feat: add options for capturing run output

Author: kylecarbs

pkg/commands/commands.go

@@ -64,13 +64,13 @@ type DockerCommand interface {
 	IsArgsEnvsRequiredInCache() bool
 }
 
-func GetCommand(cmd instructions.Command, fileContext util.FileContext, useNewRun bool, cacheCopy bool, cacheRun bool) (DockerCommand, error) {
+func GetCommand(cmd instructions.Command, fileContext util.FileContext, useNewRun bool, cacheCopy bool, cacheRun bool, output *RunOutput) (DockerCommand, error) {
 	switch c := cmd.(type) {
 	case *instructions.RunCommand:
 		if useNewRun {
-			return &RunMarkerCommand{cmd: c, shdCache: cacheRun}, nil
+			return &RunMarkerCommand{cmd: c, shdCache: cacheRun, output: output}, nil
 		}
-		return &RunCommand{cmd: c, shdCache: cacheRun}, nil
+		return &RunCommand{cmd: c, shdCache: cacheRun, output: output}, nil
 	case *instructions.CopyCommand:
 		return &CopyCommand{cmd: c, fileContext: fileContext, shdCache: cacheCopy}, nil
 	case *instructions.ExposeCommand:

pkg/commands/run.go

@@ -18,6 +18,7 @@ package commands
 
 import (
 	"fmt"
+	"io"
 	"os"
 	"os/exec"
 	"strings"
@@ -33,9 +34,15 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
+type RunOutput struct {
+	Stdout io.Writer
+	Stderr io.Writer
+}
+
 type RunCommand struct {
 	BaseCommand
 	cmd      *instructions.RunCommand
+	output   *RunOutput
 	shdCache bool
 }
 
@@ -49,10 +56,19 @@ func (r *RunCommand) IsArgsEnvsRequiredInCache() bool {
 }
 
 func (r *RunCommand) ExecuteCommand(config *v1.Config, buildArgs *dockerfile.BuildArgs) error {
-	return runCommandInExec(config, buildArgs, r.cmd)
+	return runCommandInExec(config, buildArgs, r.cmd, r.output)
 }
 
-func runCommandInExec(config *v1.Config, buildArgs *dockerfile.BuildArgs, cmdRun *instructions.RunCommand) error {
+func runCommandInExec(config *v1.Config, buildArgs *dockerfile.BuildArgs, cmdRun *instructions.RunCommand, output *RunOutput) error {
+	if output == nil {
+		output = &RunOutput{}
+	}
+	if output.Stdout == nil {
+		output.Stdout = os.Stdout
+	}
+	if output.Stderr == nil {
+		output.Stderr = os.Stderr
+	}
 	var newCommand []string
 	if cmdRun.PrependShell {
 		// This is the default shell on Linux
@@ -89,8 +105,8 @@ func runCommandInExec(config *v1.Config, buildArgs *dockerfile.BuildArgs, cmdRun
 	cmd := exec.Command(newCommand[0], newCommand[1:]...)
 
 	cmd.Dir = setWorkDirIfExists(config.WorkingDir)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
+	cmd.Stdout = output.Stdout
+	cmd.Stderr = output.Stderr
 	replacementEnvs := buildArgs.ReplacementEnvs(config.Env)
 	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
 

pkg/config/options.go

@@ -19,6 +19,7 @@ package config
 import (
 	"errors"
 	"fmt"
+	"io"
 	"strconv"
 	"strings"
 	"time"
@@ -83,6 +84,8 @@ type KanikoOptions struct {
 	IgnoreVarRun             bool
 	SkipUnusedStages         bool
 	RunV2                    bool
+	RunStdout                io.Writer
+	RunStderr                io.Writer
 	CacheCopyLayers          bool
 	CacheRunLayers           bool
 	ForceBuildMetadata       bool

pkg/executor/build.go

@@ -133,7 +133,10 @@ func newStageBuilder(args *dockerfile.BuildArgs, opts *config.KanikoOptions, sta
 	}
 
 	for _, cmd := range s.stage.Commands {
-		command, err := commands.GetCommand(cmd, fileContext, opts.RunV2, opts.CacheCopyLayers, opts.CacheRunLayers)
+		command, err := commands.GetCommand(cmd, fileContext, opts.RunV2, opts.CacheCopyLayers, opts.CacheRunLayers, &commands.RunOutput{
+			Stdout: opts.RunStdout,
+			Stderr: opts.RunStderr,
+		})
 		if err != nil {
 			return nil, err
 		}

pkg/executor/build_test.go

@@ -848,7 +848,7 @@ func Test_stageBuilder_populateCompositeKey(t *testing.T) {
 			}
 
 			fc1 := util.FileContext{Root: "workspace"}
-			dockerCommand1, err := commands.GetCommand(instructions1[0], fc1, false, true, true)
+			dockerCommand1, err := commands.GetCommand(instructions1[0], fc1, false, true, true, nil)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -859,7 +859,7 @@ func Test_stageBuilder_populateCompositeKey(t *testing.T) {
 			}
 
 			fc2 := util.FileContext{Root: "workspace"}
-			dockerCommand2, err := commands.GetCommand(instructions[0], fc2, false, true, true)
+			dockerCommand2, err := commands.GetCommand(instructions[0], fc2, false, true, true, nil)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -1515,6 +1515,7 @@ func getCommands(fileContext util.FileContext, cmds []instructions.Command, cach
 			false,
 			cacheCopy,
 			cacheRun,
+			nil,
 		)
 		if err != nil {
 			panic(err)
@@ -1610,7 +1611,7 @@ func Test_stageBuild_populateCompositeKeyForCopyCommand(t *testing.T) {
 			}
 
 			fc := util.FileContext{Root: "workspace"}
-			copyCommand, err := commands.GetCommand(instructions[0], fc, false, true, true)
+			copyCommand, err := commands.GetCommand(instructions[0], fc, false, true, true, nil)
 			if err != nil {
 				t.Fatal(err)
 			}