Fix multistage caching with COPY --from

* Removed block on use --cache-copy-layers with multistage builds
* Removed using digest in composite key with command COPY --from
* COPY --from command uses src as file context (only changed files will be reason for change hash)
* ARG and ENV changed before COPY dont change composite key
* Add and fix some tests
* Caching work same as caching in docker buildx

pkg/commands/base_command.go

@@ -24,6 +24,10 @@ import (
 type BaseCommand struct {
 }
 
+func (b *BaseCommand) IsArgsEnvsRequiredInCache() bool {
+	return false
+}
+
 func (b *BaseCommand) CacheCommand(v1.Image) DockerCommand {
 	return nil
 }

pkg/commands/commands.go

@@ -58,6 +58,10 @@ type DockerCommand interface {
 
 	// ShouldDetectDeletedFiles returns true if the command could delete files.
 	ShouldDetectDeletedFiles() bool
+
+	// True if need add ARGs and EVNs to composite cache string with resolved command
+	// need only for RUN instruction
+	IsArgsEnvsRequiredInCache() bool
 }
 
 func GetCommand(cmd instructions.Command, fileContext util.FileContext, useNewRun bool, cacheCopy bool, cacheRun bool) (DockerCommand, error) {

pkg/commands/copy.go

@@ -270,9 +270,8 @@ func copyCmdFilesUsedFromContext(
 	config *v1.Config, buildArgs *dockerfile.BuildArgs, cmd *instructions.CopyCommand,
 	fileContext util.FileContext,
 ) ([]string, error) {
-	// We don't use the context if we're performing a copy --from.
 	if cmd.From != "" {
-		return nil, nil
+		fileContext = util.FileContext{Root: filepath.Join(kConfig.KanikoDir, cmd.From)}
 	}
 
 	replacementEnvs := buildArgs.ReplacementEnvs(config.Env)

pkg/commands/run.go

@@ -44,6 +44,10 @@ var (
 	userLookup = util.LookupUser
 )
 
+func (r *RunCommand) IsArgsEnvsRequiredInCache() bool {
+	return true
+}
+
 func (r *RunCommand) ExecuteCommand(config *v1.Config, buildArgs *dockerfile.BuildArgs) error {
 	return runCommandInExec(config, buildArgs, r.cmd)
 }
@@ -200,6 +204,10 @@ type CachingRunCommand struct {
 	extractFn      util.ExtractFunction
 }
 
+func (cr *CachingRunCommand) IsArgsEnvsRequiredInCache() bool {
+	return true
+}
+
 func (cr *CachingRunCommand) ExecuteCommand(config *v1.Config, buildArgs *dockerfile.BuildArgs) error {
 	logrus.Infof("Found cached layer, extracting to filesystem")
 	var err error

pkg/commands/run_marker.go

@@ -59,6 +59,10 @@ func (r *RunMarkerCommand) ProvidesFilesToSnapshot() bool {
 	return true
 }
 
+func (r *RunMarkerCommand) IsArgsEnvsRequiredInCache() bool {
+	return true
+}
+
 // CacheCommand returns true since this command should be cached
 func (r *RunMarkerCommand) CacheCommand(img v1.Image) DockerCommand {
 

pkg/dockerfile/dockerfile.go

@@ -58,10 +58,6 @@ func ParseStages(opts *config.KanikoOptions) ([]instructions.Stage, []instructio
 		return nil, nil, errors.Wrap(err, "parsing dockerfile")
 	}
 
-	if opts.CacheCopyLayers && len(stages) >= 2 {
-		return nil, nil, errors.New("kaniko does not support caching copy layers in multistage builds")
-	}
-
 	metaArgs, err = expandNested(metaArgs, opts.BuildArgs)
 	if err != nil {
 		return nil, nil, errors.Wrap(err, "expanding meta ARGs")

pkg/dockerfile/dockerfile_test.go

@@ -29,39 +29,6 @@ import (
 	"github.com/moby/buildkit/frontend/dockerfile/instructions"
 )
 
-func Test_ParseStages_NoMultistageWithCacheCopy(t *testing.T) {
-	dockerfile := `
-	FROM scratch as first
-	COPY testfile /
-
-	FROM scratch as second
-	COPY --from=second testfile /
-	`
-	tmpfile, err := ioutil.TempFile("", "Dockerfile.test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	defer os.Remove(tmpfile.Name())
-
-	if _, err := tmpfile.Write([]byte(dockerfile)); err != nil {
-		t.Fatal(err)
-	}
-	if err := tmpfile.Close(); err != nil {
-		t.Fatal(err)
-	}
-
-	opts := &config.KanikoOptions{
-		DockerfilePath:  tmpfile.Name(),
-		CacheCopyLayers: true,
-	}
-
-	_, _, err = ParseStages(opts)
-	if err == nil {
-		t.Fatal("expected ParseStages to fail on MultiStage build if CacheCopyLayers=true")
-	}
-}
-
 func Test_ParseStages_ArgValueWithQuotes(t *testing.T) {
 	dockerfile := `
 	ARG IMAGE="ubuntu:16.04"

pkg/executor/build.go

@@ -198,7 +198,7 @@ func isOCILayout(path string) bool {
 	return strings.HasPrefix(path, "oci:")
 }
 
-func (s *stageBuilder) populateCompositeKey(command fmt.Stringer, files []string, compositeKey CompositeCache, args *dockerfile.BuildArgs, env []string) (CompositeCache, error) {
+func (s *stageBuilder) populateCompositeKey(command commands.DockerCommand, files []string, compositeKey CompositeCache, args *dockerfile.BuildArgs, env []string) (CompositeCache, error) {
 	// First replace all the environment variables or args in the command
 	replacementEnvs := args.ReplacementEnvs(env)
 	// The sort order of `replacementEnvs` is basically undefined, sort it
@@ -212,15 +212,16 @@ func (s *stageBuilder) populateCompositeKey(command fmt.Stringer, files []string
 	// avoid conflicts with any RUN command since commands can not
 	// start with | (vertical bar). The "#" (number of build envs) is there to
 	// help ensure proper cache matches.
-	if len(replacementEnvs) > 0 {
-		compositeKey.AddKey(fmt.Sprintf("|%d", len(replacementEnvs)))
-		compositeKey.AddKey(replacementEnvs...)
+
+	if command.IsArgsEnvsRequiredInCache() {
+		if len(replacementEnvs) > 0 {
+			compositeKey.AddKey(fmt.Sprintf("|%d", len(replacementEnvs)))
+			compositeKey.AddKey(replacementEnvs...)
+		}
 	}
+
 	// Add the next command to the cache key.
 	compositeKey.AddKey(resolvedCmd)
-	if copyCmd, ok := commands.CastAbstractCopyCommand(command); ok == true {
-		compositeKey = s.populateCopyCmdCompositeKey(command, copyCmd.From(), compositeKey)
-	}
 
 	for _, f := range files {
 		if err := compositeKey.AddPath(f, s.fileContext); err != nil {
@@ -230,22 +231,6 @@ func (s *stageBuilder) populateCompositeKey(command fmt.Stringer, files []string
 	return compositeKey, nil
 }
 
-func (s *stageBuilder) populateCopyCmdCompositeKey(command fmt.Stringer, from string, compositeKey CompositeCache) CompositeCache {
-	if from != "" {
-		digest, ok := s.stageIdxToDigest[from]
-		if ok {
-			ds := digest
-			cacheKey, ok := s.digestToCacheKey[ds]
-			if ok {
-				logrus.Debugf("Adding digest %v from previous stage to composite key for %v", ds, command.String())
-				compositeKey.AddKey(cacheKey)
-			}
-		}
-	}
-
-	return compositeKey
-}
-
 func (s *stageBuilder) optimize(compositeKey CompositeCache, cfg v1.Config) error {
 	if !s.opts.Cache {
 		return nil