Add pre-exec hook identical to pre-bootstrap

agent/job_runner.go

@@ -6,6 +6,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -268,6 +269,34 @@ func NewJobRunner(l logger.Logger, scope *metrics.Scope, ag *api.AgentRegisterRe
 	return runner, nil
 }
 
+type hookExit struct {
+	ExitStatus   int
+	SignalReason string
+	Ok           bool
+}
+
+func (r *JobRunner) preExecHook(ctx context.Context, hookName string) hookExit {
+	exit := hookExit{Ok: true}
+	if hookPath, _ := hook.Find(r.conf.AgentConfiguration.HooksPath, hookName); hookPath != "" {
+		// Once we have a hook any failure to run it MUST be fatal to the job to guarantee a true
+		// positive result from the hook
+		okay, err := r.executePreExecHook(ctx, hookName, hookPath)
+		if !okay {
+			exit.Ok = false
+
+			// Ensure the Job UI knows why this job resulted in failure
+			r.logStreamer.Process(fmt.Sprintf("%s hook rejected this job, see the buildkite-agent logs for more details", hookName))
+			// But disclose more information in the agent logs
+			r.logger.Error("%s hook rejected this job: %s", hookName, err)
+
+			exit.ExitStatus = -1
+			exit.SignalReason = "agent_refused"
+		}
+	}
+
+	return exit
+}
+
 // Runs the job
 func (r *JobRunner) Run(ctx context.Context) error {
 	r.logger.Info("Starting job %s", r.job.ID)
@@ -303,43 +332,24 @@ func (r *JobRunner) Run(ctx context.Context) error {
 		return err
 	}
 
-	// Default exit status is no exit status
-	exitStatus := ""
-	signal := ""
-	signalReason := ""
-
-	// Before executing the bootstrap process with the received Job env,
-	// execute the pre-bootstrap hook (if present) for it to tell us
+	// Before executing the job process with the received Job env,
+	// execute the pre-bootstrap/pre-exec hook (if present) for it to tell us
 	// whether it is happy to proceed.
-	environmentCommandOkay := true
-
-	if hook, _ := hook.Find(r.conf.AgentConfiguration.HooksPath, "pre-bootstrap"); hook != "" {
-		// Once we have a hook any failure to run it MUST be fatal to the job to guarantee a true
-		// positive result from the hook
-		okay, err := r.executePreBootstrapHook(ctx, hook)
-		if !okay {
-			environmentCommandOkay = false
-
-			// Ensure the Job UI knows why this job resulted in failure
-			r.logStreamer.Process("pre-bootstrap hook rejected this job, see the buildkite-agent logs for more details")
-			// But disclose more information in the agent logs
-			r.logger.Error("pre-bootstrap hook rejected this job: %s", err)
+	hookExit := r.preExecHook(ctx, "pre-bootstrap")
+	hookExit = r.preExecHook(ctx, "pre-exec")
 
-			exitStatus = "-1"
-			signalReason = "agent_refused"
-		}
-	}
-
-	// Used to wait on various routines that we spin up
-	var wg sync.WaitGroup
+	// Default exit status is no exit status
+	signal := ""
+	exitStatus := strconv.Itoa(hookExit.ExitStatus)
+	signalReason := hookExit.SignalReason
 
 	// Set up a child context for helper goroutines related to running the job.
 	cctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
-	if environmentCommandOkay {
-		// Kick off log streaming and job status checking when the process
-		// starts.
+	var wg sync.WaitGroup
+	if hookExit.Ok {
+		// Kick off log streaming and job status checking when the process starts.
 		wg.Add(2)
 		go r.jobLogStreamer(cctx, &wg)
 		go r.jobCancellationChecker(cctx, &wg)
@@ -504,7 +514,7 @@ func (r *JobRunner) createEnvironment() ([]string, error) {
 	}
 
 	// Certain env can only be set by agent configuration.
-	// We show the user a warning in the bootstrap if they use any of these at a job level.
+	// We show the user a warning in the job logs if they use any of these at a job level.
 
 	var protectedEnv = []string{
 		"BUILDKITE_AGENT_ENDPOINT",
@@ -541,7 +551,7 @@ func (r *JobRunner) createEnvironment() ([]string, error) {
 		}
 	}
 
-	// Set BUILDKITE_IGNORED_ENV so the bootstrap can show warnings
+	// Set BUILDKITE_IGNORED_ENV so the job executor can show warnings
 	if len(ignoredEnv) > 0 {
 		env["BUILDKITE_IGNORED_ENV"] = strings.Join(ignoredEnv, ",")
 	}
@@ -590,19 +600,19 @@ func (r *JobRunner) createEnvironment() ([]string, error) {
 	env["BUILDKITE_AGENT_EXPERIMENT"] = strings.Join(experiments.Enabled(), ",")
 	env["BUILDKITE_REDACTED_VARS"] = strings.Join(r.conf.AgentConfiguration.RedactedVars, ",")
 
-	// propagate CancelSignal to bootstrap, unless it's the default SIGTERM
+	// propagate CancelSignal to job executor, unless it's the default SIGTERM
 	if r.conf.CancelSignal != process.SIGTERM {
 		env["BUILDKITE_CANCEL_SIGNAL"] = r.conf.CancelSignal.String()
 	}
 
-	// Whether to enable profiling in the bootstrap
+	// Whether to enable profiling in the job executor
 	if r.conf.AgentConfiguration.Profile != "" {
 		env["BUILDKITE_AGENT_PROFILE"] = r.conf.AgentConfiguration.Profile
 	}
 
-	// PTY-mode is enabled by default in `start` and `bootstrap`, so we only need
+	// PTY-mode is enabled by default in `start` and `job-exec`, so we only need
 	// to propagate it if it's explicitly disabled.
-	if r.conf.AgentConfiguration.RunInPty == false {
+	if !r.conf.AgentConfiguration.RunInPty {
 		env["BUILDKITE_PTY"] = "false"
 	}
 
@@ -666,28 +676,28 @@ func (w LogWriter) Write(bytes []byte) (int, error) {
 	return len(bytes), nil
 }
 
-func (r *JobRunner) executePreBootstrapHook(ctx context.Context, hook string) (bool, error) {
-	r.logger.Info("Running pre-bootstrap hook %q", hook)
+func (r *JobRunner) executePreExecHook(ctx context.Context, hookName, hookPath string) (bool, error) {
+	r.logger.Info("Running %s hook %q", hookName, hookPath)
 
 	sh, err := shell.New()
 	if err != nil {
 		return false, err
 	}
 
 	// This (plus inherited) is the only ENV that should be exposed
-	// to the pre-bootstrap hook.
+	// to the pre-exec hook.
 	sh.Env.Set("BUILDKITE_ENV_FILE", r.envFile.Name())
 
 	sh.Writer = LogWriter{
 		l: r.logger,
 	}
 
-	if err := sh.RunWithoutPrompt(ctx, hook); err != nil {
-		r.logger.Error("Finished pre-bootstrap hook %q: job rejected", hook)
+	if err := sh.RunWithoutPrompt(ctx, hookPath); err != nil {
+		r.logger.Error("Finished %s hook %q: hookName, job rejected", hookPath)
 		return false, err
 	}
 
-	r.logger.Info("Finished pre-bootstrap hook %q: job accepted", hook)
+	r.logger.Info("Finished %s hook %q: hookName, job accepted", hookPath)
 	return true, nil
 }