Refactor sourceMgr

bridge.go

@@ -70,21 +70,17 @@ var mkBridge = func(s *solver, sm SourceManager, down bool) sourceBridge {
 	}
 }
 
-func (b *bridge) GetManifestAndLock(id ProjectIdentifier, v Version) (Manifest, Lock, error) {
+func (b *bridge) GetManifestAndLock(id ProjectIdentifier, v Version, an ProjectAnalyzer) (Manifest, Lock, error) {
 	if b.s.rd.isRoot(id.ProjectRoot) {
 		return b.s.rd.rm, b.s.rd.rl, nil
 	}
 
 	b.s.mtr.push("b-gmal")
-	m, l, e := b.sm.GetManifestAndLock(id, v)
+	m, l, e := b.sm.GetManifestAndLock(id, v, an)
 	b.s.mtr.pop()
 	return m, l, e
 }
 
-func (b *bridge) AnalyzerInfo() (string, int) {
-	return b.sm.AnalyzerInfo()
-}
-
 func (b *bridge) ListVersions(id ProjectIdentifier) ([]Version, error) {
 	if vl, exists := b.vlists[id]; exists {
 		return vl, nil

cmd.go

@@ -2,6 +2,7 @@ package gps
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 	"os/exec"
 	"sync"
@@ -11,27 +12,36 @@ import (
 )
 
 // monitoredCmd wraps a cmd and will keep monitoring the process until it
-// finishes or a certain amount of time has passed and the command showed
-// no signs of activity.
+// finishes, the provided context is canceled, or a certain amount of time has
+// passed and the command showed no signs of activity.
 type monitoredCmd struct {
 	cmd     *exec.Cmd
 	timeout time.Duration
+	ctx     context.Context
 	stdout  *activityBuffer
 	stderr  *activityBuffer
 }
 
 func newMonitoredCmd(cmd *exec.Cmd, timeout time.Duration) *monitoredCmd {
-	stdout := newActivityBuffer()
-	stderr := newActivityBuffer()
-	cmd.Stderr = stderr
-	cmd.Stdout = stdout
-	return &monitoredCmd{cmd, timeout, stdout, stderr}
+	stdout, stderr := newActivityBuffer(), newActivityBuffer()
+	cmd.Stdout, cmd.Stderr = stdout, stderr
+	return &monitoredCmd{
+		cmd:     cmd,
+		timeout: timeout,
+		stdout:  stdout,
+		stderr:  stderr,
+	}
 }
 
 // run will wait for the command to finish and return the error, if any. If the
 // command does not show any activity for more than the specified timeout the
 // process will be killed.
-func (c *monitoredCmd) run() error {
+func (c *monitoredCmd) run(ctx context.Context) error {
+	// Check for cancellation before even starting
+	if ctx.Err() != nil {
+		return ctx.Err()
+	}
+
 	ticker := time.NewTicker(c.timeout)
 	done := make(chan error, 1)
 	defer ticker.Stop()
@@ -52,6 +62,11 @@ func (c *monitoredCmd) run() error {
 
 				return &timeoutError{c.timeout}
 			}
+		case <-ctx.Done():
+			if err := c.cmd.Process.Kill(); err != nil {
+				return &killCmdError{err}
+			}
+			return c.ctx.Err()
 		case err := <-done:
 			return err
 		}
@@ -64,8 +79,8 @@ func (c *monitoredCmd) hasTimedOut() bool {
 		c.stdout.lastActivity().Before(t)
 }
 
-func (c *monitoredCmd) combinedOutput() ([]byte, error) {
-	if err := c.run(); err != nil {
+func (c *monitoredCmd) combinedOutput(ctx context.Context) ([]byte, error) {
+	if err := c.run(ctx); err != nil {
 		return c.stderr.buf.Bytes(), err
 	}
 
@@ -112,15 +127,15 @@ type killCmdError struct {
 }
 
 func (e killCmdError) Error() string {
-	return fmt.Sprintf("error killing command after timeout: %s", e.err)
+	return fmt.Sprintf("error killing command: %s", e.err)
 }
 
-func runFromCwd(cmd string, args ...string) ([]byte, error) {
+func runFromCwd(ctx context.Context, cmd string, args ...string) ([]byte, error) {
 	c := newMonitoredCmd(exec.Command(cmd, args...), 2*time.Minute)
-	return c.combinedOutput()
+	return c.combinedOutput(ctx)
 }
 
-func runFromRepoDir(repo vcs.Repo, cmd string, args ...string) ([]byte, error) {
+func runFromRepoDir(ctx context.Context, repo vcs.Repo, cmd string, args ...string) ([]byte, error) {
 	c := newMonitoredCmd(repo.CmdFromDir(cmd, args...), 2*time.Minute)
-	return c.combinedOutput()
+	return c.combinedOutput(ctx)
 }

cmd_test.go

@@ -1,6 +1,7 @@
 package gps
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"os/exec"
@@ -16,14 +17,19 @@ func mkTestCmd(iterations int) *monitoredCmd {
 }
 
 func TestMonitoredCmd(t *testing.T) {
+	// Sleeps make this a bit slow
+	if testing.Short() {
+		t.Skip("skipping test with sleeps on short")
+	}
+
 	err := exec.Command("go", "build", "./_testdata/cmd/echosleep.go").Run()
 	if err != nil {
 		t.Errorf("Unable to build echosleep binary: %s", err)
 	}
 	defer os.Remove("./echosleep")
 
 	cmd := mkTestCmd(2)
-	err = cmd.run()
+	err = cmd.run(context.Background())
 	if err != nil {
 		t.Errorf("Expected command not to fail: %s", err)
 	}
@@ -34,7 +40,7 @@ func TestMonitoredCmd(t *testing.T) {
 	}
 
 	cmd2 := mkTestCmd(10)
-	err = cmd2.run()
+	err = cmd2.run(context.Background())
 	if err == nil {
 		t.Error("Expected command to fail")
 	}