tool.go

package building

import (
	"archive/tar"
	"bytes"
	"flag"
	"io"
	"os"
	"os/exec"
	"path"
	"path/filepath"
	"runtime"
	"strings"
	"sync"
	"syscall"
)

var (
	AlpineVersion = "3.8"

	containers = flag.Bool("containers", false, "always build in containers")
	cross      = flag.Bool("cross", false, "build for all platforms (linux, darwin, windows)")
	parallel   = flag.Bool("parallel", false, "build in parallel")
)

func init() {
	// Manual flags parsing to enable containers before any actual work
	for _, arg := range os.Args {
		if arg == "-containers" {
			*containers = true
			return
		}
	}
}

type Tool struct {
	root         string
	name         string
	url          string
	dir          string
	env          []string
	instructions string
	names        string
	container    bool
	output       io.Writer
	input        io.Reader
	success      bool
}

func (t Tool) WithDir(dir string) Tool {
	dir = filepath.Clean(dir)
	if filepath.IsAbs(dir) {
		b.Fatalln("dir must be relative", dir)
	}
	if strings.Contains(dir, "..") {
		b.Fatalln("dir must be a folder under project root", dir)
	}
	t.dir = dir
	return t
}

func (t Tool) WithEnv(env ...string) Tool {
	t.env = append(t.env, env...)
	return t
}

func (t Tool) WithOutput(w io.Writer) Tool {
	t.output = w
	return t
}

func (t Tool) WithInput(r io.Reader) Tool {
	t.input = r
	return t
}

func (t Tool) WithSuccess() Tool {
	t.success = true
	return t
}

func (t Tool) WithTool(tool Tool) Tool {
	t.instructions += "\n" + tool.instructions
	if t.container || tool.container {
		t.container = true
		t.names += "-" + tool.name
		t.buildImage()
	}
	return t
}

func (b *B) MakeTool(name, check, url, instructions string, args ...string) Tool {
	t := b.makeTool(name, check, url, instructions)
	if len(args) > 0 {
		t.Run(args...)
	}
	return t
}

func (b *B) makeTool(name, check, url, instructions string) Tool {
	b.mutex.Lock()
	defer b.mutex.Unlock()
	if t, ok := b.tools[name]; ok {
		return t
	}
	t := Tool{
		root:         b.root,
		name:         name,
		url:          url,
		instructions: instructions,
		names:        name,
		container:    noApplication(name, check),
	}
	if t.container && name != "" && url != "" && !*containers {
		b.Print("missing " + name + ": consider installing it to speed up the build, see " + url)
	}
	if t.container {
		t.buildImage()
	}
	b.tools[name] = t
	return t
}

func (b *B) WithOS(f func(goos string)) {
	platforms := []string{runtime.GOOS}
	if *cross {
		platforms = []string{"linux", "darwin", "windows"}
	}
	wg := sync.WaitGroup{}
	for _, goos := range platforms {
		b.Println("building for", goos)
		if *parallel {
			wg.Add(1)
			go func(goos string) {
				f(goos)
				wg.Done()
			}(goos)
		} else {
			f(goos)
		}
	}
	wg.Wait()
}

func noApplication(name, check string) bool {
	b.Debugln("checking for", name)
	cmd := exec.Command(name)
	if check != "" {
		cmd = exec.Command(name, check)
	}
	err := cmd.Run()
	if err == nil {
		return *containers
	}
	_, ok := err.(*exec.ExitError)
	return !ok
}

func (t Tool) buildImage() {
	b.Println("preparing image for", t.name)
	buf := &bytes.Buffer{}
	tarFile(t.instructions, "Dockerfile", buf)
	cmd := exec.Command("docker", "build", "-t", t.image(), "-")
	cmd.Stderr = os.Stderr
	if isDebug() {
		cmd.Stdout = os.Stdout
	}
	cmd.Stdin = buf
	if err := cmd.Run(); err != nil {
		b.Fatalln(err)
	}
}

func (t Tool) image() string {
	if t.root == "" {
		b.Fatalln("missing root")
	}
	return strings.Replace(t.root, "/", "-", -1) + "-build-" + t.names
}

func tarFile(content, filename string, writer io.Writer) {
	tw := tar.NewWriter(writer)
	hdr := &tar.Header{
		Name: filename,
		Mode: 0600,
		Size: int64(len(content)),
	}
	if err := tw.WriteHeader(hdr); err != nil {
		b.Fatal(err)
	}
	if _, err := tw.Write([]byte(content)); err != nil {
		b.Fatal(err)
	}
	if err := tw.Close(); err != nil {
		b.Fatal(err)
	}
}

func (t Tool) Run(args ...string) int {
	if t.output == nil {
		t.output = os.Stdout
	}
	if t.input == nil {
		t.input = os.Stdin
	}
	t.print(args)
	if t.container {
		return t.runContainer(args)
	}
	return t.runApplication(args)
}

func (t Tool) runApplication(args []string) int {
	if t.dir != "" {
		err := os.MkdirAll(t.dir, 0755)
		if err != nil {
			b.Fatal(err)
		}
	}
	cmd := exec.Command(t.name, args...)
	cmd.Dir = t.dir
	cmd.Env = append(os.Environ(), t.env...)
	cmd.Stderr = os.Stderr
	cmd.Stdout = t.output
	cmd.Stdin = t.input
	code, err := run(cmd, t.success)
	if err != nil {
		b.Fatal(err)
	}
	return code
}

func (t Tool) print(args []string) {
	prefix := "running"
	if t.container {
		prefix += " [container]"
	}
	if t.dir != "" {
		prefix += " (in " + t.dir + ")"
	}
	b.Println(prefix, append([]string{t.name}, args...))
}

func (t Tool) runContainer(args []string) int {
	// $$$$ MAT error out if docker in windows containers mode
	wd, err := os.Getwd()
	if err != nil {
		b.Fatalln(err)
	}
	if t.root == "" {
		b.Fatalln("missing root")
	}
	w := path.Join("/go/src", t.root, t.dir)
	// $$$$ MAT create w if needed
	var envs []string
	for _, e := range t.env {
		envs = append(envs, "-e", e)
	}
	// $$$$ MAT use --net=none by default and allow to customize by tool
	arg := append([]string{"run", "--rm", "-v", wd + ":" + w, "-w", w, "-i"}, envs...)
	arg = append(arg, t.image(), t.name)
	// $$$$ MAT try and replace wd in args with w ?
	// $$$$ do the same with TEMPDIR -> /tmp, and mount it ? any dir ?
	// $$$$ MAT if GOPATH set, mount it instead of wd ?
	arg = append(arg, args...)
	b.Debugln("running", append([]string{"docker"}, arg...))
	cmd := exec.Command("docker", arg...)
	cmd.Stderr = os.Stderr
	cmd.Stdout = t.output
	cmd.Stdin = t.input
	code, err := run(cmd, t.success)
	if err != nil {
		b.Fatalln(err)
	}
	return code
}

func run(cmd *exec.Cmd, success bool) (int, error) {
	if err := cmd.Run(); err != nil {
		exit, ok := err.(*exec.ExitError)
		if ok {
			if success {
				err = nil
			}
			if status, ok := exit.Sys().(syscall.WaitStatus); ok {
				return status.ExitStatus(), err
			}
		}
		return 1, err
	}
	return 0, nil
}