[env-mf] Introduce an environment manifest to capture the build env

fixes #29

Author: Christian Weichel

README.md

@@ -201,6 +201,23 @@ This workspace has a (nonsensical) `nogo` variant that, when enabled, excludes a
 It also changes the config of all Go packages to include the `-tags foo` flag. You can explore the effects of a variant using `collect` and `describe`, e.g. `leeway --variant nogo collect files` vs `leeway collect files`.
 You can list all variants in a workspace using `leeway collect variants`.
 
+## Environment Manifest
+Leeway does not control the environment in which it builds the packages, but assumes that all required tools are available already (e.g. `go` or `yarn`).
+This however can lead to subtle failure modes where a package built in one enviroment ends up being used in another, because no matter of the environment they were built in, they get the same version.
+
+To prevent such issues, leeway computes an _environment manifest_ which contains the versions of the tools used, as well as some platform information.
+The entries in that manifest depend on the package types used by that workspace, e.g. if only `Go` packages exist in the workspace, only `go version`, [GOOS and GOARCH](https://golang.org/pkg/runtime/#pkg-constants) will be part of the manifest.
+You can inspect a workspace's environment manifest using `leeway describe environment-manifest`. 
+
+You can add your own entries to a workspace's environment manifest in the `WORKSPACE.yaml` like so:
+```YAML
+environmentManifest:
+  - name: gcc
+    command: ["gcc", "--version"]
+```
+
+Using this mechanism you can also overwrite the default manifest entries, e.g. "go" or "yarn".
+
 ## Nested Workspaces
 Leeway has some experimental support for nested workspaces, e.g. a structure like this one:
 ```

WORKSPACE.yaml

@@ -1,6 +1,11 @@
 defaultTarget: "//:app"
 defaultArgs:
   version: dev
+environmentManifest:
+  - name: "node"
+    command: ["node", "--version"]
+  - name: "yarn"
+    command: ["yarn", "--version"]
 variants:
 - name: nogit
   srcs:

cmd/describe-environment-manifest.go

@@ -0,0 +1,29 @@
+package cmd
+
+import (
+	"os"
+
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+)
+
+// describeEnvironmentManifestCmd represents the describeManifest command
+var describeEnvironmentManifestCmd = &cobra.Command{
+	Use:   "environment-manifest",
+	Short: "Prints the environment manifest of a workspace",
+	Run: func(cmd *cobra.Command, args []string) {
+		ws, err := getWorkspace()
+		if err != nil {
+			log.WithError(err).Fatal("cannot load workspace")
+		}
+
+		err = ws.EnvironmentManifest.Write(os.Stdout)
+		if err != nil {
+			log.Fatal(err)
+		}
+	},
+}
+
+func init() {
+	describeCmd.AddCommand(describeEnvironmentManifestCmd)
+}

fixtures/nested-ws/wsa/WORKSPACE.yaml

@@ -1,2 +1,5 @@
 defaultArgs:
-  message: "hello world"
+  message: "hello world"
+environmentManifest:
+  - name: "foobar"
+    command: ["echo", "foobar"]

pkg/leeway/package.go

@@ -569,7 +569,7 @@ func (v *PackageVariant) ResolveSources(workspace *Workspace, loc string) (incl
 
 func resolveSources(workspace *Workspace, loc string, globs []string, includeDirs bool) (res []string, err error) {
 	for _, glb := range globs {
-		srcs, err := doublestar.Glob(loc, glb, workspace.ShouldIngoreSource)
+		srcs, err := doublestar.Glob(loc, glb, workspace.ShouldIgnoreSource)
 		if err != nil {
 			return nil, err
 		}
@@ -582,7 +582,7 @@ func resolveSources(workspace *Workspace, loc string, globs []string, includeDir
 			if !includeDirs && stat.IsDir() {
 				continue
 			}
-			if workspace.ShouldIngoreSource(src) {
+			if workspace.ShouldIgnoreSource(src) {
 				continue
 			}
 			res = append(res, src)
@@ -785,6 +785,10 @@ func (p *Package) WriteVersionManifest(out io.Writer) error {
 		return xerrors.Errorf("package is not linked")
 	}
 
+	envhash, err := p.C.W.EnvironmentManifest.Hash()
+	if err != nil {
+		return err
+	}
 	defhash, err := p.DefinitionHash()
 	if err != nil {
 		return err
@@ -798,6 +802,10 @@ func (p *Package) WriteVersionManifest(out io.Writer) error {
 	if err != nil {
 		return err
 	}
+	_, err = fmt.Fprintf(out, "environment: %s\n", envhash)
+	if err != nil {
+		return err
+	}
 	_, err = fmt.Fprintf(out, "definition: %s\n", defhash)
 	if err != nil {
 		return err

pkg/leeway/workspace.go

@@ -1,18 +1,25 @@
 package leeway
 
 import (
+	"bytes"
 	"context"
+	"encoding/hex"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"reflect"
+	"runtime"
 	"runtime/trace"
 	"sort"
 	"strings"
 	"sync"
+	"time"
 
 	"github.com/imdario/mergo"
+	"github.com/minio/highwayhash"
 	log "github.com/sirupsen/logrus"
 	"github.com/typefox/leeway/pkg/doublestar"
 	"golang.org/x/sync/errgroup"
@@ -23,9 +30,10 @@ import (
 // Workspace is the root container of all compoments. All components are named relative
 // to the origin of this workspace.
 type Workspace struct {
-	DefaultTarget    string            `yaml:"defaultTarget,omitempty"`
-	ArgumentDefaults map[string]string `yaml:"defaultArgs,omitempty"`
-	Variants         []*PackageVariant `yaml:"variants,omitempty"`
+	DefaultTarget       string              `yaml:"defaultTarget,omitempty"`
+	ArgumentDefaults    map[string]string   `yaml:"defaultArgs,omitempty"`
+	Variants            []*PackageVariant   `yaml:"variants,omitempty"`
+	EnvironmentManifest EnvironmentManifest `yaml:"environmentManifest,omitempty"`
 
 	Origin          string                `yaml:"-"`
 	Components      map[string]*Component `yaml:"-"`
@@ -36,13 +44,79 @@ type Workspace struct {
 	ignores []string
 }
 
-// ShouldIngoreComponent returns true if a file should be ignored for a component listing
-func (ws *Workspace) ShouldIngoreComponent(path string) bool {
-	return ws.ShouldIngoreSource(path)
+// EnvironmentManifest is a collection of environment manifest entries
+type EnvironmentManifest []EnvironmentManifestEntry
+
+// Write writes the manifest to the writer
+func (mf EnvironmentManifest) Write(out io.Writer) error {
+	for _, e := range mf {
+		_, err := fmt.Fprintf(out, "%s: %s\n", e.Name, e.Value)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Hash produces the hash of this manifest
+func (mf EnvironmentManifest) Hash() (string, error) {
+	key, err := hex.DecodeString(contentHashKey)
+	if err != nil {
+		return "", err
+	}
+
+	hash, err := highwayhash.New(key)
+	if err != nil {
+		return "", err
+	}
+
+	err = mf.Write(hash)
+	if err != nil {
+		return "", err
+	}
+
+	return hex.EncodeToString(hash.Sum(nil)), nil
+}
+
+// EnvironmentManifestEntry represents an entry in the environment manifest
+type EnvironmentManifestEntry struct {
+	Name    string   `yaml:"name"`
+	Command []string `yaml:"command"`
+
+	Value   string `yaml:"-"`
+	Builtin bool   `yaml:"-"`
+}
+
+const (
+	builtinEnvManifestGOOS   = "goos"
+	builtinEnvManifestGOARCH = "goarch"
+)
+
+var defaultEnvManifestEntries = map[PackageType]EnvironmentManifest{
+	"": []EnvironmentManifestEntry{
+		{Name: "os", Command: []string{builtinEnvManifestGOOS}, Builtin: true},
+		{Name: "arch", Command: []string{builtinEnvManifestGOARCH}, Builtin: true},
+	},
+	GenericPackage: []EnvironmentManifestEntry{},
+	DockerPackage: []EnvironmentManifestEntry{
+		{Name: "docker", Command: []string{"docker", "version", "--format", "{{.Client.Version}} {{.Server.Version}}"}},
+	},
+	GoPackage: []EnvironmentManifestEntry{
+		{Name: "go", Command: []string{"go", "version"}},
+	},
+	YarnPackage: []EnvironmentManifestEntry{
+		{Name: "yarn", Command: []string{"yarn", "-v"}},
+		{Name: "node", Command: []string{"node", "--version"}},
+	},
+}
+
+// ShouldIgnoreComponent returns true if a file should be ignored for a component listing
+func (ws *Workspace) ShouldIgnoreComponent(path string) bool {
+	return ws.ShouldIgnoreSource(path)
 }
 
-// ShouldIngoreSource returns true if a file should be ignored for a source listing
-func (ws *Workspace) ShouldIngoreSource(path string) bool {
+// ShouldIgnoreSource returns true if a file should be ignored for a source listing
+func (ws *Workspace) ShouldIgnoreSource(path string) bool {
 	for _, ptn := range ws.ignores {
 		if strings.Contains(path, ptn) {
 			return true
@@ -199,7 +273,7 @@ func loadWorkspace(ctx context.Context, path string, args Arguments, variant str
 		}
 		ignores = strings.Split(string(fc), "\n")
 	}
-	otherWS, err := doublestar.Glob(workspace.Origin, "**/WORKSPACE.yaml", workspace.ShouldIngoreSource)
+	otherWS, err := doublestar.Glob(workspace.Origin, "**/WORKSPACE.yaml", workspace.ShouldIgnoreSource)
 	if err != nil {
 		return Workspace{}, err
 	}
@@ -212,7 +286,7 @@ func loadWorkspace(ctx context.Context, path string, args Arguments, variant str
 		ignores = append(ignores, dir)
 	}
 	workspace.ignores = ignores
-	log.WithField("ingores", workspace.ignores).Debug("computed workspace ignores")
+	log.WithField("ignores", workspace.ignores).Debug("computed workspace ignores")
 
 	if len(opts.ArgumentDefaults) > 0 {
 		if workspace.ArgumentDefaults == nil {
@@ -245,17 +319,26 @@ func loadWorkspace(ctx context.Context, path string, args Arguments, variant str
 	workspace.Components = make(map[string]*Component)
 	workspace.Packages = make(map[string]*Package)
 	workspace.Scripts = make(map[string]*Script)
+	packageTypesUsed := make(map[PackageType]struct{})
 	for _, comp := range comps {
 		workspace.Components[comp.Name] = comp
 
 		for _, pkg := range comp.Packages {
 			workspace.Packages[pkg.FullName()] = pkg
+			packageTypesUsed[pkg.Type] = struct{}{}
 		}
 		for _, script := range comp.Scripts {
 			workspace.Scripts[script.FullName()] = script
 		}
 	}
 
+	// with all packages loaded we can compute the env manifest, becuase now we know which package types are actually
+	// used, hence know the default env manifest entries.
+	workspace.EnvironmentManifest, err = buildEnvironmentManifest(workspace.EnvironmentManifest, packageTypesUsed)
+	if err != nil {
+		return Workspace{}, err
+	}
+
 	// now that we have all components/packages, we can link things
 	if opts != nil && opts.PrelinkModifier != nil {
 		opts.PrelinkModifier(workspace.Packages)
@@ -298,6 +381,55 @@ func loadWorkspace(ctx context.Context, path string, args Arguments, variant str
 	return workspace, nil
 }
 
+// buildEnvironmentManifest executes the commands of an env manifest and updates the values
+func buildEnvironmentManifest(entries EnvironmentManifest, pkgtpes map[PackageType]struct{}) (res EnvironmentManifest, err error) {
+	t0 := time.Now()
+
+	envmf := make(map[string]EnvironmentManifestEntry, len(entries))
+	for _, e := range defaultEnvManifestEntries[""] {
+		envmf[e.Name] = e
+	}
+	for tpe := range pkgtpes {
+		for _, e := range defaultEnvManifestEntries[tpe] {
+			envmf[e.Name] = e
+		}
+	}
+	for _, e := range entries {
+		e := e
+		envmf[e.Name] = e
+	}
+
+	for k, e := range envmf {
+		if e.Builtin {
+			switch e.Command[0] {
+			case builtinEnvManifestGOARCH:
+				e.Value = runtime.GOARCH
+			case builtinEnvManifestGOOS:
+				e.Value = runtime.GOOS
+			}
+			res = append(res, e)
+			continue
+		}
+
+		out := bytes.NewBuffer(nil)
+		cmd := exec.Command(e.Command[0], e.Command[1:]...)
+		cmd.Stdout = out
+		err := cmd.Run()
+		if err != nil {
+			return nil, xerrors.Errorf("cannot resolve env manifest entry %v: %w", k, err)
+		}
+		e.Value = strings.TrimSpace(out.String())
+
+		res = append(res, e)
+	}
+
+	sort.Slice(res, func(i, j int) bool { return res[i].Name < res[j].Name })
+
+	log.WithField("time", time.Since(t0).String()).WithField("res", res).Debug("built environment manifest")
+
+	return
+}
+
 // FindWorkspace looks for a WORKSPACE.yaml file within the path. If multiple such files are found,
 // an error is returned.
 func FindWorkspace(path string, args Arguments, variant string) (Workspace, error) {
@@ -309,7 +441,7 @@ func discoverComponents(ctx context.Context, workspace *Workspace, args Argument
 	defer trace.StartRegion(context.Background(), "discoverComponents").End()
 
 	path := workspace.Origin
-	pths, err := doublestar.Glob(path, "**/BUILD.yaml", workspace.ShouldIngoreSource)
+	pths, err := doublestar.Glob(path, "**/BUILD.yaml", workspace.ShouldIgnoreSource)
 	if err != nil {
 		return nil, err
 	}
@@ -318,7 +450,7 @@ func discoverComponents(ctx context.Context, workspace *Workspace, args Argument
 	cchan := make(chan *Component, 20)
 
 	for _, pth := range pths {
-		if workspace.ShouldIngoreComponent(pth) {
+		if workspace.ShouldIgnoreComponent(pth) {
 			continue
 		}
 

pkg/leeway/workspace_test.go

@@ -6,6 +6,7 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 )
 
@@ -72,6 +73,19 @@ func TestFixtureLoadWorkspace(t *testing.T) {
 			StdoutSub: "hello root",
 			ExitCode:  0,
 		},
+		{
+			Name: "environment manifest",
+			T: t,
+			Args: []string{"describe", "-w", "fixtures/nested-ws/wsa", "environment-manifest"},
+			Eval: func(t *testing.T, stdout, stderr string) {
+				for _, k := range []string{"os", "arch", "foobar"} {
+					if !strings.Contains(stdout, fmt.Sprintf("%s: ", k)) {
+						t.Errorf("missing %s entry in environment manifest", k)
+					}
+				}
+			},
+			ExitCode: 0,
+		},
 	}
 
 	for _, test := range tests {

pkg/vet/docker_test.go

@@ -62,7 +62,7 @@ ADD from-some-pkg--build/hello.txt hello.txt`,
 			// defer os.RemoveAll(tmpdir)
 
 			var pkgdeps string
-			failOnErr(ioutil.WriteFile(filepath.Join(tmpdir, "WORKSPACE.yaml"), nil, 0644))
+			failOnErr(ioutil.WriteFile(filepath.Join(tmpdir, "WORKSPACE.yaml"), []byte("environmentManifest:\n  - name: \"docker\"\n    command: [\"echo\"]"), 0644))
 			for _, dep := range test.Deps {
 				segs := strings.Split(dep, ":")
 				loc := filepath.Join(tmpdir, segs[0])