Add support to install go from source

cmd.go

@@ -0,0 +1,108 @@
+package gvm
+
+import (
+	"bufio"
+	"io"
+	"os"
+	"os/exec"
+	"sync"
+
+	"github.com/Sirupsen/logrus"
+)
+
+type command struct {
+	Path   string
+	Args   []string
+	Dir    string
+	Env    []string
+	Stdout func(string)
+	Stderr func(string)
+}
+
+func makeCommand(cmd string, args ...string) *command {
+	return &command{
+		Path: cmd,
+		Args: args,
+	}
+}
+
+func (c *command) WithLogger(log logrus.FieldLogger) *command {
+	if c.Stdout == nil {
+		c.Stdout = infoOutLog(log)
+	}
+	if c.Stderr == nil {
+		c.Stderr = errOutLog(log)
+	}
+	return c
+}
+
+func (c *command) WithDir(dir string) *command {
+	c.Dir = dir
+	return c
+}
+
+func infoOutLog(log logrus.FieldLogger) func(string) {
+	return makeOutLog(log.Info)
+}
+
+func errOutLog(log logrus.FieldLogger) func(string) {
+	return makeOutLog(log.Error)
+}
+
+func makeOutLog(fn func(...interface{})) func(string) {
+	return func(text string) { fn(text) }
+}
+
+func (c *command) Exec() error {
+	cmd := exec.Command(c.Path, c.Args...)
+	cmd.Dir = c.Dir
+
+	if len(c.Env) > 0 {
+		cmd.Env = append(os.Environ(), c.Env...)
+	}
+
+	var err error
+	var stdout, stderr io.ReadCloser
+	if c.Stdout != nil {
+		stdout, err = cmd.StdoutPipe()
+		if err != nil {
+			return err
+		}
+		defer stdout.Close()
+	}
+
+	if c.Stderr != nil {
+		stderr, err = cmd.StderrPipe()
+		if err != nil {
+			return err
+		}
+		defer stderr.Close()
+	}
+
+	var wg sync.WaitGroup
+	defer wg.Wait()
+
+	captureLines := func(in io.Reader, fn func(string)) {
+		defer wg.Done()
+		scanner := bufio.NewScanner(in)
+		for scanner.Scan() {
+			text := scanner.Text()
+			fn(text)
+		}
+	}
+
+	if stdout != nil {
+		wg.Add(1)
+		go captureLines(stdout, c.Stdout)
+	}
+	if stderr != nil {
+		wg.Add(1)
+		go captureLines(stderr, c.Stderr)
+	}
+
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+
+	return cmd.Wait()
+}

cmd/gvm/avail.go

