chore: add usage for venv for shell

Author: denis256

internal/os/exec/opts.go

@@ -3,12 +3,10 @@ package exec
 import (
 	"time"
 
-	"github.com/gruntwork-io/go-commons/collections"
+	"github.com/gruntwork-io/terragrunt/internal/util"
 	"github.com/gruntwork-io/terragrunt/pkg/log"
 )
 
-const envVarsListFormat = "%s=%s"
-
 // Option is type for passing options to the Cmd.
 type Option func(*Cmd)
 
@@ -29,7 +27,7 @@ func WithUsePTY(state bool) Option {
 // WithEnv sets envs to the Cmd.
 func WithEnv(env map[string]string) Option {
 	return func(cmd *Cmd) {
-		cmd.Env = collections.KeyValueStringSliceWithFormat(env, envVarsListFormat)
+		cmd.Env = util.EnvSliceFromMap(env)
 	}
 }
 

internal/shell/run_cmd.go

@@ -22,29 +22,6 @@ import (
 	"github.com/gruntwork-io/terragrunt/internal/util"
 )
 
-type execContextKey struct{}
-
-// WithExec returns ctx with the given vexec.Exec installed for use by RunCommandWithOutput.
-// When set, the executor replaces the default os/exec backend; intended for tests that need to intercept subprocess execution.
-func WithExec(ctx context.Context, e vexec.Exec) context.Context {
-	return context.WithValue(ctx, execContextKey{}, e)
-}
-
-func execFromContext(ctx context.Context) vexec.Exec {
-	e, _ := ctx.Value(execContextKey{}).(vexec.Exec)
-	return e
-}
-
-func envSliceFromMap(env map[string]string) []string {
-	out := make([]string, 0, len(env))
-
-	for k, v := range env {
-		out = append(out, k+"="+v)
-	}
-
-	return out
-}
-
 // SignalForwardingDelay is the time to wait before forwarding the signal to the subcommand.
 //
 // The signal can be sent to the main process (only `terragrunt`) as well as the process group (`terragrunt` and `terraform`), for example:
@@ -61,6 +38,10 @@ type ShellOptions struct {
 	EngineConfig  *engine.EngineConfig
 	Telemetry     *telemetry.Options
 	Env           map[string]string
+	// Exec, when non-nil, replaces the default os/exec backend used by
+	// RunCommandWithOutput. Intended for tests that need to intercept
+	// subprocess execution; production code leaves this nil.
+	Exec vexec.Exec
 
 	RootWorkingDir  string
 	WorkingDir      string
@@ -176,6 +157,14 @@ func (o *ShellOptions) WithForwardTFStdout(f bool) *ShellOptions {
 	return o
 }
 
+// WithExec installs a vexec.Exec backend that replaces the default os/exec
+// path used by RunCommandWithOutput. Pass nil to clear it. Intended for tests.
+func (o *ShellOptions) WithExec(e vexec.Exec) *ShellOptions {
+	o.Exec = e
+
+	return o
+}
+
 // NoEngine returns true if the user explicitly disabled the engine via --no-engine.
 // Returns false when EngineOptions is nil (default: don't disable), letting the
 // other guards (EngineConfig != nil, experiment enabled) decide whether to run.
@@ -272,24 +261,15 @@ func RunCommandWithOutput(
 			}
 		}
 
-		if injected := execFromContext(ctx); injected != nil {
-			injectedCmd := injected.Command(ctx, command, args...)
+		if runOpts.Exec != nil {
+			injectedCmd := runOpts.Exec.Command(ctx, command, args...)
 			injectedCmd.SetDir(commandDir)
-			injectedCmd.SetEnv(envSliceFromMap(runOpts.Env))
+			injectedCmd.SetEnv(util.EnvSliceFromMap(runOpts.Env))
 			injectedCmd.SetStdout(cmdStdout)
 			injectedCmd.SetStderr(cmdStderr)
 
 			if err := injectedCmd.Run(); err != nil {
-				return errors.New(util.ProcessExecutionError{
-					Err:             err,
-					Args:            args,
-					Command:         command,
-					Output:          output,
-					WorkingDir:      commandDir,
-					RootWorkingDir:  runOpts.RootWorkingDir,
-					LogShowAbsPaths: runOpts.Writers.LogShowAbsPaths,
-					DisableSummary:  runOpts.Writers.LogDisableErrorSummary,
-				})
+				return runOpts.procExecError(err, command, commandDir, args, &output)
 			}
 
 			return nil
@@ -311,39 +291,37 @@ func RunCommandWithOutput(
 		defer savedConsole.Restore()
 
 		if err := cmd.Start(); err != nil { //nolint:contextcheck // context already passed to exec.Command
-			err = util.ProcessExecutionError{
-				Err:             err,
-				Args:            args,
-				Command:         command,
-				WorkingDir:      cmd.Dir,
-				RootWorkingDir:  runOpts.RootWorkingDir,
-				LogShowAbsPaths: runOpts.Writers.LogShowAbsPaths,
-				DisableSummary:  runOpts.Writers.LogDisableErrorSummary,
-			}
-
-			return errors.New(err)
+			return runOpts.procExecError(err, command, cmd.Dir, args, nil)
 		}
 
 		cancelShutdown := cmd.RegisterGracefullyShutdown(ctx)
 		defer cancelShutdown()
 
 		if err := cmd.Wait(); err != nil {
-			err = util.ProcessExecutionError{
-				Err:             err,
-				Args:            args,
-				Command:         command,
-				Output:          output,
-				WorkingDir:      cmd.Dir,
-				RootWorkingDir:  runOpts.RootWorkingDir,
-				LogShowAbsPaths: runOpts.Writers.LogShowAbsPaths,
-				DisableSummary:  runOpts.Writers.LogDisableErrorSummary,
-			}
-
-			return errors.New(err)
+			return runOpts.procExecError(err, command, cmd.Dir, args, &output)
 		}
 
 		return nil
 	})
 
 	return &output, err
 }
+
+// procExecError builds a ProcessExecutionError using the standard fields from ShellOptions.
+// Pass nil for output when the failure occurred before any output was captured.
+func (o *ShellOptions) procExecError(err error, command, dir string, args []string, output *util.CmdOutput) error {
+	pe := util.ProcessExecutionError{
+		Err:             err,
+		Args:            args,
+		Command:         command,
+		WorkingDir:      dir,
+		RootWorkingDir:  o.RootWorkingDir,
+		LogShowAbsPaths: o.Writers.LogShowAbsPaths,
+		DisableSummary:  o.Writers.LogDisableErrorSummary,
+	}
+	if output != nil {
+		pe.Output = *output
+	}
+
+	return errors.New(pe)
+}

internal/util/collections.go

@@ -133,3 +133,17 @@ func SplitUrls(s, sep string) []string {
 
 	return urls
 }
+
+// EnvSliceFromMap converts an env-var map to the KEY=VALUE slice form
+// expected by os/exec.Cmd.Env. The result is sorted for deterministic output.
+func EnvSliceFromMap(env map[string]string) []string {
+	out := make([]string, 0, len(env))
+
+	for k, v := range env {
+		out = append(out, k+"="+v)
+	}
+
+	slices.Sort(out)
+
+	return out
+}

pkg/config/dependency.go

@@ -1459,7 +1459,8 @@ func shellRunOptsFromPctx(pctx *ParsingContext) *shell.ShellOptions {
 		WithRootWorkingDir(pctx.RootWorkingDir).
 		WithExperiments(pctx.Experiments).
 		WithHeadless(pctx.Headless).
-		WithForwardTFStdout(pctx.ForwardTFStdout)
+		WithForwardTFStdout(pctx.ForwardTFStdout).
+		WithExec(pctx.Exec)
 }
 
 // tfRunOptsFromPctx builds a *tf.RunOptions from ParsingContext flat fields.

pkg/config/fuzz_test.go

@@ -8,7 +8,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/gruntwork-io/terragrunt/internal/shell"
 	"github.com/gruntwork-io/terragrunt/internal/vexec"
 	"github.com/gruntwork-io/terragrunt/pkg/config"
 	"github.com/gruntwork-io/terragrunt/test/helpers/logger"
@@ -71,9 +70,9 @@ func FuzzHCLStringHelpers(f *testing.F) {
 }
 
 // FuzzHCLRunCommand fuzzes config.RunCommand with arbitrary argv. Subprocess execution
-// is intercepted by an in-memory vexec backend installed via shell.WithExec, so no real
-// host commands ever run — even mutator-supplied paths like "/bin/sh\x00-c\x00rm -rf /"
-// are captured by the mock instead of reaching the operating system.
+// is intercepted by an in-memory vexec backend installed via pctx.Exec, so no real host
+// commands ever run — even mutator-supplied paths like "/bin/sh\x00-c\x00rm -rf /" are
+// captured by the mock instead of reaching the operating system.
 //
 // Asserts:
 //   - On the conflict path (--terragrunt-no-cache + --terragrunt-global-cache):
@@ -128,12 +127,11 @@ func FuzzHCLRunCommand(f *testing.F) {
 		baseCtx, pctx := newTestParsingContext(t, "")
 		pctx.Writers.Writer = io.Discard
 		pctx.Writers.ErrWriter = io.Discard
+		pctx.Exec = memExec
 
 		ctx, cancel := context.WithTimeout(baseCtx, 2*time.Second)
 		defer cancel()
 
-		ctx = shell.WithExec(ctx, memExec)
-
 		l := logger.CreateLogger()
 		out, err := config.RunCommand(ctx, pctx, l, argsForCall)
 

pkg/config/parsing_context.go

@@ -21,6 +21,7 @@ import (
 	"github.com/gruntwork-io/terragrunt/internal/strict"
 	"github.com/gruntwork-io/terragrunt/internal/telemetry"
 	"github.com/gruntwork-io/terragrunt/internal/tfimpl"
+	"github.com/gruntwork-io/terragrunt/internal/vexec"
 	"github.com/gruntwork-io/terragrunt/internal/writer"
 	"github.com/gruntwork-io/terragrunt/pkg/config/hclparse"
 	"github.com/gruntwork-io/terragrunt/pkg/log"
@@ -52,6 +53,11 @@ type ParsingContext struct {
 	Features            *cty.Value
 	Locals              *cty.Value
 
+	// Exec, when non-nil, replaces the default os/exec backend used by run_cmd
+	// and other shell-outs that read shell.ShellOptions from this context.
+	// Intended for tests; production code leaves this nil.
+	Exec vexec.Exec
+
 	Env                 map[string]string
 	SourceMap           map[string]string
 	PredefinedFunctions map[string]function.Function