Skip pulling layers reusable from additional layer store

Signed-off-by: Kohei Tokunaga <[email protected]>

copy/copy.go

@@ -16,6 +16,7 @@ import (
 	"github.com/containers/image/v5/image"
 	internalblobinfocache "github.com/containers/image/v5/internal/blobinfocache"
 	"github.com/containers/image/v5/internal/pkg/platform"
+	internaltypes "github.com/containers/image/v5/internal/types"
 	"github.com/containers/image/v5/manifest"
 	"github.com/containers/image/v5/pkg/blobinfocache"
 	"github.com/containers/image/v5/pkg/compression"
@@ -833,7 +834,7 @@ func (ic *imageCopier) copyLayers(ctx context.Context) error {
 	}
 
 	data := make([]copyLayerData, numLayers)
-	copyLayerHelper := func(index int, srcLayer types.BlobInfo, toEncrypt bool, pool *mpb.Progress) {
+	copyLayerHelper := func(index int, srcLayer types.BlobInfo, toEncrypt bool, pool *mpb.Progress, srcRef reference.Named) {
 		defer copySemaphore.Release(1)
 		defer copyGroup.Done()
 		cld := copyLayerData{}
@@ -848,7 +849,7 @@ func (ic *imageCopier) copyLayers(ctx context.Context) error {
 				logrus.Debugf("Skipping foreign layer %q copy to %s", cld.destInfo.Digest, ic.c.dest.Reference().Transport().Name())
 			}
 		} else {
-			cld.destInfo, cld.diffID, cld.err = ic.copyLayer(ctx, srcLayer, toEncrypt, pool)
+			cld.destInfo, cld.diffID, cld.err = ic.copyLayer(ctx, srcLayer, toEncrypt, pool, srcRef)
 		}
 		data[index] = cld
 	}
@@ -885,7 +886,7 @@ func (ic *imageCopier) copyLayers(ctx context.Context) error {
 				return errors.Wrapf(err, "Can't acquire semaphore")
 			}
 			copyGroup.Add(1)
-			go copyLayerHelper(i, srcLayer, encLayerBitmap[i], progressPool)
+			go copyLayerHelper(i, srcLayer, encLayerBitmap[i], progressPool, ic.c.rawSource.Reference().DockerReference())
 		}
 
 		// A call to copyGroup.Wait() is done at this point by the defer above.