@@ -9,13 +9,17 @@ import (
 
 func availCommand(cmd *kingpin.CmdClause) func(*gvm.Manager) error {
 	return func(manager *gvm.Manager) error {
-		list, err := manager.Available()
+		list, hasBin, err := manager.Available()
 		if err != nil {
 			return err
 		}
 
-		for _, v := range list {
-			fmt.Println(v)
+		for i, v := range list {
+			if hasBin[i] {
+				fmt.Printf("%v\t(source, binary)\n", v)
+			} else {
+				fmt.Printf("%v\t(source)\n", v)
+			}
 		}
 		return nil
 	}

cmd/gvm/gvm.go

@@ -48,8 +48,15 @@ func main() {
 		return cmd
 	}
 
+	app.Flag("os", "Go binaries target os.").StringVar(&manager.GOOS)
+	app.Flag("arch", "Go binaries target architecture.").StringVar(&manager.GOOS)
+	app.Flag("home", "GVM home directory.").StringVar(&manager.Home)
+	app.Flag("url", "Go binaries repository base URL.").StringVar(&manager.GoStorageHome)
+	app.Flag("repository", "Go upstream git repository.").StringVar(&manager.GoSourceURL)
+
 	command(useCommand, "use", "prepare go version and print environment variables").
 		Default()
+	command(initCommand, "init", "init .gvm and update source cache")
 	command(installCommand, "install", "install go version if not already installed")
 	command(availCommand, "available", "list all installable go versions")
 	command(listCommand, "list", "list installed versions")

cmd/gvm/init.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"github.com/andrewkroh/gvm"
+	kingpin "gopkg.in/alecthomas/kingpin.v2"
+)
+
+func initCommand(cmd *kingpin.CmdClause) func(*gvm.Manager) error {
+	return func(manager *gvm.Manager) error {
+		return manager.UpdateCache()
+	}
+}

cmd/gvm/install.go

@@ -9,6 +9,8 @@ import (
 
 func installCommand(cmd *kingpin.CmdClause) func(*gvm.Manager) error {
 	var version string
+	var build bool
+	cmd.Flag("build", "Build go version from source").Short('b').BoolVar(&build)
 	cmd.Arg("version", "Go version to install (e.g. 1.10).").StringVar(&version)
 
 	return func(manager *gvm.Manager) error {
@@ -29,8 +31,14 @@ func installCommand(cmd *kingpin.CmdClause) func(*gvm.Manager) error {
 			return nil
 		}
 
-		fmt.Printf("Installing go-%v. Please wait...\n", version)
-		dir, err := manager.Install(ver)
+		var dir string
+		if build {
+			fmt.Printf("Building go-%v. Please wait...\n", version)
+			dir, err = manager.Build(ver)
+		} else {
+			fmt.Printf("Installing go-%v. Please wait...\n", version)
+			dir, err = manager.Install(ver)
+		}
 		if err != nil {
 			fmt.Println("Installation failed with:\n", err)
 			return err

cmd/gvm/use.go

@@ -11,13 +11,15 @@ import (
 
 type useCmd struct {
 	version string
+	build   bool
 	format  string
 }
 
 func useCommand(cmd *kingpin.CmdClause) func(*gvm.Manager) error {
 	ctx := &useCmd{}
 
 	cmd.Arg("version", "Go version to install (e.g. 1.10).").StringVar(&ctx.version)
+	cmd.Flag("build", "Build go version from source").Short('b').BoolVar(&ctx.build)
 	cmd.Flag("format", "Format to use for the shell commands. Options: bash, batch, powershell").
 		Short('f').
 		Default(shellfmt.DefaultFormat()).
@@ -41,7 +43,12 @@ func (cmd *useCmd) Run(manager *gvm.Manager) error {
 		return err
 	}
 
-	goroot, err := manager.Install(ver)
+	var goroot string
+	if cmd.build {
+		goroot, err = manager.Build(ver)
+	} else {
+		goroot, err = manager.Install(ver)
+	}
 	if err != nil {
 		return err
 	}

gvm.go

@@ -7,6 +7,8 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
+
+	"github.com/Sirupsen/logrus"
 )
 
 type Manager struct {
@@ -23,8 +25,16 @@ type Manager struct {
 	// Defaults to https://storage.googleapis.com/golang
 	GoStorageHome string
 
+	// GoSourceURL configres the update git repository to download and update local
+	// source checkouts from.
+	// Defaults to https://go.googlesource.com/go
+	GoSourceURL string
+
+	Logger logrus.FieldLogger
+
 	cacheDir    string
 	versionsDir string
+	logsDir     string
 }
 
 func (m *Manager) Init() error {
@@ -41,6 +51,10 @@ func (m *Manager) Init() error {
 		m.GoStorageHome = "https://storage.googleapis.com/golang"
 	}
 
+	if m.GoSourceURL == "" {
+		m.GoSourceURL = "https://go.googlesource.com/go"
+	}
+
 	if m.GOOS == "" {
 		m.GOOS = runtime.GOOS
 	}
@@ -54,22 +68,59 @@ func (m *Manager) Init() error {
 		}
 	}
 
+	if m.Logger == nil {
+		m.Logger = logrus.StandardLogger()
+	}
+
 	m.cacheDir = filepath.Join(m.Home, "cache")
 	m.versionsDir = filepath.Join(m.Home, "versions")
+	m.logsDir = filepath.Join(m.Home, "logs")
 	return m.ensureDirStruct()
 }
 
+func (m *Manager) UpdateCache() error {
+	return m.updateSrcCache()
+}
+
 func (m *Manager) ensureDirStruct() error {
-	for _, dir := range []string{m.cacheDir, m.versionsDir} {
+	for _, dir := range []string{m.cacheDir, m.versionsDir, m.logsDir} {
 		if err := os.MkdirAll(dir, os.ModeDir|0755); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func (m *Manager) Available() ([]*GoVersion, error) {
-	return m.AvailableBinaries()
+func (m *Manager) Available() ([]*GoVersion, []bool, error) {
+	if !m.hasSrcCache() {
+		versions, err := m.AvailableBinaries()
+		if err != nil {
+			return nil, nil, err
+		}
+
+		hasBin := make([]bool, len(versions))
+		for i := range hasBin {
+			hasBin[i] = true
+		}
+		return versions, hasBin, nil
+	}
+
+	src, err := m.AvailableSource()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	hasBin := make([]bool, len(src))
+	bin, err := m.AvailableBinaries()
+	if err != nil {
+		return src, hasBin, nil
+	}
+
+	for i, ver := range src {
+		hasBin[i] = findVersion(ver, bin) >= 0
+	}
+
+	return src, hasBin, nil
 }
 
 func (m *Manager) Remove(version *GoVersion) error {
@@ -128,7 +179,27 @@ func (m *Manager) versionDir(version *GoVersion) string {
 	return fmt.Sprintf("go%v.%v.%v", version, m.GOOS, m.GOARCH)
 }
 
+func (m *Manager) Build(version *GoVersion) (string, error) {
+	if version.IsTip() {
+		return m.ensureUpToDateTip()
+	}
+
+	has, err := m.HasVersion(version)
+	if err != nil {
+		return "", err
+	}
+	if has {
+		return m.VersionGoROOT(version), nil
+	}
+
+	return m.installSrc(version)
+}
+
 func (m *Manager) Install(version *GoVersion) (string, error) {
+	if version.IsTip() {
+		return m.ensureUpToDateTip()
+	}
+
 	has, err := m.HasVersion(version)
 	if err != nil {
 		return "", err
@@ -137,5 +208,37 @@ func (m *Manager) Install(version *GoVersion) (string, error) {
 		return m.VersionGoROOT(version), nil
 	}
 
-	return m.installBinary(version)
+	tryBinary := !version.IsTip()
+	if tryBinary {
+		dir, err := m.installBinary(version)
+		if err == nil {
+			return dir, err
+		}
+	}
+
+	return m.installSrc(version)
+}
+
+func (m *Manager) ensureUpToDateTip() (string, error) {
+	version, _ := ParseVersion("tip")
+
+	has, err := m.HasVersion(version)
+	if err != nil {
+		return "", err
+	}
+
+	// no updates since last build -> return installed version
+	if has {
+		updates, err := m.tryRefreshSrcCache()
+		if err != nil {
+			return "", err
+		}
+
+		if !updates {
+			return m.VersionGoROOT(version), nil
+		}
+	}
+
+	// new updates in cache -> rebuild
+	return m.installSrc(version)
 }