chore: Integrating vexec into Command

Author: yhakbar

internal/cli/commands/exec/exec.go

@@ -11,6 +11,7 @@ import (
 	"github.com/gruntwork-io/terragrunt/internal/runner/run"
 	"github.com/gruntwork-io/terragrunt/internal/runner/runcfg"
 	"github.com/gruntwork-io/terragrunt/internal/shell"
+	"github.com/gruntwork-io/terragrunt/internal/vexec"
 	"github.com/gruntwork-io/terragrunt/pkg/log"
 	"github.com/gruntwork-io/terragrunt/pkg/options"
 )
@@ -82,7 +83,7 @@ func runTargetCommand(
 
 	return run.RunActionWithHooks(ctx, l, command, runOpts, cfg, r, func(ctx context.Context) error {
 		_, err := shell.RunCommandWithOutput(
-			ctx, l, configbridge.ShellRunOptsFromOpts(opts), dir, false, false, command, cmdArgs...,
+			ctx, l, vexec.NewOSExec(), configbridge.ShellRunOptsFromOpts(opts), dir, false, false, command, cmdArgs...,
 		)
 		if err != nil {
 			return errors.Errorf("failed to run command in directory %s: %w", dir, err)

internal/cli/commands/run/help.go

@@ -12,6 +12,7 @@ import (
 	"github.com/gruntwork-io/terragrunt/internal/errors"
 	"github.com/gruntwork-io/terragrunt/internal/tf"
 	"github.com/gruntwork-io/terragrunt/internal/util"
+	"github.com/gruntwork-io/terragrunt/internal/vexec"
 	"github.com/gruntwork-io/terragrunt/pkg/log"
 	"github.com/gruntwork-io/terragrunt/pkg/options"
 )
@@ -59,7 +60,7 @@ func runTFHelp(ctx context.Context, cliCtx *clihelper.Context, l log.Logger, opt
 
 	terraformHelpCmd := []string{tf.FlagNameHelpLong, cliCtx.Command.Name}
 
-	out, err := tf.RunCommandWithOutput(ctx, l, configbridge.TFRunOptsFromOpts(opts), terraformHelpCmd...)
+	out, err := tf.RunCommandWithOutput(ctx, l, vexec.NewOSExec(), configbridge.TFRunOptsFromOpts(opts), terraformHelpCmd...)
 	if err != nil {
 		var processError util.ProcessExecutionError
 		if ok := errors.As(err, &processError); ok {

internal/cli/commands/run/run.go

@@ -18,6 +18,7 @@ import (
 	"github.com/gruntwork-io/terragrunt/internal/shell"
 	"github.com/gruntwork-io/terragrunt/internal/tf"
 	"github.com/gruntwork-io/terragrunt/internal/util"
+	"github.com/gruntwork-io/terragrunt/internal/vexec"
 	"github.com/gruntwork-io/terragrunt/pkg/config"
 	"github.com/gruntwork-io/terragrunt/pkg/log"
 	"github.com/gruntwork-io/terragrunt/pkg/options"
@@ -158,7 +159,7 @@ func runVersionCommand(ctx context.Context, l log.Logger, opts *options.Terragru
 		}
 	}
 
-	return tf.RunCommand(ctx, l, configbridge.TFRunOptsFromOpts(opts), opts.TerraformCliArgs.Slice()...)
+	return tf.RunCommand(ctx, l, vexec.NewOSExec(), configbridge.TFRunOptsFromOpts(opts), opts.TerraformCliArgs.Slice()...)
 }
 
 func getTFPathFromConfig(ctx context.Context, l log.Logger, opts *options.TerragruntOptions) (string, error) {

internal/os/exec/cmd.go

@@ -3,13 +3,15 @@ package exec
 
 import (
 	"context"
+	"io"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"sync/atomic"
 	"time"
 
 	"github.com/gruntwork-io/terragrunt/internal/os/signal"
+	"github.com/gruntwork-io/terragrunt/internal/vexec"
 	"github.com/gruntwork-io/terragrunt/pkg/log"
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
@@ -21,78 +23,131 @@ import (
 // gracefully after sending an interrupt signal before escalating to SIGKILL.
 const DefaultGracefulShutdownDelay = 30 * time.Second
 
-// Cmd is a command type.
+// ErrPTYRequiresOSBackend is returned when a Cmd is started with PTY allocation
+// requested but the underlying vexec.Exec is not OS-backed.
+var ErrPTYRequiresOSBackend = errors.New("PTY allocation requires an OS-backed vexec.Exec")
+
+// Cmd wraps a vexec.Cmd with logging, signal forwarding, and optional PTY support.
+// The Cmd may be backed by a real OS process or by an in-memory vexec backend
+// (used in tests and fuzzers to prevent fork of external binaries).
 type Cmd struct {
-	logger          log.Logger
-	interruptSignal os.Signal
-	*exec.Cmd
+	vc                         vexec.Cmd
+	osCmd                      *exec.Cmd
+	logger                     log.Logger
+	interruptSignal            os.Signal
 	filename                   string
+	dir                        string
 	forwardSignalDelay         time.Duration
 	usePTY                     bool
 	gracefulShutdownRegistered atomic.Bool
 }
 
-// Command returns the `Cmd` struct to execute the named program with
-// the given arguments.
-func Command(ctx context.Context, name string, args ...string) *Cmd {
+// Command returns a `Cmd` configured to execute the named program with
+// the given arguments via the provided vexec.Exec. PTY allocation requires
+// an OS-backed Exec; non-OS backends are accepted but `WithUsePTY(true)`
+// will fail at Start with ErrPTYRequiresOSBackend.
+func Command(ctx context.Context, e vexec.Exec, name string, args ...string) *Cmd {
+	vc := e.Command(ctx, name, args...)
+
 	cmd := &Cmd{
-		Cmd:             exec.CommandContext(ctx, name, args...),
+		vc:              vc,
 		logger:          log.Default(),
 		filename:        filepath.Base(name),
 		interruptSignal: signal.InterruptSignal,
 	}
 
-	cmd.Stdin = os.Stdin
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
+	if osCmder, ok := vc.(vexec.OSCmder); ok {
+		cmd.osCmd = osCmder.OSCmd()
+	}
+
+	cmd.SetStdin(os.Stdin)
+	cmd.SetStdout(os.Stdout)
+	cmd.SetStderr(os.Stderr)
 
-	cmd.WaitDelay = DefaultGracefulShutdownDelay
+	vc.SetWaitDelay(DefaultGracefulShutdownDelay)
 
-	cmd.Cancel = func() error {
+	vc.SetCancel(func() error {
 		if cmd.gracefulShutdownRegistered.Load() {
 			return nil
 		}
 
-		if cmd.Process == nil {
-			return nil
+		sig := signal.SignalFromContext(ctx)
+		if sig == nil {
+			sig = cmd.interruptSignal
 		}
 
-		if sig := signal.SignalFromContext(ctx); sig != nil {
-			return cmd.Process.Signal(sig)
+		if sig == nil {
+			sig = os.Kill
 		}
 
-		if cmd.interruptSignal != nil {
-			return cmd.Process.Signal(cmd.interruptSignal)
+		if err := vc.Signal(sig); err != nil && !errors.Is(err, vexec.ErrProcessNotStarted) {
+			return err
 		}
 
-		return cmd.Process.Signal(os.Kill)
-	}
+		return nil
+	})
 
 	return cmd
 }
 
+// SetStdin sets the command's standard input.
+func (cmd *Cmd) SetStdin(r io.Reader) { cmd.vc.SetStdin(r) }
+
+// SetStdout sets the command's standard output.
+func (cmd *Cmd) SetStdout(w io.Writer) { cmd.vc.SetStdout(w) }
+
+// SetStderr sets the command's standard error.
+func (cmd *Cmd) SetStderr(w io.Writer) { cmd.vc.SetStderr(w) }
+
+// SetEnv sets the command's environment in `KEY=value` form.
+func (cmd *Cmd) SetEnv(env []string) { cmd.vc.SetEnv(env) }
+
+// SetDir sets the command's working directory.
+func (cmd *Cmd) SetDir(dir string) {
+	cmd.dir = dir
+	cmd.vc.SetDir(dir)
+}
+
+// Dir returns the working directory previously set via SetDir.
+func (cmd *Cmd) Dir() string { return cmd.dir }
+
 // Configure sets options to the `Cmd`.
 func (cmd *Cmd) Configure(opts ...Option) {
 	for _, opt := range opts {
 		opt(cmd)
 	}
 }
 
-// Start starts the specified command but does not wait for it to complete.
+// Start starts the command but does not wait for it to complete. When PTY
+// allocation is requested, the underlying backend must be OS-backed.
 func (cmd *Cmd) Start() error {
-	// If we need to allocate a ptty for the command, route through the ptty routine.
-	// Otherwise, directly call the command.
 	if cmd.usePTY {
-		if err := runCommandWithPTY(cmd.logger, cmd.Cmd); err != nil {
-			return err
+		if cmd.osCmd == nil {
+			return ErrPTYRequiresOSBackend
 		}
-	} else if err := cmd.Cmd.Start(); err != nil {
+
+		return runCommandWithPTY(cmd.logger, cmd.osCmd)
+	}
+
+	if err := cmd.vc.Start(); err != nil {
 		return errors.New(err)
 	}
 
 	return nil
 }
 
+// Wait waits for the command to exit and returns its error.
+func (cmd *Cmd) Wait() error { return cmd.vc.Wait() }
+
+// Run starts the command and waits for it to complete.
+func (cmd *Cmd) Run() error {
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+
+	return cmd.Wait()
+}
+
 // RegisterGracefullyShutdown registers a graceful shutdown for the
 // command in two ways:
 //  1. If the context cancel contains a cause with a signal, this means
@@ -156,11 +211,13 @@ func (cmd *Cmd) ForwardSignal(ctx context.Context, sig os.Signal) {
 	cmd.SendSignal(sig)
 }
 
-// SendSignal sends the given `sig` to the executed command.
+// SendSignal sends the given `sig` to the executed command. Errors are logged
+// rather than returned; ErrProcessNotStarted is silently ignored because
+// callers may race against process startup.
 func (cmd *Cmd) SendSignal(sig os.Signal) {
 	cmd.logger.Debugf("%s signal is forwarded to %s", cases.Title(language.English).String(sig.String()), cmd.filename)
 
-	if err := cmd.Process.Signal(sig); err != nil {
+	if err := cmd.vc.Signal(sig); err != nil && !errors.Is(err, vexec.ErrProcessNotStarted) {
 		cmd.logger.Errorf("Failed to forwarding signal %s to %s: %v", sig, cmd.filename, err)
 	}
 }

internal/os/exec/cmd_test.go

@@ -0,0 +1,76 @@
+package exec_test
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	"github.com/gruntwork-io/terragrunt/internal/os/exec"
+	"github.com/gruntwork-io/terragrunt/internal/vexec"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestCommandWithMemBackend verifies that the wrapper drives a mem-backed
+// vexec.Exec end-to-end without forking a real process.
+func TestCommandWithMemBackend(t *testing.T) {
+	t.Parallel()
+
+	var got vexec.Invocation
+
+	e := vexec.NewMemExec(func(_ context.Context, inv vexec.Invocation) vexec.Result {
+		got = inv
+
+		return vexec.Result{Stdout: []byte("Plan: 0 to add\n")}
+	})
+
+	stdout := &bytes.Buffer{}
+
+	cmd := exec.Command(t.Context(), e, "tofu", "plan")
+	cmd.SetStdout(stdout)
+	cmd.SetDir("/work")
+	cmd.SetEnv([]string{"FOO=bar"})
+
+	require.NoError(t, cmd.Run())
+
+	assert.Equal(t, "tofu", got.Name)
+	assert.Equal(t, []string{"plan"}, got.Args)
+	assert.Equal(t, "/work", got.Dir)
+	assert.Equal(t, []string{"FOO=bar"}, got.Env)
+	assert.Equal(t, "Plan: 0 to add\n", stdout.String())
+	assert.Equal(t, "/work", cmd.Dir())
+}
+
+// TestCommandWithMemBackendExitCode verifies that handler-reported exit codes
+// are recoverable via vexec.ExitCode.
+func TestCommandWithMemBackendExitCode(t *testing.T) {
+	t.Parallel()
+
+	e := vexec.NewMemExec(func(context.Context, vexec.Invocation) vexec.Result {
+		return vexec.Result{ExitCode: 7}
+	})
+
+	cmd := exec.Command(t.Context(), e, "tofu", "apply")
+
+	err := cmd.Run()
+	require.Error(t, err)
+
+	assert.Equal(t, 7, vexec.ExitCode(err))
+}
+
+// TestCommandWithMemBackendPTYRejected verifies that requesting a PTY against
+// a non-OS backend is refused at Start, rather than silently degrading.
+func TestCommandWithMemBackendPTYRejected(t *testing.T) {
+	t.Parallel()
+
+	e := vexec.NewMemExec(func(context.Context, vexec.Invocation) vexec.Result {
+		return vexec.Result{}
+	})
+
+	cmd := exec.Command(t.Context(), e, "tofu", "apply")
+	cmd.Configure(exec.WithUsePTY(true))
+
+	err := cmd.Run()
+	assert.ErrorIs(t, err, exec.ErrPTYRequiresOSBackend)
+}

internal/os/exec/cmd_unix_test.go

@@ -1,5 +1,4 @@
 //go:build linux || darwin
-// +build linux darwin
 
 package exec_test
 
@@ -13,6 +12,7 @@ import (
 
 	"github.com/gruntwork-io/terragrunt/internal/os/exec"
 	"github.com/gruntwork-io/terragrunt/internal/util"
+	"github.com/gruntwork-io/terragrunt/internal/vexec"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -26,7 +26,7 @@ func TestExitCodeUnix(t *testing.T) {
 	t.Parallel()
 
 	for index := 0; index <= 255; index++ {
-		cmd := exec.Command(t.Context(), "testdata/test_exit_code.sh", strconv.Itoa(index))
+		cmd := exec.Command(t.Context(), vexec.NewOSExec(), "testdata/test_exit_code.sh", strconv.Itoa(index))
 		err := cmd.Run()
 
 		if index == 0 {
@@ -52,7 +52,7 @@ func TestNewSignalsForwarderWaitUnix(t *testing.T) {
 
 	expectedWait := 5
 
-	cmd := exec.Command(t.Context(), "testdata/test_sigint_wait.sh", strconv.Itoa(expectedWait))
+	cmd := exec.Command(t.Context(), vexec.NewOSExec(), "testdata/test_sigint_wait.sh", strconv.Itoa(expectedWait))
 
 	runChannel := make(chan error)
 
@@ -64,7 +64,7 @@ func TestNewSignalsForwarderWaitUnix(t *testing.T) {
 
 	start := time.Now()
 
-	cmd.Process.Signal(os.Interrupt)
+	cmd.SendSignal(os.Interrupt)
 
 	err := <-runChannel
 	require.Error(t, err)
@@ -83,7 +83,10 @@ func TestNewSignalsForwarderMultipleUnix(t *testing.T) {
 
 	expectedInterrupts := 10
 
-	cmd := exec.Command(t.Context(), "testdata/test_sigint_multiple.sh", strconv.Itoa(expectedInterrupts))
+	cmd := exec.Command(
+		t.Context(), vexec.NewOSExec(),
+		"testdata/test_sigint_multiple.sh", strconv.Itoa(expectedInterrupts),
+	)
 
 	runChannel := make(chan error)
 
@@ -106,7 +109,7 @@ func TestNewSignalsForwarderMultipleUnix(t *testing.T) {
 			case err = <-runChannel:
 				return interrupts, err
 			default:
-				cmd.Process.Signal(os.Interrupt)
+				cmd.SendSignal(os.Interrupt)
 
 				interrupts++
 			}
@@ -132,7 +135,7 @@ func TestGracefulShutdownOnContextCancelUnix(t *testing.T) {
 
 	ctx, cancel := context.WithCancel(context.Background())
 
-	cmd := exec.Command(ctx, "testdata/test_graceful_shutdown.sh")
+	cmd := exec.Command(ctx, vexec.NewOSExec(), "testdata/test_graceful_shutdown.sh")
 
 	cmd.Configure(exec.WithGracefulShutdownDelay(5 * time.Second))