@@ -1068,7 +1069,8 @@ type diffIDResult struct {
 
 // copyLayer copies a layer with srcInfo (with known Digest and Annotations and possibly known Size) in src to dest, perhaps (de/re/)compressing it,
 // and returns a complete blobInfo of the copied layer, and a value for LayerDiffIDs if diffIDIsNeeded
-func (ic *imageCopier) copyLayer(ctx context.Context, srcInfo types.BlobInfo, toEncrypt bool, pool *mpb.Progress) (types.BlobInfo, digest.Digest, error) {
+// srcRef can be used as an additional hint to the destination during checking whehter a layer can be reused but srcRef can be nil.
+func (ic *imageCopier) copyLayer(ctx context.Context, srcInfo types.BlobInfo, toEncrypt bool, pool *mpb.Progress, srcRef reference.Named) (types.BlobInfo, digest.Digest, error) {
 	cachedDiffID := ic.c.blobInfoCache.UncompressedDigest(srcInfo.Digest) // May be ""
 	// Diffs are needed if we are encrypting an image or trying to decrypt an image
 	diffIDIsNeeded := ic.diffIDsAreNeeded && cachedDiffID == "" || toEncrypt || (isOciEncrypted(srcInfo.MediaType) && ic.c.ociDecryptConfig != nil)
@@ -1081,7 +1083,16 @@ func (ic *imageCopier) copyLayer(ctx context.Context, srcInfo types.BlobInfo, to
 		// a failure when we eventually try to update the manifest with the digest and MIME type of the reused blob.
 		// Fixing that will probably require passing more information to TryReusingBlob() than the current version of
 		// the ImageDestination interface lets us pass in.
-		reused, blobInfo, err := ic.c.dest.TryReusingBlob(ctx, srcInfo, ic.c.blobInfoCache, ic.canSubstituteBlobs)
+		var (
+			reused   bool
+			blobInfo types.BlobInfo
+			err      error
+		)
+		if rDest, ok := ic.c.dest.(internaltypes.ImageDestinationReusableWithRef); ok && srcRef != nil {
+			reused, blobInfo, err = rDest.TryReusingBlobWithSrcRef(ctx, srcInfo, srcRef, ic.c.blobInfoCache, ic.canSubstituteBlobs)
+		} else {
+			reused, blobInfo, err = ic.c.dest.TryReusingBlob(ctx, srcInfo, ic.c.blobInfoCache, ic.canSubstituteBlobs)
+		}
 		if err != nil {
 			return types.BlobInfo{}, "", errors.Wrapf(err, "Error trying to reuse blob %s at destination", srcInfo.Digest)
 		}

internal/types/types.go

@@ -0,0 +1,19 @@
+package types
+
+import (
+	"context"
+
+	"github.com/containers/image/v5/types"
+	"github.com/containers/image/v5/docker/reference"
+)
+
+// ImageDestinationReusableWithRef is a variant of ImageDestination that tries to reuse blob contents with
+// taking the image reference into consideration. One of the use-cases of this is "additional layer store"
+// where some backends require the image reference to be passed.
+type ImageDestinationReusableWithRef interface {
+	types.ImageDestination
+
+	// TryReusingBlobWithRef checks whether the destination can efficiently reuse a blob, and if so, applies it to the current destination.
+	// This allows the destination to search the blob contents with taking the image reference into consideration.
+	TryReusingBlobWithSrcRef(ctx context.Context, blobinfo types.BlobInfo, srcRef reference.Named, cache types.BlobInfoCache, canSubstitute bool) (bool, types.BlobInfo, error)
+}

storage/storage_image.go

@@ -53,18 +53,19 @@ type storageImageSource struct {
 }
 
 type storageImageDestination struct {
-	imageRef        storageReference
-	directory       string                          // Temporary directory where we store blobs until Commit() time
-	nextTempFileID  int32                           // A counter that we use for computing filenames to assign to blobs
-	manifest        []byte                          // Manifest contents, temporary
-	signatures      []byte                          // Signature contents, temporary
-	signatureses    map[digest.Digest][]byte        // Instance signature contents, temporary
-	putBlobMutex    sync.Mutex                      // Mutex to sync state for parallel PutBlob executions
-	blobDiffIDs     map[digest.Digest]digest.Digest // Mapping from layer blobsums to their corresponding DiffIDs
-	fileSizes       map[digest.Digest]int64         // Mapping from layer blobsums to their sizes
-	filenames       map[digest.Digest]string        // Mapping from layer blobsums to names of files we used to hold them
-	SignatureSizes  []int                           `json:"signature-sizes,omitempty"`  // List of sizes of each signature slice
-	SignaturesSizes map[digest.Digest][]int         `json:"signatures-sizes,omitempty"` // Sizes of each manifest's signature slice
+	imageRef            storageReference
+	directory           string                                    // Temporary directory where we store blobs until Commit() time
+	nextTempFileID      int32                                     // A counter that we use for computing filenames to assign to blobs
+	manifest            []byte                                    // Manifest contents, temporary
+	signatures          []byte                                    // Signature contents, temporary
+	signatureses        map[digest.Digest][]byte                  // Instance signature contents, temporary
+	putBlobMutex        sync.Mutex                                // Mutex to sync state for parallel PutBlob executions
+	blobDiffIDs         map[digest.Digest]digest.Digest           // Mapping from layer blobsums to their corresponding DiffIDs
+	blobAdditionalLayer map[digest.Digest]storage.AdditionalLayer // Mapping from layer blobsums to their corresponding additional layer
+	fileSizes           map[digest.Digest]int64                   // Mapping from layer blobsums to their sizes
+	filenames           map[digest.Digest]string                  // Mapping from layer blobsums to names of files we used to hold them
+	SignatureSizes      []int                                     `json:"signature-sizes,omitempty"`  // List of sizes of each signature slice
+	SignaturesSizes     map[digest.Digest][]int                   `json:"signatures-sizes,omitempty"` // Sizes of each manifest's signature slice
 }
 
 type storageImageCloser struct {
@@ -348,14 +349,15 @@ func newImageDestination(sys *types.SystemContext, imageRef storageReference) (*
 		return nil, errors.Wrapf(err, "error creating a temporary directory")
 	}
 	image := &storageImageDestination{
-		imageRef:        imageRef,
-		directory:       directory,
-		signatureses:    make(map[digest.Digest][]byte),
-		blobDiffIDs:     make(map[digest.Digest]digest.Digest),
-		fileSizes:       make(map[digest.Digest]int64),
-		filenames:       make(map[digest.Digest]string),
-		SignatureSizes:  []int{},
-		SignaturesSizes: make(map[digest.Digest][]int),
+		imageRef:            imageRef,
+		directory:           directory,
+		signatureses:        make(map[digest.Digest][]byte),
+		blobDiffIDs:         make(map[digest.Digest]digest.Digest),
+		blobAdditionalLayer: make(map[digest.Digest]storage.AdditionalLayer),
+		fileSizes:           make(map[digest.Digest]int64),
+		filenames:           make(map[digest.Digest]string),
+		SignatureSizes:      []int{},
+		SignaturesSizes:     make(map[digest.Digest][]int),
 	}
 	return image, nil
 }
@@ -366,8 +368,11 @@ func (s *storageImageDestination) Reference() types.ImageReference {
 	return s.imageRef
 }
 
-// Close cleans up the temporary directory.
+// Close cleans up the temporary directory and additional layer store handlers.
 func (s *storageImageDestination) Close() error {
+	for _, al := range s.blobAdditionalLayer {
+		al.Release()
+	}
 	return os.RemoveAll(s.directory)
 }
 
@@ -459,6 +464,29 @@ func (s *storageImageDestination) PutBlob(ctx context.Context, stream io.Reader,
 	}, nil
 }
 
+func (s *storageImageDestination) TryReusingBlobWithSrcRef(ctx context.Context, blobinfo types.BlobInfo, ref reference.Named, cache types.BlobInfoCache, canSubstitute bool) (bool, types.BlobInfo, error) {
+	// lock the entire method as it executes fairly quickly
+	s.putBlobMutex.Lock()
+	defer s.putBlobMutex.Unlock()
+
+	// Check if we have the layer in the underlying additional layer store.
+	aLayer, err := s.imageRef.transport.store.LookupAdditionalLayer(blobinfo.Digest, ref.String())
+	if err != nil && errors.Cause(err) != storage.ErrLayerUnknown {
+		return false, types.BlobInfo{}, errors.Wrapf(err, `Error looking for compressed layers with digest %q and labels`, blobinfo.Digest)
+	} else if err == nil {
+		// Record the uncompressed value so that we can use it to calculate layer IDs.
+		s.blobDiffIDs[blobinfo.Digest] = aLayer.UncompressedDigest()
+		s.blobAdditionalLayer[blobinfo.Digest] = aLayer
+		return true, types.BlobInfo{
+			Digest:    blobinfo.Digest,
+			Size:      aLayer.CompressedSize(),
+			MediaType: blobinfo.MediaType,
+		}, nil
+	}
+
+	return s.tryReusingBlobLocked(ctx, blobinfo, cache, canSubstitute)
+}
+
 // TryReusingBlob checks whether the transport already contains, or can efficiently reuse, a blob, and if so, applies it to the current destination
 // (e.g. if the blob is a filesystem layer, this signifies that the changes it describes need to be applied again when composing a filesystem tree).
 // info.Digest must not be empty.
@@ -472,6 +500,11 @@ func (s *storageImageDestination) TryReusingBlob(ctx context.Context, blobinfo t
 	// lock the entire method as it executes fairly quickly
 	s.putBlobMutex.Lock()
 	defer s.putBlobMutex.Unlock()
+
+	return s.tryReusingBlobLocked(ctx, blobinfo, cache, canSubstitute)
+}
+
+func (s *storageImageDestination) tryReusingBlobLocked(ctx context.Context, blobinfo types.BlobInfo, cache types.BlobInfoCache, canSubstitute bool) (bool, types.BlobInfo, error) {
 	if blobinfo.Digest == "" {
 		return false, types.BlobInfo{}, errors.Errorf(`Can not check for a blob with unknown digest`)
 	}
@@ -684,6 +717,15 @@ func (s *storageImageDestination) Commit(ctx context.Context, unparsedToplevel t
 			lastLayer = layer.ID
 			continue
 		}
+		if al, ok := s.blobAdditionalLayer[blob.Digest]; ok {
+			layer, err := al.PutAs(id, lastLayer, nil)
+			if err != nil {
+				return errors.Wrapf(err, "failed to put layer from digest and labels")
+			}
+			lastLayer = layer.ID
+			continue
+		}
+
 		// Check if we previously cached a file with that blob's contents.  If we didn't,
 		// then we need to read the desired contents from a layer.
 		filename, ok := s.filenames[blob.Digest]