mutate: Add() should tell you what it added

cmd/umoci/insert.go

@@ -189,7 +189,7 @@ func insert(ctx *cli.Context) error {
 
 	// TODO: We should add a flag to allow for a new layer to be made
 	//       non-distributable.
-	if err := mutator.Add(context.Background(), reader, history); err != nil {
+	if _, err := mutator.Add(context.Background(), reader, history); err != nil {
 		return errors.Wrap(err, "add diff layer")
 	}
 

cmd/umoci/raw-add-layer.go

@@ -155,7 +155,7 @@ func rawAddLayer(ctx *cli.Context) error {
 
 	// TODO: We should add a flag to allow for a new layer to be made
 	//       non-distributable.
-	if err := mutator.Add(context.Background(), newLayer, history); err != nil {
+	if _, err := mutator.Add(context.Background(), newLayer, history); err != nil {
 		return errors.Wrap(err, "add diff layer")
 	}
 

mutate/mutate.go

@@ -155,6 +155,17 @@ func (m *Mutator) Config(ctx context.Context) (ispec.ImageConfig, error) {
 	return m.config.Config, nil
 }
 
+// Manifest returns the current (cached) image manifest. This is what will be
+// appended to when any additional Add() calls are made, and what will be
+// Commit()ed if no further changes are made.
+func (m *Mutator) Manifest(ctx context.Context) (ispec.Manifest, error) {
+	if err := m.cache(ctx); err != nil {
+		return ispec.Manifest{}, errors.Wrap(err, "getting cache failed")
+	}
+
+	return *m.manifest, nil
+}
+
 // Meta returns the current (cached) image metadata, which should be used as
 // the source for any modifications of the configuration using Set.
 func (m *Mutator) Meta(ctx context.Context) (Meta, error) {
@@ -280,46 +291,50 @@ func (m *Mutator) add(ctx context.Context, reader io.Reader, history *ispec.Hist
 // generate the DiffIDs for the image metatadata. The provided history entry is
 // appended to the image's history and should correspond to what operations
 // were made to the configuration.
-func (m *Mutator) Add(ctx context.Context, r io.Reader, history *ispec.History) error {
+func (m *Mutator) Add(ctx context.Context, r io.Reader, history *ispec.History) (ispec.Descriptor, error) {
+	desc := ispec.Descriptor{}
 	if err := m.cache(ctx); err != nil {
-		return errors.Wrap(err, "getting cache failed")
+		return desc, errors.Wrap(err, "getting cache failed")
 	}
 
 	digest, size, err := m.add(ctx, r, history)
 	if err != nil {
-		return errors.Wrap(err, "add layer")
+		return desc, errors.Wrap(err, "add layer")
 	}
 
 	// Append to layers.
-	m.manifest.Layers = append(m.manifest.Layers, ispec.Descriptor{
+	desc = ispec.Descriptor{
 		// TODO: Detect whether the layer is gzip'd or not...
 		MediaType: ispec.MediaTypeImageLayerGzip,
 		Digest:    digest,
 		Size:      size,
-	})
-	return nil
+	}
+	m.manifest.Layers = append(m.manifest.Layers, desc)
+	return desc, nil
 }
 
 // AddNonDistributable is the same as Add, except it adds a non-distributable
 // layer to the image.
-func (m *Mutator) AddNonDistributable(ctx context.Context, r io.Reader, history *ispec.History) error {
+func (m *Mutator) AddNonDistributable(ctx context.Context, r io.Reader, history *ispec.History) (ispec.Descriptor, error) {
+	desc := ispec.Descriptor{}
 	if err := m.cache(ctx); err != nil {
-		return errors.Wrap(err, "getting cache failed")
+		return desc, errors.Wrap(err, "getting cache failed")
 	}
 
 	digest, size, err := m.add(ctx, r, history)
 	if err != nil {
-		return errors.Wrap(err, "add non-distributable layer")
+		return desc, errors.Wrap(err, "add non-distributable layer")
 	}
 
 	// Append to layers.
-	m.manifest.Layers = append(m.manifest.Layers, ispec.Descriptor{
+	desc = ispec.Descriptor{
 		// TODO: Detect whether the layer is gzip'd or not...
 		MediaType: ispec.MediaTypeImageLayerNonDistributableGzip,
 		Digest:    digest,
 		Size:      size,
-	})
-	return nil
+	}
+	m.manifest.Layers = append(m.manifest.Layers, desc)
+	return desc, nil
 }
 
 // Commit writes all of the temporary changes made to the configuration,

mutate/mutate_test.go

@@ -215,9 +215,10 @@ func TestMutateAdd(t *testing.T) {
 	buffer := bytes.NewBufferString("contents")
 
 	// Add a new layer.
-	if err := mutator.Add(context.Background(), buffer, &ispec.History{
+	newLayerDesc, err := mutator.Add(context.Background(), buffer, &ispec.History{
 		Comment: "new layer",
-	}); err != nil {
+	})
+	if err != nil {
 		t.Fatalf("unexpected error adding layer: %+v", err)
 	}
 
@@ -251,6 +252,19 @@ func TestMutateAdd(t *testing.T) {
 		t.Errorf("manifest.Layers[1].Digest is not the same!")
 	}
 
+	if mutator.manifest.Layers[1].Digest != newLayerDesc.Digest {
+		t.Fatalf("unexpected digest for new layer: %v %v", mutator.manifest.Layers[1].Digest, newLayerDesc.Digest)
+	}
+
+	manifestFromFunction, err := mutator.Manifest(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error getting manifest: %+v", err)
+	}
+
+	if !reflect.DeepEqual(manifestFromFunction, *mutator.manifest) {
+		t.Fatalf("mutator.Manifest() didn't return the cached manifest")
+	}
+
 	// Check layer was added.
 	if len(mutator.manifest.Layers) != 2 {
 		t.Errorf("manifest.Layers was not updated")
@@ -295,9 +309,10 @@ func TestMutateAddNonDistributable(t *testing.T) {
 	buffer := bytes.NewBufferString("contents")
 
 	// Add a new layer.
-	if err := mutator.AddNonDistributable(context.Background(), buffer, &ispec.History{
+	newLayerDesc, err := mutator.AddNonDistributable(context.Background(), buffer, &ispec.History{
 		Comment: "new layer",
-	}); err != nil {
+	})
+	if err != nil {
 		t.Fatalf("unexpected error adding layer: %+v", err)
 	}
 
@@ -330,6 +345,9 @@ func TestMutateAddNonDistributable(t *testing.T) {
 	if mutator.manifest.Layers[1].Digest == expectedLayerDigest {
 		t.Errorf("manifest.Layers[1].Digest is not the same!")
 	}
+	if mutator.manifest.Layers[1].Digest != newLayerDesc.Digest {
+		t.Fatalf("unexpected digest for new layer: %v %v", mutator.manifest.Layers[1].Digest, newLayerDesc.Digest)
+	}
 
 	// Check layer was added.
 	if len(mutator.manifest.Layers) != 2 {

repack.go

@@ -110,7 +110,7 @@ func Repack(engineExt casext.Engine, tagName string, bundlePath string, meta Met
 
 		// TODO: We should add a flag to allow for a new layer to be made
 		//       non-distributable.
-		if err := mutator.Add(context.Background(), reader, history); err != nil {
+		if _, err := mutator.Add(context.Background(), reader, history); err != nil {
 			return errors.Wrap(err, "add diff layer")
 		}
 	}