added Resolve

Signed-off-by: Xiaoxuan Wang <[email protected]>

Author: wangxiaoxuan273

content/oci/deletableOci.go

@@ -20,6 +20,7 @@ package oci
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -30,6 +31,7 @@ import (
 	specs "github.com/opencontainers/image-spec/specs-go"
 	ocispec "github.com/opencontainers/image-spec/specs-go/v1"
 	"oras.land/oras-go/v2/content"
+	"oras.land/oras-go/v2/errdef"
 	"oras.land/oras-go/v2/internal/container/set"
 	"oras.land/oras-go/v2/internal/descriptor"
 	"oras.land/oras-go/v2/internal/graph"
@@ -98,86 +100,115 @@ func NewDeletableStoreWithContext(ctx context.Context, root string) (*DeletableS
 }
 
 // Fetch fetches the content identified by the descriptor.
-func (s *DeletableStore) Fetch(ctx context.Context, target ocispec.Descriptor) (io.ReadCloser, error) {
-	s.operationLock.RLock()
-	defer s.operationLock.RUnlock()
-	return s.storage.Fetch(ctx, target)
+func (ds *DeletableStore) Fetch(ctx context.Context, target ocispec.Descriptor) (io.ReadCloser, error) {
+	ds.operationLock.RLock()
+	defer ds.operationLock.RUnlock()
+	return ds.storage.Fetch(ctx, target)
 }
 
 // Push pushes the content, matching the expected descriptor.
-func (s *DeletableStore) Push(ctx context.Context, expected ocispec.Descriptor, reader io.Reader) error {
-	s.operationLock.Lock()
-	defer s.operationLock.Unlock()
-	if err := s.storage.Push(ctx, expected, reader); err != nil {
+func (ds *DeletableStore) Push(ctx context.Context, expected ocispec.Descriptor, reader io.Reader) error {
+	ds.operationLock.Lock()
+	defer ds.operationLock.Unlock()
+	if err := ds.storage.Push(ctx, expected, reader); err != nil {
 		return err
 	}
-	if err := s.graph.Index(ctx, s.storage, expected); err != nil {
+	if err := ds.graph.Index(ctx, ds.storage, expected); err != nil {
 		return err
 	}
 	if descriptor.IsManifest(expected) {
 		// tag by digest
-		return s.tag(ctx, expected, expected.Digest.String())
+		return ds.tag(ctx, expected, expected.Digest.String())
 	}
 	return nil
 }
 
 // Delete removes the content matching the descriptor from the store.
-func (s *DeletableStore) Delete(ctx context.Context, target ocispec.Descriptor) error {
-	s.operationLock.Lock()
-	defer s.operationLock.Unlock()
-	resolvers := s.tagResolver.Map()
+func (ds *DeletableStore) Delete(ctx context.Context, target ocispec.Descriptor) error {
+	ds.operationLock.Lock()
+	defer ds.operationLock.Unlock()
+	resolvers := ds.tagResolver.Map()
 	for reference, desc := range resolvers {
 		if content.Equal(desc, target) {
-			s.tagResolver.Delete(reference)
+			ds.tagResolver.Delete(reference)
 		}
 	}
-	if err := s.graph.RemoveFromIndex(ctx, target); err != nil {
+	if err := ds.graph.RemoveFromIndex(ctx, target); err != nil {
 		return err
 	}
-	if s.AutoSaveIndex {
-		err := s.SaveIndex()
+	if ds.AutoSaveIndex {
+		err := ds.SaveIndex()
 		if err != nil {
 			return err
 		}
 	}
-	return s.storage.Delete(ctx, target)
+	return ds.storage.Delete(ctx, target)
 }
 
 // Exists returns true if the described content exists.
-func (s *DeletableStore) Exists(ctx context.Context, target ocispec.Descriptor) (bool, error) {
-	s.operationLock.RLock()
-	defer s.operationLock.RUnlock()
-	return s.storage.Exists(ctx, target)
+func (ds *DeletableStore) Exists(ctx context.Context, target ocispec.Descriptor) (bool, error) {
+	ds.operationLock.RLock()
+	defer ds.operationLock.RUnlock()
+	return ds.storage.Exists(ctx, target)
 }
 
 // tag tags a descriptor with a reference string.
-func (s *DeletableStore) tag(ctx context.Context, desc ocispec.Descriptor, reference string) error {
+func (ds *DeletableStore) tag(ctx context.Context, desc ocispec.Descriptor, reference string) error {
 	dgst := desc.Digest.String()
 	if reference != dgst {
 		// also tag desc by its digest
-		if err := s.tagResolver.Tag(ctx, desc, dgst); err != nil {
+		if err := ds.tagResolver.Tag(ctx, desc, dgst); err != nil {
 			return err
 		}
 	}
-	if err := s.tagResolver.Tag(ctx, desc, reference); err != nil {
+	if err := ds.tagResolver.Tag(ctx, desc, reference); err != nil {
 		return err
 	}
-	if s.AutoSaveIndex {
-		return s.SaveIndex()
+	if ds.AutoSaveIndex {
+		return ds.SaveIndex()
 	}
 	return nil
 }
 
+// Resolve resolves a reference to a descriptor. If the reference to be resolved
+// is a tag, the returned descriptor will be a full descriptor declared by
+// github.com/opencontainers/image-spec/specs-go/v1. If the reference is a
+// digest the returned descriptor will be a plain descriptor (containing only
+// the digest, media type and size).
+func (ds *DeletableStore) Resolve(ctx context.Context, reference string) (ocispec.Descriptor, error) {
+	ds.operationLock.RLock()
+	defer ds.operationLock.RUnlock()
+	if reference == "" {
+		return ocispec.Descriptor{}, errdef.ErrMissingReference
+	}
+
+	// attempt resolving manifest
+	desc, err := ds.tagResolver.Resolve(ctx, reference)
+	if err != nil {
+		if errors.Is(err, errdef.ErrNotFound) {
+			// attempt resolving blob
+			return resolveBlob(os.DirFS(ds.root), reference)
+		}
+		return ocispec.Descriptor{}, err
+	}
+
+	if reference == desc.Digest.String() {
+		return descriptor.Plain(desc), nil
+	}
+
+	return desc, nil
+}
+
 // Predecessors returns the nodes directly pointing to the current node.
 // Predecessors returns nil without error if the node does not exists in the
 // store.
-func (s *DeletableStore) Predecessors(ctx context.Context, node ocispec.Descriptor) ([]ocispec.Descriptor, error) {
-	return s.graph.Predecessors(ctx, node)
+func (ds *DeletableStore) Predecessors(ctx context.Context, node ocispec.Descriptor) ([]ocispec.Descriptor, error) {
+	return ds.graph.Predecessors(ctx, node)
 }
 
 // ensureOCILayoutFile ensures the `oci-layout` file.
-func (s *DeletableStore) ensureOCILayoutFile() error {
-	layoutFilePath := filepath.Join(s.root, ocispec.ImageLayoutFile)
+func (ds *DeletableStore) ensureOCILayoutFile() error {
+	layoutFilePath := filepath.Join(ds.root, ocispec.ImageLayoutFile)
 	layoutFile, err := os.Open(layoutFilePath)
 	if err != nil {
 		if !os.IsNotExist(err) {
@@ -205,44 +236,44 @@ func (s *DeletableStore) ensureOCILayoutFile() error {
 
 // loadIndexFile reads index.json from the file system.
 // Create index.json if it does not exist.
-func (s *DeletableStore) loadIndexFile(ctx context.Context) error {
-	indexFile, err := os.Open(s.indexPath)
+func (ds *DeletableStore) loadIndexFile(ctx context.Context) error {
+	indexFile, err := os.Open(ds.indexPath)
 	if err != nil {
 		if !os.IsNotExist(err) {
 			return fmt.Errorf("failed to open index file: %w", err)
 		}
 
 		// write index.json if it does not exist
-		s.index = &ocispec.Index{
+		ds.index = &ocispec.Index{
 			Versioned: specs.Versioned{
 				SchemaVersion: 2, // historical value
 			},
 			Manifests: []ocispec.Descriptor{},
 		}
-		return s.writeIndexFile()
+		return ds.writeIndexFile()
 	}
 	defer indexFile.Close()
 
 	var index ocispec.Index
 	if err := json.NewDecoder(indexFile).Decode(&index); err != nil {
 		return fmt.Errorf("failed to decode index file: %w", err)
 	}
-	s.index = &index
-	return loadIndex(ctx, s.index, s.storage, s.tagResolver, s.graph)
+	ds.index = &index
+	return loadIndex(ctx, ds.index, ds.storage, ds.tagResolver, ds.graph)
 }
 
 // SaveIndex writes the `index.json` file to the file system.
 //   - If AutoSaveIndex is set to true (default value),
 //     the OCI store will automatically call this method on each Tag() call.
 //   - If AutoSaveIndex is set to false, it's the caller's responsibility
 //     to manually call this method when needed.
-func (s *DeletableStore) SaveIndex() error {
-	s.indexLock.Lock()
-	defer s.indexLock.Unlock()
+func (ds *DeletableStore) SaveIndex() error {
+	ds.indexLock.Lock()
+	defer ds.indexLock.Unlock()
 
 	var manifests []ocispec.Descriptor
 	tagged := set.New[digest.Digest]()
-	refMap := s.tagResolver.Map()
+	refMap := ds.tagResolver.Map()
 
 	// 1. Add descriptors that are associated with tags
 	// Note: One descriptor can be associated with multiple tags.
@@ -267,15 +298,15 @@ func (s *DeletableStore) SaveIndex() error {
 		}
 	}
 
-	s.index.Manifests = manifests
-	return s.writeIndexFile()
+	ds.index.Manifests = manifests
+	return ds.writeIndexFile()
 }
 
 // writeIndexFile writes the `index.json` file.
-func (s *DeletableStore) writeIndexFile() error {
-	indexJSON, err := json.Marshal(s.index)
+func (ds *DeletableStore) writeIndexFile() error {
+	indexJSON, err := json.Marshal(ds.index)
 	if err != nil {
 		return fmt.Errorf("failed to marshal index file: %w", err)
 	}
-	return os.WriteFile(s.indexPath, indexJSON, 0666)
+	return os.WriteFile(ds.indexPath, indexJSON, 0666)
 }

content/oci/deletableOci_test.go

@@ -20,19 +20,21 @@ package oci
 import (
 	"bytes"
 	"context"
+	"reflect"
 	"testing"
 
 	"github.com/opencontainers/go-digest"
 	ocispec "github.com/opencontainers/image-spec/specs-go/v1"
 )
 
-func TestDeletableStore_Delete(t *testing.T) {
+func TestDeletableStore(t *testing.T) {
 	content := []byte("test delete")
 	desc := ocispec.Descriptor{
 		MediaType: "test-delete",
 		Digest:    digest.FromBytes(content),
 		Size:      int64(len(content)),
 	}
+	ref := "latest"
 
 	tempDir := t.TempDir()
 	s, err := NewDeletableStore(tempDir)
@@ -54,6 +56,20 @@ func TestDeletableStore_Delete(t *testing.T) {
 		t.Errorf("Store.Exists() = %v, want %v", exists, true)
 	}
 
+	err = s.tag(ctx, desc, ref)
+	if err != nil {
+		t.Errorf("error tagging descriptor error = %v, wantErr %v", err, false)
+	}
+
+	resolvedDescr, err := s.Resolve(ctx, ref)
+	if err != nil {
+		t.Errorf("error resolving descriptor error = %v, wantErr %v", err, false)
+	}
+
+	if !reflect.DeepEqual(resolvedDescr, desc) {
+		t.Errorf("Store.Resolve() = %v, want %v", resolvedDescr, desc)
+	}
+
 	err = s.Delete(ctx, desc)
 	if err != nil {
 		t.Errorf("Store.Delete() = %v, wantErr %v", err, true)