184 lines
4.3 KiB
Go
184 lines
4.3 KiB
Go
// Copyright 2018 Mikhail Klementev. All rights reserved.
|
|
// Use of this source code is governed by a AGPLv3 license
|
|
// (or later) that can be found in the LICENSE file.
|
|
|
|
package main
|
|
|
|
import (
|
|
"errors"
|
|
"io/ioutil"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"os/user"
|
|
"regexp"
|
|
"strings"
|
|
|
|
system "github.com/jollheef/go-system"
|
|
kingpin "gopkg.in/alecthomas/kingpin.v2"
|
|
)
|
|
|
|
func matchBody(url, pattern string) bool {
|
|
resp, err := http.Get(url)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := ioutil.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
|
|
matched, err := regexp.MatchString(pattern, string(body))
|
|
if err != nil {
|
|
return false
|
|
}
|
|
if !matched {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func isAptCacherExists(url string) bool {
|
|
return matchBody(url, "Apt-Cacher")
|
|
}
|
|
|
|
func runInChroot(chroot, cmd string) (string, string, int, error) {
|
|
return system.System("chroot", chroot, "/bin/sh", "-c", cmd)
|
|
}
|
|
|
|
func generateImage(repo, release, path, size string) (err error) {
|
|
log.Println("Check current user")
|
|
usr, err := user.Current()
|
|
if err != nil {
|
|
return
|
|
}
|
|
if usr.Name != "root" {
|
|
err = errors.New("Run as root is required")
|
|
return
|
|
}
|
|
|
|
log.Println("Create qcow2 image")
|
|
stdout, stderr, _, err := system.System("qemu-img", "create", path, size)
|
|
if err != nil {
|
|
log.Println(stdout, stderr)
|
|
return
|
|
}
|
|
|
|
log.Println("Create ext4 file system")
|
|
stdout, stderr, _, err = system.System("mkfs.ext4", "-F", path)
|
|
if err != nil {
|
|
log.Println(stdout, stderr)
|
|
return
|
|
}
|
|
|
|
log.Println("Create temporary directory")
|
|
stdout, stderr, _, err = system.System("mktemp", "-d")
|
|
if err != nil {
|
|
log.Println(stdout, stderr)
|
|
return
|
|
}
|
|
tmpdir := strings.TrimSpace(stdout)
|
|
defer func() {
|
|
log.Println("Remove temporary directory")
|
|
err := os.RemoveAll(tmpdir)
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
}()
|
|
|
|
log.Println("Mount qemu image")
|
|
stdout, stderr, _, err = system.System("mount", "-o", "loop", path, tmpdir)
|
|
if err != nil {
|
|
log.Println(stdout, stderr)
|
|
return
|
|
}
|
|
defer func() {
|
|
log.Println("Umount qemu image")
|
|
stdout, stderr, _, err := system.System("umount", tmpdir)
|
|
if err != nil {
|
|
log.Println(err, stdout, stderr)
|
|
}
|
|
}()
|
|
|
|
log.Println("debootstrap (may be more than 10-15 minutes)")
|
|
stdout, stderr, _, err = system.System("debootstrap",
|
|
"--include=openssh-server",
|
|
release, tmpdir, repo)
|
|
if err != nil {
|
|
log.Println(stdout, stderr)
|
|
return
|
|
}
|
|
|
|
log.Println("Create new user")
|
|
stdout, stderr, _, err = runInChroot(tmpdir, "useradd -m user")
|
|
if err != nil {
|
|
log.Println(stdout, stderr)
|
|
return
|
|
}
|
|
|
|
log.Println("Login without password")
|
|
stdout, stderr, _, err = runInChroot(tmpdir, "passwd -d root")
|
|
if err != nil {
|
|
log.Println(stdout, stderr)
|
|
return
|
|
}
|
|
stdout, stderr, _, err = runInChroot(tmpdir, "passwd -d user")
|
|
if err != nil {
|
|
log.Println(stdout, stderr)
|
|
return
|
|
}
|
|
|
|
log.Println("Allow ssh login without password (NOTE: fixed sshd pam.d)")
|
|
stdout, stderr, _, err = runInChroot(tmpdir,
|
|
"echo auth sufficient pam_permit.so > /etc/pam.d/sshd"+
|
|
" && sed -i '/PermitEmptyPasswords/d' /etc/ssh/sshd_config"+
|
|
" && echo PermitEmptyPasswords yes >> /etc/ssh/sshd_config"+
|
|
" && sed -i '/PermitRootLogin/d' /etc/ssh/sshd_config"+
|
|
" && echo PermitRootLogin yes >> /etc/ssh/sshd_config")
|
|
if err != nil {
|
|
log.Println(stdout, stderr)
|
|
return
|
|
}
|
|
|
|
log.Println("Add dhclient to rc.local")
|
|
stdout, stderr, _, err = runInChroot(tmpdir,
|
|
"echo '#!/bin/sh\ndhclient' > /etc/rc.local"+
|
|
" && chmod +x /etc/rc.local")
|
|
if err != nil {
|
|
log.Println(stdout, stderr)
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func main() {
|
|
generate := kingpin.Command("generate", "Generate qemu image")
|
|
repository := generate.Flag("repository", "Debian/ubuntu repository").Default(
|
|
"deb.debian.org/debian").String()
|
|
aptCacherURL := generate.Flag("apt-cacher", "Local apt cacher url").Default(
|
|
"http://localhost:3142/").String()
|
|
release := generate.Flag("release", "Debian/ubuntu release name").Default(
|
|
"sid").String()
|
|
size := generate.Flag("size", "Image size").Default("8G").String()
|
|
path := generate.Arg("path", "Generated image path").Required().String()
|
|
|
|
switch kingpin.Parse() {
|
|
case "generate":
|
|
repo := *repository
|
|
if isAptCacherExists(*aptCacherURL) {
|
|
log.Println("Use local apt cache")
|
|
repo = *aptCacherURL + "/" + repo
|
|
}
|
|
log.Println("Repository:", repo)
|
|
|
|
err := generateImage(repo, *release, *path, *size)
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
}
|
|
}
|