Recompute docker dependencies across dev loops.

pkg/skaffold/docker/context.go

@@ -27,7 +27,7 @@ import (
 )
 
 func CreateDockerTarContext(ctx context.Context, w io.Writer, workspace string, a *latest.DockerArtifact, cfg Config) error {
-	paths, err := GetDependencies(ctx, workspace, a.DockerfilePath, a.BuildArgs, cfg)
+	paths, err := GetDependenciesCached(ctx, workspace, a.DockerfilePath, a.BuildArgs, cfg)
 	if err != nil {
 		return fmt.Errorf("getting relative tar paths: %w", err)
 	}

pkg/skaffold/docker/dependencies.go

@@ -48,17 +48,33 @@ func NormalizeDockerfilePath(context, dockerfile string) (string, error) {
 }
 
 // GetDependencies finds the sources dependency for the given docker artifact.
+// it caches the results for the computed dependency which can be used by `GetDependenciesCached`
 // All paths are relative to the workspace.
 func GetDependencies(ctx context.Context, workspace string, dockerfilePath string, buildArgs map[string]*string, cfg Config) ([]string, error) {
 	absDockerfilePath, err := NormalizeDockerfilePath(workspace, dockerfilePath)
 	if err != nil {
 		return nil, fmt.Errorf("normalizing dockerfile path: %w", err)
 	}
+	result := getDependencies(workspace, dockerfilePath, absDockerfilePath, buildArgs, cfg)
+	dependencyCache.Store(absDockerfilePath, result)
+	return resultPair(result)
+}
+
+// GetDependenciesCached reads from cache finds the sources dependency for the given docker artifact.
+// All paths are relative to the workspace.
+func GetDependenciesCached(ctx context.Context, workspace string, dockerfilePath string, buildArgs map[string]*string, cfg Config) ([]string, error) {
+	absDockerfilePath, err := NormalizeDockerfilePath(workspace, dockerfilePath)
+	if err != nil {
+		return nil, fmt.Errorf("normalizing dockerfile path: %w", err)
+	}
 
 	deps := dependencyCache.Exec(absDockerfilePath, func() interface{} {
 		return getDependencies(workspace, dockerfilePath, absDockerfilePath, buildArgs, cfg)
 	})
+	return resultPair(deps)
+}
 
+func resultPair(deps interface{}) ([]string, error) {
 	switch t := deps.(type) {
 	case error:
 		return nil, t

pkg/skaffold/docker/dependencies_test.go

@@ -708,7 +708,7 @@ func TestGetDependenciesCached(t *testing.T) {
 					return v
 				})
 			}
-			deps, err := GetDependencies(context.Background(), tmpDir.Root(), "Dockerfile", map[string]*string{}, nil)
+			deps, err := GetDependenciesCached(context.Background(), tmpDir.Root(), "Dockerfile", map[string]*string{}, nil)
 			t.CheckErrorAndDeepEqual(test.shouldErr, err, test.expected, deps)
 		})
 	}

pkg/skaffold/util/store.go

@@ -54,6 +54,15 @@ func (o *SyncStore) Exec(key string, f func() interface{}) interface{} {
 	return val
 }
 
+// Store will store the results for a key in a cache
+// It makes sure only one execution is in-flight for a given key at any time.
+func (o *SyncStore) Store(key string, r interface{}) {
+	o.sf.Do(fmt.Sprintf("%s-put", key), func() (interface{}, error) {
+		o.results.Store(key, r)
+		return nil, nil
+	})
+}
+
 // NewSyncStore returns a new instance of `SyncStore`
 func NewSyncStore() *SyncStore {
 	return &SyncStore{