Fix inline cache export compression config propagation and the corres…

…ponding tests Signed-off-by: a-palchikov <deemok@gmail.com>
moby · May 27, 2022 · 384c0ee · 384c0ee
1 parent 25b13b3
commit 384c0ee
Show file tree

Hide file tree

Showing 5 changed files with 84 additions and 69 deletions.
diff --git a/client/client_test.go b/client/client_test.go
@@ -1905,17 +1905,16 @@ func testPreventsMultipleExportWithSameExporter(t *testing.T, sb integration.San
 	def, err := llb.Scratch().File(llb.Mkfile("foo.txt", 0o755, nil)).Marshal(sb.Context())
 	require.NoError(t, err)
 
-	destDir1, destDir2 := t.TempDir(), t.TempDir()
-
+	dummyOutput := func(map[string]string) (io.WriteCloser, error) { return nil, fmt.Errorf("not implemented") }
 	_, err = c.Solve(sb.Context(), def, SolveOpt{
 		Exports: []ExportEntry{
 			{
-				Type:      ExporterOCI,
-				OutputDir: destDir1,
+				Type:   ExporterOCI,
+				Output: dummyOutput,
 			},
 			{
-				Type:      ExporterOCI,
-				OutputDir: destDir2,
+				Type:   ExporterOCI,
+				Output: dummyOutput,
 			},
 		},
 	}, nil)

diff --git a/exporter/containerimage/export.go b/exporter/containerimage/export.go
@@ -272,8 +272,9 @@ func (e *imageExporterInstance) Name() string {
 }
 
 func (e *imageExporterInstance) Config() exporter.Config {
+	compression := e.compression()
 	return exporter.Config{
-		Compression: e.compression(),
+		Compression: &compression,
 	}
 }
 

diff --git a/exporter/exporter.go b/exporter/exporter.go
@@ -24,5 +24,5 @@ type Source struct {
 }
 
 type Config struct {
-	Compression compression.Config
+	Compression *compression.Config
 }
diff --git a/exporter/oci/export.go b/exporter/oci/export.go
@@ -180,8 +180,9 @@ func (e *imageExporterInstance) Name() string {
 }
 
 func (e *imageExporterInstance) Config() exporter.Config {
+	compression := e.compression()
 	return exporter.Config{
-		Compression: e.compression(),
+		Compression: &compression,
 	}
 }
 

diff --git a/solver/llbsolver/solver.go b/solver/llbsolver/solver.go
@@ -199,76 +199,81 @@ func (s *Solver) Solve(ctx context.Context, id string, sessionID string, req fro
 		}
 	}
 
