Show when bazel run exited with code

Author: KoltesDigital

internal/bazel/bazel.go

@@ -142,7 +142,6 @@ type Bazel interface {
 	Norun(args ...string) (*bytes.Buffer, error)
 	Test(args ...string) (*bytes.Buffer, error)
 	Run(args ...string) (*exec.Cmd, *bytes.Buffer, error)
-	Wait() error
 	Cancel()
 }
 
@@ -417,16 +416,6 @@ func (b *bazel) Run(args ...string) (*exec.Cmd, *bytes.Buffer, error) {
 	return b.cmd, stderrBuffer, err
 }
 
-func (b *bazel) Wait() error {
-	res := b.cmd.Wait()
-	if res.Error() == "exec: Wait was already called" {
-		if b.cmd.ProcessState.Success() {
-			return nil
-		}
-	}
-	return res
-}
-
 // Cancel the currently running operation. Useful if you call Run(target) and
 // would like to stop the action running in a goroutine.
 func (b *bazel) Cancel() {

internal/e2e/exit_code/BUILD

@@ -0,0 +1,7 @@
+load("@io_bazel_rules_go//go/tools/bazel_testing:def.bzl", "go_bazel_test")
+
+go_bazel_test(
+    name = "exit_code_test",
+    srcs = ["exit_code_test.go"],
+    deps = ["//internal/e2e"],
+)

internal/e2e/exit_code/exit_code_test.go

@@ -0,0 +1,44 @@
+package lifecycle_hooks
+
+import (
+	"testing"
+
+	"github.com/bazelbuild/bazel-watcher/internal/e2e"
+)
+
+const mainFiles = `
+-- BUILD.bazel --
+sh_binary(
+  name = "test",
+  srcs = ["test.sh"],
+)
+sh_binary(
+  name = "failure",
+  srcs = ["failure.sh"],
+)
+-- test.sh --
+-- failure.sh --
+exit 42
+`
+
+func TestMain(m *testing.M) {
+	e2e.TestMain(m, e2e.Args{
+		Main: mainFiles,
+	})
+}
+
+func TestExitCode(t *testing.T) {
+	ibazel := e2e.SetUp(t)
+	defer ibazel.Kill()
+
+	ibazel.Run([]string{}, "//:test")
+	ibazel.ExpectIBazelError("Exited \\(0\\)")
+}
+
+func TestExitCodeFailure(t *testing.T) {
+	ibazel := e2e.SetUp(t)
+	defer ibazel.Kill()
+
+	ibazel.Run([]string{}, "//:failure")
+	ibazel.ExpectIBazelError("Exited \\(42\\)")
+}

internal/ibazel/command/command.go

@@ -20,7 +20,6 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
-	"os/exec"
 	"runtime"
 	"strings"
 	"syscall"
@@ -82,42 +81,22 @@ func start(b bazel.Bazel, target string, args []string) (*bytes.Buffer, process_
 	return outputBuffer, cmd
 }
 
-func subprocessRunning(cmd *exec.Cmd) bool {
-	if cmd == nil {
-		return false
-	}
-	if cmd.Process == nil {
-		return false
-	}
-	if cmd.ProcessState != nil {
-		if cmd.ProcessState.Exited() {
-			return false
-		}
-	}
-
-	return true
-}
-
-func terminate(pg process_group.ProcessGroup) {
+func terminate(pg process_group.ProcessGroup, doneChan chan bool) {
 	pg.Signal(syscall.SIGTERM)
-	done := make(chan bool, 1)
 	go func() {
 		select {
 		case <-time.After(*waitDuration):
 			log.Logf("The subprocess wasn't terminated within %s. Forcing to close.", *waitDuration)
 			kill(pg)
-		case <-done:
+			<-doneChan
+		case <-doneChan:
 			// The subprocess was terminated with SIGTERM
 		}
 	}()
-	pg.Wait()
-	done <- true
 	pg.Close()
 }
 
 func kill(pg process_group.ProcessGroup) {
-	if subprocessRunning(pg.RootProcess()) {
-		log.Logf("Sending SIGKILL to the subprocess")
-		pg.Signal(syscall.SIGKILL)
-	}
+	log.Log("Sending SIGKILL to the subprocess")
+	pg.Signal(syscall.SIGKILL)
 }

internal/ibazel/command/command_test.go

@@ -19,8 +19,6 @@ import (
 	"testing"
 
 	"github.com/bazelbuild/bazel-watcher/internal/bazel"
-	"github.com/bazelbuild/bazel-watcher/internal/ibazel/log"
-	"github.com/bazelbuild/bazel-watcher/internal/ibazel/process_group"
 )
 
 var oldExecCommand = execCommand
@@ -37,37 +35,3 @@ func assertKilled(t *testing.T, cmd *exec.Cmd) {
 		}
 	}
 }
