chore: Integrating vexec into Command (#6004)

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,14 @@ 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 +22,125 @@ 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 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
+	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...),
-		logger:          log.Default(),
+		vc:              vc,
 		filename:        filepath.Base(name),
 		interruptSignal: signal.InterruptSignal,
 	}
 
-	cmd.Stdin = os.Stdin
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
+	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.
-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.
+// 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(l log.Logger) error {
 	if cmd.usePTY {
-		if err := runCommandWithPTY(cmd.logger, cmd.Cmd); err != nil {
-			return err
+		osCmder, ok := cmd.vc.(vexec.OSCmder)
+		if !ok {
+			return ErrPTYRequiresOSBackend
 		}
-	} else if err := cmd.Cmd.Start(); err != nil {
+
+		return runCommandWithPTY(l, osCmder.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(l log.Logger) error {
+	if err := cmd.Start(l); 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
@@ -106,7 +154,7 @@ func (cmd *Cmd) Start() error {
 //     was some failure and we need to terminate all executed commands,
 //     in this situation we are sure that commands did not receive any
 //     signal, so we send them an interrupt signal immediately.
-func (cmd *Cmd) RegisterGracefullyShutdown(ctx context.Context) func() {
+func (cmd *Cmd) RegisterGracefullyShutdown(ctx context.Context, l log.Logger) func() {
 	cmd.gracefulShutdownRegistered.Store(true)
 
 	ctxShutdown, cancelShutdown := context.WithCancel(context.Background())
@@ -116,12 +164,12 @@ func (cmd *Cmd) RegisterGracefullyShutdown(ctx context.Context) func() {
 		case <-ctxShutdown.Done():
 		case <-ctx.Done():
 			if cause := new(signal.ContextCanceledError); errors.As(context.Cause(ctx), &cause) && cause.Signal != nil {
-				cmd.ForwardSignal(ctxShutdown, cause.Signal)
+				cmd.ForwardSignal(ctxShutdown, l, cause.Signal)
 
 				return
 			}
 
-			cmd.SendSignal(cmd.interruptSignal)
+			cmd.SendSignal(l, cmd.interruptSignal)
 		}
 	}()
 
@@ -130,7 +178,7 @@ func (cmd *Cmd) RegisterGracefullyShutdown(ctx context.Context) func() {
 
 // ForwardSignal forwards a given `sig` with a delay if cmd.forwardSignalDelay is greater than 0,
 // and if the same signal is received again, it is forwarded immediately.
-func (cmd *Cmd) ForwardSignal(ctx context.Context, sig os.Signal) {
+func (cmd *Cmd) ForwardSignal(ctx context.Context, l log.Logger, sig os.Signal) {
 	ctxDelay, cancelDelay := context.WithCancel(ctx)
 	defer cancelDelay()
 
@@ -139,7 +187,7 @@ func (cmd *Cmd) ForwardSignal(ctx context.Context, sig os.Signal) {
 	}, sig)
 
 	if cmd.forwardSignalDelay > 0 {
-		cmd.logger.Debugf("%s signal will be forwarded to %s with delay %s",
+		l.Debugf("%s signal will be forwarded to %s with delay %s",
 			cases.Title(language.English).String(sig.String()),
 			cmd.filename,
 			cmd.forwardSignalDelay,
@@ -153,14 +201,16 @@ func (cmd *Cmd) ForwardSignal(ctx context.Context, sig os.Signal) {
 	case <-ctxDelay.Done():
 	}
 
-	cmd.SendSignal(sig)
+	cmd.SendSignal(l, sig)
 }
 
-// SendSignal sends the given `sig` to the executed command.
-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)
+// 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(l log.Logger, sig os.Signal) {
+	l.Debugf("%s signal is forwarded to %s", cases.Title(language.English).String(sig.String()), cmd.filename)
 
-	if err := cmd.Process.Signal(sig); err != nil {
-		cmd.logger.Errorf("Failed to forwarding signal %s to %s: %v", sig, cmd.filename, err)
+	if err := cmd.vc.Signal(sig); err != nil && !errors.Is(err, vexec.ErrProcessNotStarted) {
+		l.Errorf("Failed to forwarding signal %s to %s: %v", sig, cmd.filename, err)
 	}
 }

internal/os/exec/cmd_test.go

@@ -0,0 +1,77 @@
+package exec_test
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	"github.com/gruntwork-io/terragrunt/internal/os/exec"
+	"github.com/gruntwork-io/terragrunt/internal/vexec"
+	"github.com/gruntwork-io/terragrunt/test/helpers/logger"
+
+	"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(logger.CreateLogger()))
+
+	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(logger.CreateLogger())
+	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(logger.CreateLogger())
+	assert.ErrorIs(t, err, exec.ErrPTYRequiresOSBackend)
+}