-	inp := exporter.Source{
-		Metadata: res.Metadata,
-	}
-	if inp.Metadata == nil {
-		inp.Metadata = make(map[string][]byte)
-	}
-	var cr solver.CachedResult
-	var crMap = map[string]solver.CachedResult{}
-	if res := res.Ref; res != nil {
-		r, err := res.Result(ctx)
-		if err != nil {
-			return nil, err
+	var exporterResponse map[string]string
+	if len(exp.Exporters) != 0 {
+		inp := exporter.Source{
+			Metadata: res.Metadata,
 		}
-		workerRef, ok := r.Sys().(*worker.WorkerRef)
-		if !ok {
-			return nil, errors.Errorf("invalid reference: %T", r.Sys())
+		if inp.Metadata == nil {
+			inp.Metadata = make(map[string][]byte)
 		}
-		inp.Ref = workerRef.ImmutableRef
-		cr = r
-	}
-	if res.Refs != nil {
-		m := make(map[string]cache.ImmutableRef, len(res.Refs))
-		for k, res := range res.Refs {
-			if res == nil {
-				m[k] = nil
-			} else {
-				r, err := res.Result(ctx)
-				if err != nil {
-					return nil, err
-				}
-				workerRef, ok := r.Sys().(*worker.WorkerRef)
-				if !ok {
-					return nil, errors.Errorf("invalid reference: %T", r.Sys())
-				}
-				m[k] = workerRef.ImmutableRef
-				crMap[k] = r
+		var cr solver.CachedResult
+		var crMap = map[string]solver.CachedResult{}
+		if res := res.Ref; res != nil {
+			r, err := res.Result(ctx)
+			if err != nil {
+				return nil, err
 			}
+			workerRef, ok := r.Sys().(*worker.WorkerRef)
+			if !ok {
+				return nil, errors.Errorf("invalid reference: %T", r.Sys())
+			}
+			inp.Ref = workerRef.ImmutableRef
+			cr = r
 		}
-		inp.Refs = m
-	}
-	if e, ok := asInlineCache(exp.CacheExporter); ok {
-		if err := inBuilderContext(ctx, j, "preparing layers for inline cache", "", func(ctx context.Context, _ session.Group) error {
-			if cr != nil {
-				dtic, err := inlineCache(ctx, exp.CacheExporter, cr, e.Config().Compression, session.NewGroup(sessionID))
-				if err != nil {
-					return err
-				}
-				if dtic != nil {
-					inp.Metadata[exptypes.ExporterInlineCache] = dtic
+		if res.Refs != nil {
+			m := make(map[string]cache.ImmutableRef, len(res.Refs))
+			for k, res := range res.Refs {
+				if res == nil {
+					m[k] = nil
+				} else {
+					r, err := res.Result(ctx)
+					if err != nil {
+						return nil, err
+					}
+					workerRef, ok := r.Sys().(*worker.WorkerRef)
+					if !ok {
+						return nil, errors.Errorf("invalid reference: %T", r.Sys())
+					}
+					m[k] = workerRef.ImmutableRef
+					crMap[k] = r
 				}
 			}
-			for k, res := range crMap {
-				dtic, err := inlineCache(ctx, exp.CacheExporter, res, e.Config().Compression, session.NewGroup(sessionID))
-				if err != nil {
-					return err
+			inp.Refs = m
+		}
+
+		if _, ok := asInlineCache(exp.CacheExporter); ok {
+			if err := inBuilderContext(ctx, j, "preparing layers for inline cache", "", func(ctx context.Context, _ session.Group) error {
+				compression := inlineCacheExporterCompression(exp.Exporters)
+				if cr != nil {
+					dtic, err := inlineCache(ctx, exp.CacheExporter, cr, compression, session.NewGroup(sessionID))
+					if err != nil {
+						return err
+					}
+					if dtic != nil {
+						inp.Metadata[exptypes.ExporterInlineCache] = dtic
+					}
 				}
-				if dtic != nil {
-					inp.Metadata[fmt.Sprintf("%s/%s", exptypes.ExporterInlineCache, k)] = dtic
+				for k, res := range crMap {
+					dtic, err := inlineCache(ctx, exp.CacheExporter, res, compression, session.NewGroup(sessionID))
+					if err != nil {
+						return err
+					}
+					if dtic != nil {
+						inp.Metadata[fmt.Sprintf("%s/%s", exptypes.ExporterInlineCache, k)] = dtic
+					}
 				}
+				exp.CacheExporter = nil
+				return nil
+			}); err != nil {
+				return nil, err
 			}
-			exp.CacheExporter = nil
-			return nil
-		}); err != nil {
-			return nil, err
 		}
-	}
 
-	exporterResponse, err := runExporters(ctx, exp.Exporters, inp, j)
-	if err != nil {
-		return nil, err
+		exporterResponse, err = runExporters(ctx, exp.Exporters, inp, j)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	g := session.NewGroup(j.SessionID)
@@ -333,6 +338,16 @@ func (s *Solver) Solve(ctx context.Context, id string, sessionID string, req fro
 	}, nil
 }
 
+// inlineCacheExporterCompression selects the compression configuration for the inline cache exporter.
+func inlineCacheExporterCompression(exporters []exporter.ExporterInstance) compression.Config {
+	for _, exp := range exporters {
+		if compression := exp.Config().Compression; compression != nil {
+			return *compression
+		}
+	}
+	return compression.Config{}
+}
+
 func runExporters(ctx context.Context, exporters []exporter.ExporterInstance, input exporter.Source, job *solver.Job) (exporterResponse map[string]string, err error) {
 	eg, ctx := errgroup.WithContext(ctx)
 	sessionID := job.SessionID
@@ -364,7 +379,6 @@ func runExporters(ctx context.Context, exporters []exporter.ExporterInstance, in
 
 type inlineCacheExporter interface {
 	ExportForLayers(context.Context, []digest.Digest) ([]byte, error)
-	Config() remotecache.Config
 }
 
 func asInlineCache(e remotecache.Exporter) (inlineCacheExporter, bool) {