diff --git a/Gopkg.lock b/Gopkg.lock index 62db1fba2..01659bbd0 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -1448,6 +1448,7 @@ "github.com/docker/cli/cli/context/kubernetes", "github.com/docker/cli/cli/context/store", "github.com/docker/cli/cli/flags", + "github.com/docker/cli/cli/streams", "github.com/docker/cli/opts", "github.com/docker/cli/templates", "github.com/docker/cnab-to-oci/relocation", @@ -1491,6 +1492,7 @@ "gotest.tools/icmd", "k8s.io/api/core/v1", "k8s.io/apimachinery/pkg/apis/meta/v1", + "k8s.io/apimachinery/pkg/util/wait", "k8s.io/client-go/kubernetes/typed/core/v1", ] solver-name = "gps-cdcl" diff --git a/internal/cnab/cnab.go b/internal/cnab/cnab.go index a9f71b89e..d382a6a4b 100644 --- a/internal/cnab/cnab.go +++ b/internal/cnab/cnab.go @@ -123,7 +123,7 @@ func PullBundle(dockerCli command.Cli, bundleStore appstore.BundleStore, tagRef return nil, err } relocatedBundle := &relocated.Bundle{Bundle: bndl, RelocationMap: relocationMap} - if _, err := bundleStore.Store(tagRef, relocatedBundle); err != nil { + if _, err := bundleStore.Store(relocatedBundle, tagRef); err != nil { return nil, err } return relocatedBundle, nil diff --git a/internal/commands/build/build.go b/internal/commands/build/build.go index c6fade7a6..43b9ebc53 100644 --- a/internal/commands/build/build.go +++ b/internal/commands/build/build.go @@ -133,13 +133,12 @@ func runBuild(dockerCli command.Cli, contextPath string, opt buildOptions) error return err } - var ref reference.Reference - ref, err = packager.GetNamedTagged(opt.tag) + ref, err := packager.GetNamedTagged(opt.tag) if err != nil { return err } - id, err := packager.PersistInBundleStore(ref, bundle) + id, err := packager.PersistInBundleStore(bundle, ref) if err != nil { return err } diff --git a/internal/commands/image/list.go b/internal/commands/image/list.go index 8fc479028..ed71dee1b 100644 --- a/internal/commands/image/list.go +++ b/internal/commands/image/list.go @@ -126,10 +126,7 @@ func getImageDesc(bundle *relocated.Bundle, ref reference.Reference) imageDesc { if t, ok := ref.(reference.Tagged); ok { tag = t.Tag() } - var digest string - if t, ok := ref.(reference.Digested); ok { - digest = t.Digest().String() - } + digest := bundle.RepoDigest var created time.Time if payload, err := packager.CustomPayload(bundle.Bundle); err == nil { if createdPayload, ok := payload.(packager.CustomPayloadCreated); ok { @@ -141,7 +138,7 @@ func getImageDesc(bundle *relocated.Bundle, ref reference.Reference) imageDesc { Name: bundle.Name, Repository: repository, Tag: tag, - Digest: digest, + Digest: digest.String(), Created: created, } } diff --git a/internal/commands/image/list_test.go b/internal/commands/image/list_test.go index 7c040f212..5af21d02c 100644 --- a/internal/commands/image/list_test.go +++ b/internal/commands/image/list_test.go @@ -3,59 +3,24 @@ package image import ( "bufio" "bytes" - "fmt" "testing" "time" - "github.com/docker/app/internal/relocated" - - "gotest.tools/assert" + "github.com/docker/app/internal/store" + "gotest.tools/fs" "github.com/deislabs/cnab-go/bundle" - "github.com/docker/app/internal/store" + "github.com/docker/app/internal/relocated" "github.com/docker/cli/cli/command" "github.com/docker/distribution/reference" + "gotest.tools/assert" ) -type bundleStoreStubForListCmd struct { - refMap map[reference.Reference]*relocated.Bundle - // in order to keep the reference in the same order between tests - refList []reference.Reference -} - -func (b *bundleStoreStubForListCmd) Store(ref reference.Reference, bndl *relocated.Bundle) (reference.Digested, error) { - b.refMap[ref] = bndl - b.refList = append(b.refList, ref) - return store.FromBundle(bndl) -} - -func (b *bundleStoreStubForListCmd) Read(ref reference.Reference) (*relocated.Bundle, error) { - bndl, ok := b.refMap[ref] - if ok { - return bndl, nil - } - return nil, fmt.Errorf("Bundle not found") -} - -func (b *bundleStoreStubForListCmd) List() ([]reference.Reference, error) { - return b.refList, nil -} - -func (b *bundleStoreStubForListCmd) Remove(ref reference.Reference, force bool) error { - return nil -} - -func (b *bundleStoreStubForListCmd) LookUp(refOrID string) (reference.Reference, error) { - return nil, nil -} - func TestListCmd(t *testing.T) { - ref, err := store.FromString("a855ac937f2ed375ba4396bbc49c4093e124da933acd2713fb9bc17d7562a087") - assert.NilError(t, err) - refs := []reference.Reference{ + refs := []reference.Named{ parseReference(t, "foo/bar@sha256:b59492bb814012ca3d2ce0b6728242d96b4af41687cc82166a4b5d7f2d9fb865"), parseReference(t, "foo/bar:1.0"), - ref, + nil, } bundles := []relocated.Bundle{ { @@ -85,18 +50,18 @@ func TestListCmd(t *testing.T) { { name: "TestList", expectedOutput: `REPOSITORY TAG APP IMAGE ID APP NAME CREATED -foo/bar 3f825b2d0657 Digested App N/A + ad2828ea5653 Quiet App N/A foo/bar 1.0 9aae408ee04f Foo App N/A - a855ac937f2e Quiet App N/A +foo/bar 3f825b2d0657 Digested App N/A `, options: imageListOption{format: "table"}, }, { name: "TestTemplate", expectedOutput: `APP IMAGE ID DIGEST -3f825b2d0657 sha256:b59492bb814012ca3d2ce0b6728242d96b4af41687cc82166a4b5d7f2d9fb865 +ad2828ea5653 9aae408ee04f -a855ac937f2e sha256:a855ac937f2ed375ba4396bbc49c4093e124da933acd2713fb9bc17d7562a087 +3f825b2d0657 sha256:b59492bb814012ca3d2ce0b6728242d96b4af41687cc82166a4b5d7f2d9fb865 `, options: imageListOption{format: "table {{.ID}}", digests: true}, }, @@ -104,17 +69,17 @@ a855ac937f2e sha256:a855ac937f2ed375ba4396bbc49c4093e124da933acd2713fb9bc name: "TestListWithDigests", //nolint:lll expectedOutput: `REPOSITORY TAG DIGEST APP IMAGE ID APP NAME CREATED -foo/bar sha256:b59492bb814012ca3d2ce0b6728242d96b4af41687cc82166a4b5d7f2d9fb865 3f825b2d0657 Digested App N/A + ad2828ea5653 Quiet App N/A foo/bar 1.0 9aae408ee04f Foo App N/A - sha256:a855ac937f2ed375ba4396bbc49c4093e124da933acd2713fb9bc17d7562a087 a855ac937f2e Quiet App N/A +foo/bar sha256:b59492bb814012ca3d2ce0b6728242d96b4af41687cc82166a4b5d7f2d9fb865 3f825b2d0657 Digested App N/A `, options: imageListOption{format: "table", digests: true}, }, { name: "TestListWithQuiet", - expectedOutput: `3f825b2d0657 + expectedOutput: `ad2828ea5653 9aae408ee04f -a855ac937f2e +3f825b2d0657 `, options: imageListOption{format: "table", quiet: true}, }, @@ -143,27 +108,26 @@ func TestSortImages(t *testing.T) { assert.Equal(t, "3", images[4].ID) } -func parseReference(t *testing.T, s string) reference.Reference { - ref, err := reference.Parse(s) +func parseReference(t *testing.T, s string) reference.Named { + ref, err := reference.ParseNormalizedNamed(s) assert.NilError(t, err) return ref } -func testRunList(t *testing.T, refs []reference.Reference, bundles []relocated.Bundle, options imageListOption, expectedOutput string) { +func testRunList(t *testing.T, refs []reference.Named, bundles []relocated.Bundle, options imageListOption, expectedOutput string) { var buf bytes.Buffer w := bufio.NewWriter(&buf) dockerCli, err := command.NewDockerCli(command.WithOutputStream(w)) assert.NilError(t, err) - bundleStore := &bundleStoreStubForListCmd{ - refMap: make(map[reference.Reference]*relocated.Bundle), - refList: []reference.Reference{}, - } + bundleStore, err := store.NewBundleStore(fs.NewDir(t, "store").Path()) + assert.NilError(t, err) for i, ref := range refs { - _, err = bundleStore.Store(ref, &bundles[i]) + _, err = bundleStore.Store(&bundles[i], ref) assert.NilError(t, err) } err = runList(dockerCli, options, bundleStore) assert.NilError(t, err) w.Flush() - assert.Equal(t, buf.String(), expectedOutput) + actualOutput := buf.String() + assert.Equal(t, actualOutput, expectedOutput) } diff --git a/internal/commands/image/tag.go b/internal/commands/image/tag.go index 917787f27..b8414da43 100644 --- a/internal/commands/image/tag.go +++ b/internal/commands/image/tag.go @@ -45,7 +45,7 @@ func runTag(bundleStore store.BundleStore, srcAppImage, destAppImage string) err if err != nil { return err } - + srcRef.RepoDigest = "" return storeBundle(srcRef, destAppImage, bundleStore) } @@ -73,6 +73,6 @@ func storeBundle(bundle *relocated.Bundle, name string, bundleStore store.Bundle if err != nil { return err } - _, err = bundleStore.Store(cnabRef, bundle) + _, err = bundleStore.Store(bundle, cnabRef) return err } diff --git a/internal/commands/image/tag_test.go b/internal/commands/image/tag_test.go index 0b76ccd76..a914cfac3 100644 --- a/internal/commands/image/tag_test.go +++ b/internal/commands/image/tag_test.go @@ -4,6 +4,8 @@ import ( "fmt" "testing" + "github.com/docker/app/internal/store" + "github.com/docker/app/internal/relocated" "gotest.tools/assert" @@ -23,12 +25,12 @@ type bundleStoreStub struct { ReadError error StoredBundle string StoredError error - StoredID reference.Digested + StoredID store.ID LookUpRef reference.Reference LookUpError error } -func (b *bundleStoreStub) Store(ref reference.Reference, bndle *relocated.Bundle) (reference.Digested, error) { +func (b *bundleStoreStub) Store(bndl *relocated.Bundle, ref reference.Named) (store.ID, error) { defer func() { b.StoredError = nil }() diff --git a/internal/commands/push.go b/internal/commands/push.go index 32f5ee698..8cfcf9ae1 100644 --- a/internal/commands/push.go +++ b/internal/commands/push.go @@ -8,6 +8,8 @@ import ( "os" "strings" + "github.com/opencontainers/go-digest" + "github.com/docker/app/internal/relocated" "github.com/docker/app/internal/store" @@ -69,10 +71,20 @@ func runPush(dockerCli command.Cli, name string) error { return err } - cnabRef := reference.TagNameOnly(ref) - // Push the bundle - return pushBundle(dockerCli, bndl, cnabRef) + dg, err := pushBundle(dockerCli, bndl, ref) + if err != nil { + return errors.Wrapf(err, "could not push %q", ref) + } + + // we can't just re-use bndl var here, as fixup did rewrite the bundle + bndl, err = resolveReferenceAndBundle(bundleStore, ref) + if err != nil { + return err + } + bndl.RepoDigest = dg + _, err = bundleStore.Store(bndl, ref) + return err } func resolveReferenceAndBundle(bundleStore store.BundleStore, ref reference.Reference) (*relocated.Bundle, error) { @@ -88,10 +100,10 @@ func resolveReferenceAndBundle(bundleStore store.BundleStore, ref reference.Refe return bndl, err } -func pushBundle(dockerCli command.Cli, bndl *relocated.Bundle, cnabRef reference.Named) error { +func pushBundle(dockerCli command.Cli, bndl *relocated.Bundle, cnabRef reference.Named) (digest.Digest, error) { insecureRegistries, err := internal.InsecureRegistriesFromEngine(dockerCli) if err != nil { - return errors.Wrap(err, "could not retrieve insecure registries") + return "", errors.Wrap(err, "could not retrieve insecure registries") } resolver := remotes.CreateResolver(dockerCli.ConfigFile(), insecureRegistries...) var display fixupDisplay = &plainDisplay{out: os.Stdout} @@ -107,17 +119,17 @@ func pushBundle(dockerCli command.Cli, bndl *relocated.Bundle, cnabRef reference // bundle fixup relocationMap, err := remotes.FixupBundle(context.Background(), bndl.Bundle, cnabRef, resolver, fixupOptions...) if err != nil { - return errors.Wrapf(err, "fixing up %q for push", cnabRef) + return "", errors.Wrapf(err, "fixing up %q for push", cnabRef) } bndl.RelocationMap = relocationMap // push bundle manifest logrus.Debugf("Pushing the bundle %q", cnabRef) descriptor, err := remotes.Push(log.WithLogContext(context.Background()), bndl.Bundle, bndl.RelocationMap, cnabRef, resolver, true, withAppAnnotations) if err != nil { - return errors.Wrapf(err, "pushing to %q", cnabRef) + return "", errors.Wrapf(err, "pushing to %q", cnabRef) } fmt.Fprintf(os.Stdout, "Successfully pushed bundle to %s. Digest is %s.\n", cnabRef, descriptor.Digest) - return nil + return descriptor.Digest, nil } func withAppAnnotations(index *ocischemav1.Index) error { diff --git a/internal/packager/bundle.go b/internal/packager/bundle.go index fd0158b77..c3fdbe878 100644 --- a/internal/packager/bundle.go +++ b/internal/packager/bundle.go @@ -73,16 +73,16 @@ func MakeCNABImageName(appName, appVersion, suffix string) (string, error) { } // PersistInBundleStore do store a bundle with optional reference and return it's ID -func PersistInBundleStore(ref reference.Reference, bndl *bundle.Bundle) (reference.Digested, error) { +func PersistInBundleStore(bndl *bundle.Bundle, ref reference.Named) (store.ID, error) { appstore, err := store.NewApplicationStore(config.Dir()) if err != nil { - return nil, err + return "", err } bundleStore, err := appstore.BundleStore() if err != nil { - return nil, err + return "", err } - return bundleStore.Store(ref, relocated.FromBundle(bndl)) + return bundleStore.Store(relocated.FromBundle(bndl), ref) } func GetNamedTagged(tag string) (reference.NamedTagged, error) { diff --git a/internal/relocated/bundle.go b/internal/relocated/bundle.go index 9a660f4d4..6d5c2997f 100644 --- a/internal/relocated/bundle.go +++ b/internal/relocated/bundle.go @@ -5,6 +5,8 @@ import ( "os" "path/filepath" + "github.com/opencontainers/go-digest" + "github.com/pkg/errors" "github.com/deislabs/cnab-go/bundle" @@ -15,11 +17,13 @@ import ( type Bundle struct { *bundle.Bundle RelocationMap relocation.ImageRelocationMap + RepoDigest digest.Digest } const ( BundleFilename = "bundle.json" RelocationMapFilename = "relocation-map.json" + DigestFilename = "digest" ) // FromBundle returns a RelocatedBundle with an empty relocation map. @@ -43,9 +47,16 @@ func BundleFromFile(filename string) (*Bundle, error) { return nil, errors.Wrapf(err, "failed to read relocation map") } + digestFileName := filepath.Join(filepath.Dir(filename), DigestFilename) + dg, err := repoDigest(digestFileName) + if err != nil { + return nil, errors.Wrapf(err, "failed to read digest file") + } + return &Bundle{ Bundle: bndl, RelocationMap: relocationMap, + RepoDigest: dg, }, nil } @@ -58,6 +69,21 @@ func (b *Bundle) writeRelocationMap(dest string, mode os.FileMode) error { return ioutil.WriteFile(dest, d, mode) } +// writeRepoDigest store the repo digest to a file as plain text. +func (b *Bundle) writeRepoDigest(dest string, mode os.FileMode) error { + if b.RepoDigest == "" { + return cleanRepoDigest(dest) + } + return ioutil.WriteFile(dest, []byte(b.RepoDigest), mode) +} + +func cleanRepoDigest(dest string) error { + if _, err := os.Stat(dest); os.IsNotExist(err) { + return nil + } + return os.Remove(dest) +} + // Store a bundle with the relocation map as json files. func (b *Bundle) Store(dir string) error { // store bundle.json @@ -72,6 +98,12 @@ func (b *Bundle) Store(dir string) error { return errors.Wrapf(err, "failed to store relocation map") } + // store repo digest + repoDigestPath := filepath.Join(dir, DigestFilename) + if err := b.writeRepoDigest(repoDigestPath, 0644); err != nil { + return errors.Wrapf(err, "failed to store digest") + } + return nil } @@ -115,3 +147,15 @@ func (b *Bundle) RelocatedImages() map[string]bundle.Image { return images } + +func repoDigest(digestFileName string) (digest.Digest, error) { + _, err := os.Stat(digestFileName) + if os.IsNotExist(err) { + return "", nil + } + bytes, err := ioutil.ReadFile(digestFileName) + if err != nil { + return "", err + } + return digest.Parse(string(bytes)) +} diff --git a/internal/store/bundle.go b/internal/store/bundle.go index e9d17df85..9af37152d 100644 --- a/internal/store/bundle.go +++ b/internal/store/bundle.go @@ -18,7 +18,7 @@ import ( // type BundleStore interface { // Store do store the bundle with optional reference, and return it's unique ID - Store(ref reference.Reference, bndl *relocated.Bundle) (reference.Digested, error) + Store(bndl *relocated.Bundle, ref reference.Named) (ID, error) Read(ref reference.Reference) (*relocated.Bundle, error) List() ([]reference.Reference, error) Remove(ref reference.Reference, force bool) error @@ -63,27 +63,44 @@ func NewBundleStore(path string) (BundleStore, error) { // \_ bundle.json // -func (b *bundleStore) Store(ref reference.Reference, bndl *relocated.Bundle) (reference.Digested, error) { +func (b *bundleStore) Store(bndl *relocated.Bundle, name reference.Named) (ID, error) { id, err := FromBundle(bndl) if err != nil { - return nil, errors.Wrapf(err, "failed to store bundle %q", ref) + return "", errors.Wrapf(err, "failed to store bundle %q", name) } - if ref == nil { - ref = id + var r reference.Reference = id + if name != nil { + r = name + if dg, ok := name.(reference.Digested); ok { + bndl.RepoDigest = dg.Digest() + } } - dir, err := b.storePath(ref) + dir, err := b.storePath(r) if err != nil { - return id, errors.Wrapf(err, "failed to store bundle %q", ref) + return id, errors.Wrapf(err, "failed to store bundle %q", name) } if err := os.MkdirAll(dir, 0755); err != nil { - return id, errors.Wrapf(err, "failed to store bundle %q", ref) + return id, errors.Wrapf(err, "failed to store bundle %q", name) } if err := bndl.Store(dir); err != nil { - return id, errors.Wrapf(err, "failed to store relocated bundle %q", ref) + return id, errors.Wrapf(err, "failed to store bundle %q", name) + } + + if r != id { + // Check bundle was previously stored by ID, then cleanup + path, err := b.storePath(id) + if err != nil { + return id, errors.Wrapf(err, "failed to store bundle %q", name) + } + if _, err := os.Stat(path); err == nil { + if err := os.RemoveAll(path); err != nil { + return id, errors.Wrapf(err, "failed to store bundle %q", name) + } + } } - b.refsMap.appendRef(id, ref) + b.refsMap.appendRef(id, r) return id, nil } @@ -227,7 +244,7 @@ func (b *bundleStore) referenceToID(ref reference.Reference) (ID, error) { } } } - return ID{}, unknownReference(reference.FamiliarString(ref)) + return "", unknownReference(reference.FamiliarString(ref)) } func (b *bundleStore) storePaths(ref reference.Reference) ([]string, error) { @@ -316,7 +333,7 @@ func (b *bundleStore) processBundleStoreFile(path string, info os.FileInfo, err if strings.HasPrefix(path, idRefPath) { rel := path[len(idRefPath)+1:] dg := strings.Split(filepath.ToSlash(rel), "/")[0] - id := ID{digest.NewDigestFromEncoded(digest.SHA256, dg)} + id := ID(digest.NewDigestFromEncoded(digest.SHA256, dg)) b.refsMap.appendRef(id, id) return nil } diff --git a/internal/store/bundle_test.go b/internal/store/bundle_test.go index c12b4e19f..303e7a994 100644 --- a/internal/store/bundle_test.go +++ b/internal/store/bundle_test.go @@ -50,7 +50,7 @@ func TestStoreAndReadBundle(t *testing.T) { for _, testcase := range testcases { t.Run(testcase.name, func(t *testing.T) { // Store the bundle - _, err = bundleStore.Store(testcase.ref, expectedBundle) + _, err = bundleStore.Store(expectedBundle, testcase.ref) assert.NilError(t, err) // Check the file exists @@ -60,7 +60,7 @@ func TestStoreAndReadBundle(t *testing.T) { // Load it actualBundle, err := bundleStore.Read(testcase.ref) assert.NilError(t, err) - assert.DeepEqual(t, expectedBundle, actualBundle) + assert.DeepEqual(t, expectedBundle.Bundle, actualBundle.Bundle) }) } } @@ -226,7 +226,7 @@ func TestList(t *testing.T) { bndl := relocated.FromBundle(&bundle.Bundle{Name: "bundle-name"}) for _, ref := range refs { - _, err = bundleStore.Store(ref, bndl) + _, err = bundleStore.Store(bndl, ref) assert.NilError(t, err) } @@ -264,7 +264,7 @@ func TestRemove(t *testing.T) { bndl := relocated.FromBundle(&bundle.Bundle{Name: "bundle-name"}) for _, ref := range refs { - _, err = bundleStore.Store(ref, bndl) + _, err = bundleStore.Store(bndl, ref) assert.NilError(t, err) } @@ -315,9 +315,9 @@ func TestRemoveById(t *testing.T) { bndl := relocated.FromBundle(&bundle.Bundle{Name: "bundle-name"}) idRef, err := FromBundle(bndl) assert.NilError(t, err) - _, err = bundleStore.Store(idRef, bndl) + _, err = bundleStore.Store(bndl, parseRefOrDie(t, "my-repo/a-bundle:my-tag")) assert.NilError(t, err) - _, err = bundleStore.Store(parseRefOrDie(t, "my-repo/a-bundle:my-tag"), bndl) + _, err = bundleStore.Store(bndl, parseRefOrDie(t, "my-repo/b-bundle:my-tag")) assert.NilError(t, err) err = bundleStore.Remove(idRef, false) @@ -328,9 +328,9 @@ func TestRemoveById(t *testing.T) { bndl := relocated.FromBundle(&bundle.Bundle{Name: "bundle-name"}) idRef, err := FromBundle(bndl) assert.NilError(t, err) - _, err = bundleStore.Store(idRef, bndl) + _, err = bundleStore.Store(bndl, parseRefOrDie(t, "my-repo/a-bundle:my-tag")) assert.NilError(t, err) - _, err = bundleStore.Store(parseRefOrDie(t, "my-repo/a-bundle:my-tag"), bndl) + _, err = bundleStore.Store(bndl, parseRefOrDie(t, "my-repo/b-bundle:my-tag")) assert.NilError(t, err) err = bundleStore.Remove(idRef, true) @@ -340,7 +340,7 @@ func TestRemoveById(t *testing.T) { t.Run("success when only one reference exists", func(t *testing.T) { bndl := relocated.FromBundle(&bundle.Bundle{Name: "other-bundle-name"}) ref := parseRefOrDie(t, "my-repo/other-bundle:my-tag") - _, err = bundleStore.Store(ref, bndl) + _, err = bundleStore.Store(bndl, ref) idRef, err := FromBundle(bndl) assert.NilError(t, err) @@ -363,15 +363,15 @@ func TestLookUp(t *testing.T) { assert.NilError(t, err) bndl := relocated.FromBundle(&bundle.Bundle{Name: "bundle-name"}) // Adding the bundle referenced by id - id, err := bundleStore.Store(nil, bndl) + id, err := bundleStore.Store(bndl, nil) assert.NilError(t, err) // Adding the same bundle referenced by a tag ref := parseRefOrDie(t, "my-repo/a-bundle:my-tag") - _, err = bundleStore.Store(ref, bndl) + _, err = bundleStore.Store(bndl, ref) assert.NilError(t, err) // Adding the same bundle referenced by tag prefixed by docker.io/library dockerIoRef := parseRefOrDie(t, "docker.io/library/a-bundle:my-tag") - _, err = bundleStore.Store(dockerIoRef, bndl) + _, err = bundleStore.Store(bndl, dockerIoRef) assert.NilError(t, err) for _, tc := range []struct { diff --git a/internal/store/digest.go b/internal/store/digest.go index 13f445542..09d1c6a62 100644 --- a/internal/store/digest.go +++ b/internal/store/digest.go @@ -44,28 +44,24 @@ func StringToNamedRef(s string) (reference.Named, error) { func FromString(s string) (ID, error) { if ok := identifierRegexp.MatchString(s); !ok { - return ID{}, fmt.Errorf("could not parse %q as a valid reference", s) + return "", fmt.Errorf("could not parse %q as a valid reference", s) } digest := digest.NewDigestFromEncoded(digest.SHA256, s) - return ID{digest}, nil + return ID(digest), nil } func FromBundle(bndl *relocated.Bundle) (ID, error) { - digest, err := ComputeDigest(bndl) - return ID{digest}, err + digest, err := ComputeDigest(bndl.Bundle) + return ID(digest), err } // ID is an unique identifier for docker app image bundle, implementing reference.Reference -type ID struct { - digest digest.Digest -} - -var _ reference.Reference = ID{} +type ID digest.Digest func (id ID) String() string { - return id.digest.Encoded() + return id.Digest().Encoded() } func (id ID) Digest() digest.Digest { - return id.digest + return digest.Digest(id) } diff --git a/internal/store/digest_test.go b/internal/store/digest_test.go index e790e90dd..38f67e498 100644 --- a/internal/store/digest_test.go +++ b/internal/store/digest_test.go @@ -22,13 +22,13 @@ func Test_storeByDigest(t *testing.T) { bndl := relocated.FromBundle(&bundle.Bundle{Name: "bundle-name"}) ref := parseRefOrDie(t, "test/simple:1.0") - _, err = bundleStore.Store(ref, bndl) + _, err = bundleStore.Store(bndl, ref) assert.NilError(t, err) _, err = os.Stat(dockerConfigDir.Join("app", "bundles", "docker.io", "test", "simple", "_tags", "1.0", relocated.BundleFilename)) assert.NilError(t, err) - _, err = bundleStore.Store(nil, bndl) + _, err = bundleStore.Store(bndl, nil) assert.NilError(t, err) ids := dockerConfigDir.Join("app", "bundles", "_ids")