WORKDIR learned to cache it's potential output layer

pkg/commands/commands.go

@@ -78,7 +78,7 @@ func GetCommand(cmd instructions.Command, fileContext util.FileContext, useNewRu
 	case *instructions.EnvCommand:
 		return &EnvCommand{cmd: c}, nil
 	case *instructions.WorkdirCommand:
-		return &WorkdirCommand{cmd: c}, nil
+		return &WorkdirCommand{cmd: c, shdCache: cacheRun}, nil
 	case *instructions.AddCommand:
 		return &AddCommand{cmd: c, fileContext: fileContext}, nil
 	case *instructions.CmdCommand:

pkg/commands/workdir.go

@@ -17,9 +17,11 @@ limitations under the License.
 package commands
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 
+	kConfig "github.com/GoogleContainerTools/kaniko/pkg/config"
 	"github.com/GoogleContainerTools/kaniko/pkg/dockerfile"
 	"github.com/pkg/errors"
 
@@ -33,6 +35,7 @@ type WorkdirCommand struct {
 	BaseCommand
 	cmd           *instructions.WorkdirCommand
 	snapshotFiles []string
+	shdCache      bool
 }
 
 // For testing
@@ -81,14 +84,116 @@ func (w *WorkdirCommand) ExecuteCommand(config *v1.Config, buildArgs *dockerfile
 
 // FilesToSnapshot returns the workingdir, which should have been created if it didn't already exist
 func (w *WorkdirCommand) FilesToSnapshot() []string {
-	return w.snapshotFiles
+	return nil
+}
+
+func (r *WorkdirCommand) ProvidesFilesToSnapshot() bool {
+	return false
 }
 
 // String returns some information about the command for the image config history
 func (w *WorkdirCommand) String() string {
 	return w.cmd.String()
 }
 
+// CacheCommand returns true since this command should be cached
+func (w *WorkdirCommand) CacheCommand(img v1.Image) DockerCommand {
+
+	return &CachingWorkdirCommand{
+		img:       img,
+		cmd:       w.cmd,
+		extractFn: util.ExtractFile,
+	}
+}
+
 func (w *WorkdirCommand) MetadataOnly() bool {
 	return false
 }
+
+func (r *WorkdirCommand) RequiresUnpackedFS() bool {
+	return true
+}
+
+func (w *WorkdirCommand) ShouldCacheOutput() bool {
+	return w.shdCache
+}
+
+type CachingWorkdirCommand struct {
+	BaseCommand
+	caching
+	img            v1.Image
+	extractedFiles []string
+	cmd            *instructions.WorkdirCommand
+	extractFn      util.ExtractFunction
+}
+
+func (wr *CachingWorkdirCommand) ExecuteCommand(config *v1.Config, buildArgs *dockerfile.BuildArgs) error {
+	var err error
+	logrus.Info("Cmd: workdir")
+	workdirPath := wr.cmd.Path
+	replacementEnvs := buildArgs.ReplacementEnvs(config.Env)
+	resolvedWorkingDir, err := util.ResolveEnvironmentReplacement(workdirPath, replacementEnvs, true)
+	if err != nil {
+		return err
+	}
+	if filepath.IsAbs(resolvedWorkingDir) {
+		config.WorkingDir = resolvedWorkingDir
+	} else {
+		if config.WorkingDir != "" {
+			config.WorkingDir = filepath.Join(config.WorkingDir, resolvedWorkingDir)
+		} else {
+			config.WorkingDir = filepath.Join("/", resolvedWorkingDir)
+		}
+	}
+	logrus.Infof("Changed working directory to %s", config.WorkingDir)
+
+	logrus.Infof("Found cached layer, extracting to filesystem")
+
+	if wr.img == nil {
+		return errors.New(fmt.Sprintf("command image is nil %v", wr.String()))
+	}
+
+	layers, err := wr.img.Layers()
+	if err != nil {
+		return errors.Wrap(err, "retrieving image layers")
+	}
+
+	if len(layers) != 1 {
+		return errors.New(fmt.Sprintf("expected %d layers but got %d", 1, len(layers)))
+	}
+
+	wr.layer = layers[0]
+
+	wr.extractedFiles, err = util.GetFSFromLayers(
+		kConfig.RootDir,
+		layers,
+		util.ExtractFunc(wr.extractFn),
+		util.IncludeWhiteout(),
+	)
+	if err != nil {
+		return errors.Wrap(err, "extracting fs from image")
+	}
+
+	return nil
+}
+
+// FilesToSnapshot returns the workingdir, which should have been created if it didn't already exist
+func (wr *CachingWorkdirCommand) FilesToSnapshot() []string {
+	f := wr.extractedFiles
+	logrus.Debugf("%d files extracted by caching run command", len(f))
+	logrus.Tracef("Extracted files: %s", f)
+
+	return f
+}
+
+// String returns some information about the command for the image config history
+func (wr *CachingWorkdirCommand) String() string {
+	if wr.cmd == nil {
+		return "nil command"
+	}
+	return wr.cmd.String()
+}
+
+func (wr *CachingWorkdirCommand) MetadataOnly() bool {
+	return false
+}