-
-func TestSubprocessRunning(t *testing.T) {
-	log.SetLogger(t)
-
-	execCommand = func(name string, args ...string) process_group.ProcessGroup {
-		return oldExecCommand("ls") // Every system has ls.
-	}
-	defer func() { execCommand = oldExecCommand }()
-
-	if subprocessRunning(nil) {
-		t.Errorf("Nil subprocesses don't run")
-	}
-
-	cmd := exec.Command("sleep", ".1")
-
-	if subprocessRunning(cmd) {
-		t.Errorf("New subprocess shouldn't have been started yet. State: %v", cmd.ProcessState)
-	}
-
-	if err := cmd.Start(); err != nil {
-		t.Errorf("cmd.Start(): %v", err)
-	}
-
-	if !subprocessRunning(cmd) {
-		t.Errorf("New subprocess was never started. State: %v", cmd.ProcessState)
-	}
-
-	err := cmd.Wait()
-	if err != nil {
-		t.Errorf("Subprocess finished with error: %v State: %v", err, cmd.ProcessState)
-	} else if subprocessRunning(cmd) {
-		t.Errorf("Subprocess still running State: %v", cmd.ProcessState)
-	}
-}

internal/ibazel/command/default_command.go

@@ -17,19 +17,23 @@ package command
 import (
 	"bytes"
 	"os"
+	"os/exec"
 	"sync"
+	"sync/atomic"
 
 	"github.com/bazelbuild/bazel-watcher/internal/ibazel/log"
 	"github.com/bazelbuild/bazel-watcher/internal/ibazel/process_group"
 )
 
 type defaultCommand struct {
-	target      string
-	startupArgs []string
-	bazelArgs   []string
-	args        []string
-	pg          process_group.ProcessGroup
-	termSync    sync.Once
+	target            string
+	startupArgs       []string
+	bazelArgs         []string
+	args              []string
+	pg                process_group.ProcessGroup
+	termSync          sync.Once
+	doneChan          chan bool
+	subprocessRunning atomic.Bool
 }
 
 // DefaultCommand is the normal mode of interacting with iBazel. If you start a
@@ -50,13 +54,14 @@ func (c *defaultCommand) Terminate() {
 		return
 	}
 	c.termSync.Do(func() {
-		terminate(c.pg)
+		terminate(c.pg, c.doneChan)
 	})
 	c.pg = nil
