removing blobs from test data, after testing on pack we don't want to…

… save the image information. Reimplement the getters/setters to read the information from the index. Adding more test coverage

Signed-off-by: Juan Bustamante <[email protected]>

cnb_index.go

@@ -35,161 +35,144 @@ type CNBIndex struct {
 	RepoName string
 }
 
-func (h *CNBIndex) getConfigFileFrom(digest name.Digest) (v1.ConfigFile, error) {
-	hash, err := v1.NewHash(digest.Identifier())
-	if err != nil {
-		return v1.ConfigFile{}, err
-	}
-	image, err := h.Image(hash)
-	if err != nil {
-		return v1.ConfigFile{}, err
-	}
-	configFile, err := GetConfigFile(image)
-	if err != nil {
-		return v1.ConfigFile{}, err
-	}
-	return *configFile, nil
-}
-
-func (h *CNBIndex) getManifestFileFrom(digest name.Digest) (v1.Manifest, error) {
-	hash, err := v1.NewHash(digest.Identifier())
-	if err != nil {
-		return v1.Manifest{}, err
-	}
-	image, err := h.Image(hash)
+func (h *CNBIndex) getDescriptorFrom(digest name.Digest) (v1.Descriptor, error) {
+	indexManifest, err := getIndexManifest(h.ImageIndex)
 	if err != nil {
-		return v1.Manifest{}, err
+		return v1.Descriptor{}, err
 	}
-	manifestFile, err := GetManifest(image)
-	if err != nil {
-		return v1.Manifest{}, err
+	for _, current := range indexManifest.Manifests {
+		if current.Digest.String() == digest.Identifier() {
+			return current, nil
+		}
 	}
-	return *manifestFile, nil
+	return v1.Descriptor{}, fmt.Errorf("failed to find image with digest %s in index", digest.Identifier())
 }
 
 // OS returns `OS` of an existing Image.
 func (h *CNBIndex) OS(digest name.Digest) (os string, err error) {
-	configFile, err := h.getConfigFileFrom(digest)
+	desc, err := h.getDescriptorFrom(digest)
 	if err != nil {
 		return "", err
 	}
-	return configFile.OS, nil
+	if desc.Platform != nil {
+		return desc.Platform.OS, nil
+	}
+	return "", nil
 }
 
 // Architecture return the Architecture of an Image/Index based on given Digest.
 // Returns an error if no Image/Index found with given Digest.
 func (h *CNBIndex) Architecture(digest name.Digest) (arch string, err error) {
-	configFile, err := h.getConfigFileFrom(digest)
+	desc, err := h.getDescriptorFrom(digest)
 	if err != nil {
 		return "", err
 	}
-	return configFile.Architecture, nil
+	if desc.Platform != nil {
+		return desc.Platform.Architecture, nil
+	}
+	return "", nil
 }
 
 // Variant return the `Variant` of an Image.
 // Returns an error if no Image/Index found with given Digest.
 func (h *CNBIndex) Variant(digest name.Digest) (osVariant string, err error) {
-	configFile, err := h.getConfigFileFrom(digest)
+	desc, err := h.getDescriptorFrom(digest)
 	if err != nil {
 		return "", err
 	}
-	return configFile.Variant, nil
+	if desc.Platform != nil {
+		return desc.Platform.Variant, nil
+	}
+	return "", nil
 }
 
 // OSVersion returns the `OSVersion` of an Image with given Digest.
 // Returns an error if no Image/Index found with given Digest.
 func (h *CNBIndex) OSVersion(digest name.Digest) (osVersion string, err error) {
-	configFile, err := h.getConfigFileFrom(digest)
+	desc, err := h.getDescriptorFrom(digest)
 	if err != nil {
 		return "", err
 	}
-	return configFile.OSVersion, nil
+	if desc.Platform != nil {
+		return desc.Platform.OSVersion, nil
+	}
+	return "", nil
 }
 
 // OSFeatures returns the `OSFeatures` of an Image with given Digest.
 // Returns an error if no Image/Index found with given Digest.
 func (h *CNBIndex) OSFeatures(digest name.Digest) (osFeatures []string, err error) {
-	configFile, err := h.getConfigFileFrom(digest)
+	desc, err := h.getDescriptorFrom(digest)
 	if err != nil {
 		return nil, err
 	}
-	return configFile.OSFeatures, nil
+	if desc.Platform != nil {
+		return desc.Platform.OSFeatures, nil
+	}
+	return []string{}, nil
 }
 
 // Annotations return the `Annotations` of an Image with given Digest.
 // Returns an error if no Image/Index found with given Digest.
 // For Docker images and Indexes it returns an error.
 func (h *CNBIndex) Annotations(digest name.Digest) (annotations map[string]string, err error) {
-	manifestFile, err := h.getManifestFileFrom(digest)
+	desc, err := h.getDescriptorFrom(digest)
 	if err != nil {
 		return nil, err
 	}
-	return manifestFile.Annotations, nil
+	return desc.Annotations, nil
 }
 
 // setters
 
 func (h *CNBIndex) SetAnnotations(digest name.Digest, annotations map[string]string) (err error) {
-	return h.mutateExistingImage(digest, func(image v1.Image) (v1.Image, error) {
-		partial := mutate.Annotations(image, annotations)
-		annotatedImage, ok := partial.(v1.Image)
-		if !ok {
-			return nil, fmt.Errorf("failed to annotate image")
+	return h.replaceDescriptor(digest, func(descriptor v1.Descriptor) (v1.Descriptor, error) {
+		if len(descriptor.Annotations) == 0 {
+			descriptor.Annotations = make(map[string]string)
 		}
-		return annotatedImage, nil
+
+		for k, v := range annotations {
+			descriptor.Annotations[k] = v
+		}
+		return descriptor, nil
 	})
 }
 
 func (h *CNBIndex) SetArchitecture(digest name.Digest, arch string) (err error) {
-	return h.mutateExistingImage(digest, func(image v1.Image) (v1.Image, error) {
-		configFile, err := image.ConfigFile()
-		if err != nil {
-			return nil, err
-		}
-		configFile.Architecture = arch
-		return mutate.ConfigFile(image, configFile)
+	return h.replaceDescriptor(digest, func(descriptor v1.Descriptor) (v1.Descriptor, error) {
+		descriptor.Platform.Architecture = arch
+		return descriptor, nil
 	})
 }
 
 func (h *CNBIndex) SetOS(digest name.Digest, os string) (err error) {
-	return h.mutateExistingImage(digest, func(image v1.Image) (v1.Image, error) {
-		configFile, err := image.ConfigFile()
-		if err != nil {
-			return nil, err
-		}
-		configFile.OS = os
-		return mutate.ConfigFile(image, configFile)
+	return h.replaceDescriptor(digest, func(descriptor v1.Descriptor) (v1.Descriptor, error) {
+		descriptor.Platform.OS = os
+		return descriptor, nil
 	})
 }
 
 func (h *CNBIndex) SetVariant(digest name.Digest, osVariant string) (err error) {
-	return h.mutateExistingImage(digest, func(image v1.Image) (v1.Image, error) {
-		configFile, err := image.ConfigFile()
-		if err != nil {
-			return nil, err
-		}
-		configFile.Variant = osVariant
-		return mutate.ConfigFile(image, configFile)
+	return h.replaceDescriptor(digest, func(descriptor v1.Descriptor) (v1.Descriptor, error) {
+		descriptor.Platform.Variant = osVariant
+		return descriptor, nil
 	})
 }
 
-func (h *CNBIndex) mutateExistingImage(digest name.Digest, withFunc func(image v1.Image) (v1.Image, error)) (err error) {
-	hash, err := v1.NewHash(digest.Identifier())
+func (h *CNBIndex) replaceDescriptor(digest name.Digest, withFun func(descriptor v1.Descriptor) (v1.Descriptor, error)) (err error) {
+	desc, err := h.getDescriptorFrom(digest)
 	if err != nil {
 		return err
 	}
-	image, err := h.Image(hash)
+	desc, err = withFun(desc)
 	if err != nil {
 		return err
 	}
-	if err = h.RemoveManifest(digest); err != nil {
-		return err
-	}
-	newImage, err := withFunc(image)
-	if err != nil {
-		return err
+	add := mutate.IndexAddendum{
+		Add:        h.ImageIndex,
+		Descriptor: desc,
 	}
-	h.AddManifest(newImage)
+	h.ImageIndex = mutate.AppendManifests(mutate.RemoveManifests(h.ImageIndex, match.Digests(desc.Digest)), add)
 	return nil
 }
 
@@ -215,8 +198,10 @@ func indexContains(manifests []v1.Descriptor, hash v1.Hash) bool {
 
 // AddManifest adds an image to the index.
 func (h *CNBIndex) AddManifest(image v1.Image) {
+	desc, _ := descriptor(image)
 	h.ImageIndex = mutate.AppendManifests(h.ImageIndex, mutate.IndexAddendum{
-		Add: image,
+		Add:        image,
+		Descriptor: desc,
 	})
 }
 
@@ -378,3 +363,19 @@ func getIndexManifest(ii v1.ImageIndex) (mfest *v1.IndexManifest, err error) {
 	}
 	return mfest, err
 }
+
+// descriptor returns a v1.Descriptor filled with a v1.Platform created from reading
+// the image config file.
+func descriptor(image v1.Image) (v1.Descriptor, error) {
+	// Get the image configuration file
+	cfg, _ := GetConfigFile(image)
+	platform := v1.Platform{}
+	platform.Architecture = cfg.Architecture
+	platform.OS = cfg.OS
+	platform.OSVersion = cfg.OSVersion
+	platform.Variant = cfg.Variant
+	platform.OSFeatures = cfg.OSFeatures
+	return v1.Descriptor{
+		Platform: &platform,
+	}, nil
+}

layout/layout_test.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"reflect"
 	"strings"
 	"testing"
 	"time"
@@ -1267,6 +1268,112 @@ func testIndex(t *testing.T, when spec.G, it spec.S) {
 		})
 	})
 
+	when("#Setters", func() {
+		var (
+			descriptor1 v1.Descriptor
+			digest1     name.Digest
+		)
+
+		when("index is created from scratch", func() {
+			it.Before(func() {
+				repoName := newRepoName()
+				idx = setupIndex(t, repoName, imgutil.WithXDGRuntimePath(tmpDir))
+				localPath = filepath.Join(tmpDir, repoName)
+			})
+
+			when("digest is provided", func() {
+				it.Before(func() {
+					image1, err := random.Image(1024, 1)
+					h.AssertNil(t, err)
+					idx.AddManifest(image1)
+
+					h.AssertNil(t, idx.SaveDir())
+
+					index := h.ReadIndexManifest(t, localPath)
+					h.AssertEq(t, len(index.Manifests), 1)
+					descriptor1 = index.Manifests[0]
+
+					digest1, err = name.NewDigest(fmt.Sprintf("%s@%s", "random", descriptor1.Digest.String()))
+					h.AssertNil(t, err)
+				})
+
+				it("platform attributes are written on disk", func() {
+					h.AssertNil(t, idx.SetOS(digest1, "linux"))
+					h.AssertNil(t, idx.SetArchitecture(digest1, "arm"))
+					h.AssertNil(t, idx.SetVariant(digest1, "v6"))
+					h.AssertNil(t, idx.SaveDir())
+
+					index := h.ReadIndexManifest(t, localPath)
+					h.AssertEq(t, len(index.Manifests), 1)
+					h.AssertEq(t, index.Manifests[0].Digest.String(), descriptor1.Digest.String())
+					h.AssertEq(t, index.Manifests[0].Platform.OS, "linux")
+					h.AssertEq(t, index.Manifests[0].Platform.Architecture, "arm")
+					h.AssertEq(t, index.Manifests[0].Platform.Variant, "v6")
+				})
+
+				it("annotations are written on disk", func() {
+					annotations := map[string]string{
+						"some-key": "some-value",
+					}
+					h.AssertNil(t, idx.SetAnnotations(digest1, annotations))
+					h.AssertNil(t, idx.SaveDir())
+
+					index := h.ReadIndexManifest(t, localPath)
+					h.AssertEq(t, len(index.Manifests), 1)
+					h.AssertEq(t, index.Manifests[0].Digest.String(), descriptor1.Digest.String())
+					h.AssertEq(t, reflect.DeepEqual(index.Manifests[0].Annotations, annotations), true)
+				})
+			})
+		})
+
+		when("index exists on disk", func() {
+			when("#FromBaseIndex", func() {
+				it.Before(func() {
+					idx = setupIndex(t, "busybox-multi-platform", imgutil.WithXDGRuntimePath(tmpDir), imgutil.FromBaseIndex(baseIndexPath))
+					localPath = filepath.Join(tmpDir, "busybox-multi-platform")
+					digest1, err = name.NewDigest("busybox@sha256:e18f2c12bb4ea582045415243370a3d9cf3874265aa2867f21a35e630ebe45a7")
+					h.AssertNil(t, err)
+				})
+
+				when("digest is provided", func() {
+					when("attributes already exists", func() {
+						it("platform attributes are updated on disk", func() {
+							h.AssertNil(t, idx.SetOS(digest1, "linux-2"))
+							h.AssertNil(t, idx.SetArchitecture(digest1, "arm-2"))
+							h.AssertNil(t, idx.SetVariant(digest1, "v6-2"))
+							h.AssertNil(t, idx.SaveDir())
+
+							index := h.ReadIndexManifest(t, localPath)
+							h.AssertEq(t, len(index.Manifests), 2)
+							h.AssertEq(t, index.Manifests[1].Digest.String(), "sha256:e18f2c12bb4ea582045415243370a3d9cf3874265aa2867f21a35e630ebe45a7")
+							h.AssertEq(t, index.Manifests[1].Platform.OS, "linux-2")
+							h.AssertEq(t, index.Manifests[1].Platform.Architecture, "arm-2")
+							h.AssertEq(t, index.Manifests[1].Platform.Variant, "v6-2")
+						})
+
+						it("new annotation are appended on disk", func() {
+							annotations := map[string]string{
+								"some-key": "some-value",
+							}
+							h.AssertNil(t, idx.SetAnnotations(digest1, annotations))
+							h.AssertNil(t, idx.SaveDir())
+
+							index := h.ReadIndexManifest(t, localPath)
+							h.AssertEq(t, len(index.Manifests), 2)
+
+							// When updating a digest, it will be appended at the end
+							h.AssertEq(t, index.Manifests[1].Digest.String(), "sha256:e18f2c12bb4ea582045415243370a3d9cf3874265aa2867f21a35e630ebe45a7")
+
+							// in testdata we have 7 annotations + 1 new
+							h.AssertEq(t, len(index.Manifests[1].Annotations), 8)
+							h.AssertEq(t, index.Manifests[1].Annotations["some-key"], "some-value")
+						})
+					})
+				})
+			})
+		})
+	})
+
 	when("#Save", func() {
 		when("index exists on disk", func() {
 			when("#FromBaseIndex", func() {
@@ -1348,7 +1455,7 @@ func testIndex(t *testing.T, when spec.G, it spec.S) {
 					h.AssertEq(t, len(index.Manifests), 1)
 				})
 
-				it.Focus("add more than one manifest to the index", func() {
+				it("add more than one manifest to the index", func() {
 					image1, err := random.Image(1024, 1)
 					h.AssertNil(t, err)
 					idx.AddManifest(image1)