+	c.subprocessRunning.Store(false)
 }
 
 func (c *defaultCommand) Kill() {
-	if c.pg != nil {
+	if !c.IsSubprocessRunning() {
 		kill(c.pg)
 	}
 }
@@ -70,16 +75,35 @@ func (c *defaultCommand) Start() (*bytes.Buffer, error) {
 	b.WriteToStdout(true)
 
 	var outputBuffer *bytes.Buffer
-	outputBuffer, c.pg = start(b, c.target, c.args)
+	outputBuffer, pg := start(b, c.target, c.args)
+	c.pg = pg
+	doneChan := make(chan bool, 1)
+	c.doneChan = doneChan
+	c.subprocessRunning.Store(true)
 
-	c.pg.RootProcess().Env = os.Environ()
+	pg.RootProcess().Env = os.Environ()
 
 	var err error
-	if err = c.pg.Start(); err != nil {
+	if err = pg.Start(); err != nil {
 		log.Errorf("Error starting process: %v", err)
 		return outputBuffer, err
 	}
 	log.Log("Starting...")
+
+	logf := log.Logf
+	go func() {
+		err := pg.Wait()
+
+		code := 0
+		if exiterr, ok := err.(*exec.ExitError); ok {
+			code = exiterr.ExitCode()
+		}
+		logf("Exited (%d)", code)
+
+		doneChan <- true
+		c.subprocessRunning.Store(false)
+	}()
+
 	c.termSync = sync.Once{}
 	return outputBuffer, nil
 }
@@ -91,5 +115,5 @@ func (c *defaultCommand) NotifyOfChanges() *bytes.Buffer {
 }
 
 func (c *defaultCommand) IsSubprocessRunning() bool {
-	return c.pg != nil && subprocessRunning(c.pg.RootProcess())
+	return c.subprocessRunning.Load()
 }

internal/ibazel/command/default_command_test.go

@@ -57,6 +57,7 @@ func TestDefaultCommand(t *testing.T) {
 	}
 
 	toKill.Start()
+	c.subprocessRunning.Store(true)
 
 	if !c.IsSubprocessRunning() {
 		t.Errorf("New subprocess was never started. State: %v", toKill.RootProcess().ProcessState)

internal/ibazel/command/notify_command.go

@@ -18,20 +18,24 @@ import (
 	"bytes"
 	"io"
 	"os"
+	"os/exec"
 	"sync"
+	"sync/atomic"
 
 	"github.com/bazelbuild/bazel-watcher/internal/ibazel/log"
 	"github.com/bazelbuild/bazel-watcher/internal/ibazel/process_group"
 )
 
 type notifyCommand struct {
-	target      string
-	startupArgs []string
-	bazelArgs   []string
-	args        []string
-	pg          process_group.ProcessGroup
-	stdin       io.WriteCloser
-	termSync    sync.Once
+	target            string
+	startupArgs       []string
+	bazelArgs         []string
+	args              []string
+	pg                process_group.ProcessGroup
+	stdin             io.WriteCloser
+	termSync          sync.Once
+	doneChan          chan bool
+	subprocessRunning atomic.Bool
 }
 
 // NotifyCommand is an alternate mode for starting a command. In this mode the
@@ -51,13 +55,14 @@ func (c *notifyCommand) Terminate() {
 		return
 	}
 	c.termSync.Do(func() {
-		terminate(c.pg)
+		terminate(c.pg, c.doneChan)
 	})
 	c.pg = nil
+	c.subprocessRunning.Store(false)
 }
 
 func (c *notifyCommand) Kill() {
-	if c.pg != nil {
+	if !c.IsSubprocessRunning() {
 		kill(c.pg)
 	}
 }
@@ -71,22 +76,42 @@ func (c *notifyCommand) Start() (*bytes.Buffer, error) {
 	b.WriteToStdout(true)
 
 	var outputBuffer *bytes.Buffer
-	outputBuffer, c.pg = start(b, c.target, c.args)
+	outputBuffer, pg := start(b, c.target, c.args)
+	c.pg = pg
+	doneChan := make(chan bool, 1)
+	c.doneChan = doneChan
+	c.subprocessRunning.Store(true)
+
 	// Keep the writer around.
 	var err error
-	c.stdin, err = c.pg.RootProcess().StdinPipe()
+	c.stdin, err = pg.RootProcess().StdinPipe()
 	if err != nil {
 		log.Errorf("Error getting stdin pipe: %v", err)
 		return outputBuffer, err
 	}
 
-	c.pg.RootProcess().Env = append(os.Environ(), "IBAZEL_NOTIFY_CHANGES=y")
+	pg.RootProcess().Env = append(os.Environ(), "IBAZEL_NOTIFY_CHANGES=y")
 
-	if err = c.pg.Start(); err != nil {
+	if err = pg.Start(); err != nil {
 		log.Errorf("Error starting process: %v", err)
 		return outputBuffer, err
 	}
 	log.Log("Starting...")
+
+	logf := log.Logf
+	go func() {
+		err := pg.Wait()
+
+		code := 0
+		if exiterr, ok := err.(*exec.ExitError); ok {
+			code = exiterr.ExitCode()
+		}
+		logf("Exited (%d)", code)
+
+		doneChan <- true
+		c.subprocessRunning.Store(false)
+	}()
+
 	c.termSync = sync.Once{}
 	return outputBuffer, nil
 }
@@ -127,5 +152,5 @@ func (c *notifyCommand) NotifyOfChanges() *bytes.Buffer {
 }
 
 func (c *notifyCommand) IsSubprocessRunning() bool {
-	return c.pg != nil && subprocessRunning(c.pg.RootProcess())
+	return c.subprocessRunning.Load()
 }