feat(sync,s3): added s3 logic for ORAS and OCI artifacts (#985)

added sync logic for OCI artifacts

Signed-off-by: Petu Eusebiu <peusebiu@cisco.com>

pkg/storage/common.go

@@ -2,11 +2,16 @@ package storage
 
 import (
 	"encoding/json"
+	"errors"
+	"os"
 	"path"
 	"strings"
+	"time"
 
+	"github.com/docker/distribution/registry/storage/driver"
 	"github.com/notaryproject/notation-go"
 	godigest "github.com/opencontainers/go-digest"
+	imeta "github.com/opencontainers/image-spec/specs-go"
 	ispec "github.com/opencontainers/image-spec/specs-go/v1"
 	oras "github.com/oras-project/artifacts-spec/specs-go/v1"
 	"github.com/rs/zerolog"
@@ -446,6 +451,204 @@ func ApplyLinter(imgStore ImageStore, linter Lint, repo string, manifestDesc isp
 	return pass, nil
 }
 
+func GetOrasReferrers(imgStore ImageStore, repo string, gdigest godigest.Digest, artifactType string,
+	log zerolog.Logger,
+) ([]oras.Descriptor, error) {
+	var lockLatency time.Time
+
+	if err := gdigest.Validate(); err != nil {
+		return nil, err
+	}
+
+	dir := path.Join(imgStore.RootDir(), repo)
+	if !imgStore.DirExists(dir) {
+		return nil, zerr.ErrRepoNotFound
+	}
+
+	index, err := GetIndex(imgStore, repo, log)
+	if err != nil {
+		return nil, err
+	}
+
+	imgStore.RLock(&lockLatency)
+	defer imgStore.RUnlock(&lockLatency)
+
+	found := false
+
+	result := []oras.Descriptor{}
+
+	for _, manifest := range index.Manifests {
+		if manifest.MediaType != oras.MediaTypeArtifactManifest {
+			continue
+		}
+
+		imgStore.RUnlock(&lockLatency)
+		buf, err := imgStore.GetBlobContent(repo, manifest.Digest)
+		imgStore.RLock(&lockLatency)
+
+		if err != nil {
+			log.Error().Err(err).Str("blob", imgStore.BlobPath(repo, manifest.Digest)).Msg("failed to read manifest")
+
+			if os.IsNotExist(err) || errors.Is(err, driver.PathNotFoundError{}) {
+				return nil, zerr.ErrManifestNotFound
+			}
+
+			return nil, err
+		}
+
+		var artManifest oras.Manifest
+		if err := json.Unmarshal(buf, &artManifest); err != nil {
+			log.Error().Err(err).Str("dir", dir).Msg("invalid JSON")
+
+			return nil, err
+		}
+
+		if artManifest.Subject.Digest != gdigest {
+			continue
+		}
+
+		// filter by artifact type
+		if artifactType != "" && artManifest.ArtifactType != artifactType {
+			continue
+		}
+
+		result = append(result, oras.Descriptor{
+			MediaType:    manifest.MediaType,
+			ArtifactType: artManifest.ArtifactType,
+			Digest:       manifest.Digest,
+			Size:         manifest.Size,
+			Annotations:  manifest.Annotations,
+		})
+
+		found = true
+	}
+
+	if !found {
+		return nil, zerr.ErrManifestNotFound
+	}
+
+	return result, nil
+}
+
+func GetReferrers(imgStore ImageStore, repo string, gdigest godigest.Digest, artifactType string,
+	log zerolog.Logger,
+) (ispec.Index, error) {
+	var lockLatency time.Time
+
+	nilIndex := ispec.Index{}
+
+	if err := gdigest.Validate(); err != nil {
+		return nilIndex, err
+	}
+
+	dir := path.Join(imgStore.RootDir(), repo)
+	if !imgStore.DirExists(dir) {
+		return nilIndex, zerr.ErrRepoNotFound
+	}
+
+	index, err := GetIndex(imgStore, repo, log)
+	if err != nil {
+		return nilIndex, err
+	}
+
+	imgStore.RLock(&lockLatency)
+	defer imgStore.RUnlock(&lockLatency)
+
+	found := false
+
+	result := []ispec.Descriptor{}
+
+	for _, manifest := range index.Manifests {
+		if manifest.Digest == gdigest {
+			continue
+		}
+
+		imgStore.RUnlock(&lockLatency)
+		buf, err := imgStore.GetBlobContent(repo, manifest.Digest)
+		imgStore.RLock(&lockLatency)
+
+		if err != nil {
+			log.Error().Err(err).Str("blob", imgStore.BlobPath(repo, manifest.Digest)).Msg("failed to read manifest")
+
+			if os.IsNotExist(err) || errors.Is(err, driver.PathNotFoundError{}) {
+				return nilIndex, zerr.ErrManifestNotFound
+			}
+
+			return nilIndex, err
+		}
+
+		if manifest.MediaType == ispec.MediaTypeImageManifest {
+			var mfst ispec.Manifest
+			if err := json.Unmarshal(buf, &mfst); err != nil {
+				log.Error().Err(err).Str("manifest digest", manifest.Digest.String()).Msg("invalid JSON")
+
+				return nilIndex, err
+			}
+
+			if mfst.Subject == nil || mfst.Subject.Digest != gdigest {
+				continue
+			}
+
+			// filter by artifact type
+			if artifactType != "" && mfst.Config.MediaType != artifactType {
+				continue
+			}
+
+			result = append(result, ispec.Descriptor{
+				MediaType:    manifest.MediaType,
+				ArtifactType: mfst.Config.MediaType,
+				Size:         manifest.Size,
+				Digest:       manifest.Digest,
+				Annotations:  mfst.Annotations,
+			})
+		} else if manifest.MediaType == ispec.MediaTypeArtifactManifest {
+			var art ispec.Artifact
+			if err := json.Unmarshal(buf, &art); err != nil {
+				log.Error().Err(err).Str("manifest digest", manifest.Digest.String()).Msg("invalid JSON")
+
+				return nilIndex, err
+			}
+
+			if art.Subject == nil || art.Subject.Digest != gdigest {
+				continue
+			}
+
+			// filter by artifact type
+			if artifactType != "" && art.ArtifactType != artifactType {
+				continue
+			}
+
+			result = append(result, ispec.Descriptor{
+				MediaType:    manifest.MediaType,
+				ArtifactType: art.ArtifactType,
+				Size:         manifest.Size,
+				Digest:       manifest.Digest,
+				Annotations:  art.Annotations,
+			})
+		}
+
+		found = true
+	}
+
+	if !found {
+		return nilIndex, zerr.ErrManifestNotFound
+	}
+
+	index = ispec.Index{
+		Versioned:   imeta.Versioned{SchemaVersion: storageConstants.SchemaVersion},
+		MediaType:   ispec.MediaTypeImageIndex,
+		Manifests:   result,
+		Annotations: map[string]string{},
+	}
+
+	// response was filtered by artifactType
+	if artifactType != "" {
+		index.Annotations[storageConstants.ReferrerFilterAnnotation] = ""
+	}
+
+	return index, nil
+}
+
 func IsSupportedMediaType(mediaType string) bool {
 	return mediaType == ispec.MediaTypeImageIndex ||
 		mediaType == ispec.MediaTypeImageManifest ||

pkg/storage/common_test.go

@@ -4,19 +4,24 @@ import (
 	"bytes"
 	"encoding/json"
 	"os"
+	"path"
 	"testing"
 
+	"github.com/docker/distribution/registry/storage/driver"
 	godigest "github.com/opencontainers/go-digest"
 	ispec "github.com/opencontainers/image-spec/specs-go/v1"
+	artifactspec "github.com/oras-project/artifacts-spec/specs-go/v1"
 	"github.com/rs/zerolog"
 	. "github.com/smartystreets/goconvey/convey"
 
+	"zotregistry.io/zot/errors"
 	"zotregistry.io/zot/pkg/extensions/monitoring"
 	"zotregistry.io/zot/pkg/log"
 	"zotregistry.io/zot/pkg/storage"
 	"zotregistry.io/zot/pkg/storage/cache"
 	"zotregistry.io/zot/pkg/storage/local"
 	"zotregistry.io/zot/pkg/test"
+	"zotregistry.io/zot/pkg/test/mocks"
 )
 
 func TestValidateManifest(t *testing.T) {
@@ -102,3 +107,199 @@ func TestValidateManifest(t *testing.T) {
 		})
 	})
 }
+
+func TestGetReferrersErrors(t *testing.T) {
+	Convey("make storage", t, func(c C) {
+		dir := t.TempDir()
+
+		log := log.Logger{Logger: zerolog.New(os.Stdout)}
+		metrics := monitoring.NewMetricsServer(false, log)
+		cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{
+			RootDir:     dir,
+			Name:        "cache",
+			UseRelPaths: true,
+		}, log)
+
+		imgStore := local.NewImageStore(dir, true, storage.DefaultGCDelay, false,
+			true, log, metrics, nil, cacheDriver)
+
+		artifactType := "application/vnd.example.icecream.v1"
+		validDigest := godigest.FromBytes([]byte("blob"))
+
+		Convey("Trigger invalid digest error", func(c C) {
+			_, err := storage.GetReferrers(imgStore, "zot-test", "invalidDigest", artifactType, log.With().Caller().Logger())
+			So(err, ShouldNotBeNil)
+
+			_, err = storage.GetOrasReferrers(imgStore, "zot-test", "invalidDigest", artifactType, log.With().Caller().Logger())
+			So(err, ShouldNotBeNil)
+		})
+
+		Convey("Trigger repo not found error", func(c C) {
+			_, err := storage.GetReferrers(imgStore, "zot-test", validDigest, artifactType, log.With().Caller().Logger())
+			So(err, ShouldNotBeNil)
+
+			_, err = storage.GetOrasReferrers(imgStore, "zot-test", validDigest, artifactType, log.With().Caller().Logger())
+			So(err, ShouldNotBeNil)
+		})
+
+		err := test.CopyFiles("../../test/data/zot-test", path.Join(dir, "zot-test"))
+		So(err, ShouldBeNil)
+
+		digest := godigest.FromBytes([]byte("{}"))
+
+		index := ispec.Index{
+			Manifests: []ispec.Descriptor{
+				{
+					MediaType: artifactspec.MediaTypeArtifactManifest,
+					Digest:    digest,
+				},
+			},
+		}
+
+		indexBuf, err := json.Marshal(index)
+		So(err, ShouldBeNil)
+
+		Convey("Trigger GetBlobContent() not found", func(c C) {
+			imgStore = &mocks.MockedImageStore{
+				GetIndexContentFn: func(repo string) ([]byte, error) {
+					return indexBuf, nil
+				},
+				GetBlobContentFn: func(repo string, digest godigest.Digest) ([]byte, error) {
+					return []byte{}, driver.PathNotFoundError{}
+				},
+			}
+
+			_, err = storage.GetReferrers(imgStore, "zot-test", validDigest, artifactType, log.With().Caller().Logger())
+			So(err, ShouldNotBeNil)
+
+			_, err = storage.GetOrasReferrers(imgStore, "zot-test", validDigest, artifactType, log.With().Caller().Logger())
+			So(err, ShouldNotBeNil)
+		})
+
+		Convey("Trigger GetBlobContent() generic error", func(c C) {
+			imgStore = &mocks.MockedImageStore{
+				GetIndexContentFn: func(repo string) ([]byte, error) {
+					return indexBuf, nil
+				},
+				GetBlobContentFn: func(repo string, digest godigest.Digest) ([]byte, error) {
+					return []byte{}, errors.ErrBadBlob
+				},
+			}
+
+			_, err = storage.GetReferrers(imgStore, "zot-test", validDigest, artifactType, log.With().Caller().Logger())
+			So(err, ShouldNotBeNil)
+		})
+
+		Convey("Trigger continue on different artifactType", func(c C) {
+			orasManifest := artifactspec.Manifest{
+				Subject: &artifactspec.Descriptor{
+					Digest:       digest,
+					ArtifactType: "unknown",
+				},
+			}
+
+			orasBuf, err := json.Marshal(orasManifest)
+			So(err, ShouldBeNil)
+
+			imgStore = &mocks.MockedImageStore{
+				GetIndexContentFn: func(repo string) ([]byte, error) {
+					return indexBuf, nil
+				},
+				GetBlobContentFn: func(repo string, digest godigest.Digest) ([]byte, error) {
+					return orasBuf, nil
+				},
+			}
+
+			_, err = storage.GetOrasReferrers(imgStore, "zot-test", validDigest, artifactType, log.With().Caller().Logger())
+			So(err, ShouldNotBeNil)
+
+			_, err = storage.GetOrasReferrers(imgStore, "zot-test", digest, artifactType, log.With().Caller().Logger())
+			So(err, ShouldNotBeNil)
+		})
+
+		Convey("Trigger unmarshal error on manifest image mediaType", func(c C) {
+			index = ispec.Index{
+				Manifests: []ispec.Descriptor{
+					{
+						MediaType: ispec.MediaTypeImageManifest,
+						Digest:    digest,
+					},
+				},
+			}
+
+			indexBuf, err = json.Marshal(index)
+			So(err, ShouldBeNil)
+
+			imgStore = &mocks.MockedImageStore{
+				GetIndexContentFn: func(repo string) ([]byte, error) {
+					return indexBuf, nil
+				},
+				GetBlobContentFn: func(repo string, digest godigest.Digest) ([]byte, error) {
+					return []byte{}, nil
+				},
+			}
+
+			_, err = storage.GetReferrers(imgStore, "zot-test", validDigest, artifactType, log.With().Caller().Logger())
+			So(err, ShouldNotBeNil)
+		})
+
+		Convey("Trigger unmarshal error on artifact mediaType", func(c C) {
+			index = ispec.Index{
+				Manifests: []ispec.Descriptor{
+					{
+						MediaType: ispec.MediaTypeArtifactManifest,
+						Digest:    digest,
+					},
+				},
+			}
+
+			indexBuf, err = json.Marshal(index)
+			So(err, ShouldBeNil)
+
+			imgStore = &mocks.MockedImageStore{
+				GetIndexContentFn: func(repo string) ([]byte, error) {
+					return indexBuf, nil
+				},
+				GetBlobContentFn: func(repo string, digest godigest.Digest) ([]byte, error) {
+					return []byte{}, nil
+				},
+			}
+
+			_, err = storage.GetReferrers(imgStore, "zot-test", validDigest, artifactType, log.With().Caller().Logger())
+			So(err, ShouldNotBeNil)
+		})
+
+		Convey("Trigger nil subject", func(c C) {
+			index = ispec.Index{
+				Manifests: []ispec.Descriptor{
+					{
+						MediaType: ispec.MediaTypeArtifactManifest,
+						Digest:    digest,
+					},
+				},
+			}
+
+			indexBuf, err = json.Marshal(index)
+			So(err, ShouldBeNil)
+
+			ociManifest := ispec.Manifest{
+				Subject: nil,
+			}
+
+			ociManifestBuf, err := json.Marshal(ociManifest)
+			So(err, ShouldBeNil)
+
+			imgStore = &mocks.MockedImageStore{
+				GetIndexContentFn: func(repo string) ([]byte, error) {
+					return indexBuf, nil
+				},
+				GetBlobContentFn: func(repo string, digest godigest.Digest) ([]byte, error) {
+					return ociManifestBuf, nil
+				},
+			}
+
+			_, err = storage.GetReferrers(imgStore, "zot-test", validDigest, artifactType, log.With().Caller().Logger())
+			So(err, ShouldNotBeNil)
+		})
+	})
+}

pkg/storage/local/local.go

@@ -1341,192 +1341,12 @@ func (is *ImageStoreLocal) DeleteBlob(repo string, digest godigest.Digest) error
 
 func (is *ImageStoreLocal) GetReferrers(repo string, gdigest godigest.Digest, artifactType string,
 ) (ispec.Index, error) {
-	var lockLatency time.Time
-
-	nilIndex := ispec.Index{}
-
-	if err := gdigest.Validate(); err != nil {
-		return nilIndex, err
-	}
-
-	dir := path.Join(is.rootDir, repo)
-	if !is.DirExists(dir) {
-		return nilIndex, zerr.ErrRepoNotFound
-	}
-
-	index, err := storage.GetIndex(is, repo, is.log)
-	if err != nil {
-		return nilIndex, err
-	}
-
-	is.RLock(&lockLatency)
-	defer is.RUnlock(&lockLatency)
-
-	found := false
-
-	result := []ispec.Descriptor{}
-
-	for _, manifest := range index.Manifests {
-		if manifest.Digest == gdigest {
-			continue
-		}
-
-		p := path.Join(dir, "blobs", manifest.Digest.Algorithm().String(), manifest.Digest.Encoded())
-
-		buf, err := os.ReadFile(p)
-		if err != nil {
-			is.log.Error().Err(err).Str("blob", p).Msg("failed to read manifest")
-
-			if os.IsNotExist(err) {
-				return nilIndex, zerr.ErrManifestNotFound
-			}
-
-			return nilIndex, err
-		}
-
-		if manifest.MediaType == ispec.MediaTypeImageManifest {
-			var mfst ispec.Manifest
-			if err := json.Unmarshal(buf, &mfst); err != nil {
-				return nilIndex, err
-			}
-
-			if mfst.Subject == nil || mfst.Subject.Digest != gdigest {
-				continue
-			}
-
-			// filter by artifact type
-			if artifactType != "" && mfst.Config.MediaType != artifactType {
-				continue
-			}
-
-			result = append(result, ispec.Descriptor{
-				MediaType:    manifest.MediaType,
-				ArtifactType: mfst.Config.MediaType,
-				Size:         manifest.Size,
-				Digest:       manifest.Digest,
-				Annotations:  mfst.Annotations,
-			})
-		} else if manifest.MediaType == ispec.MediaTypeArtifactManifest {
-			var art ispec.Artifact
-			if err := json.Unmarshal(buf, &art); err != nil {
-				return nilIndex, err
-			}
-
-			if art.Subject == nil || art.Subject.Digest != gdigest {
-				continue
-			}
-
-			// filter by artifact type
-			if artifactType != "" && art.ArtifactType != artifactType {
-				continue
-			}
-
-			result = append(result, ispec.Descriptor{
-				MediaType:    manifest.MediaType,
-				ArtifactType: art.ArtifactType,
-				Size:         manifest.Size,
-				Digest:       manifest.Digest,
-				Annotations:  art.Annotations,
-			})
-		}
-
-		found = true
-	}
-
-	if !found {
-		return nilIndex, zerr.ErrManifestNotFound
-	}
-
-	index = ispec.Index{
-		Versioned:   imeta.Versioned{SchemaVersion: defaultSchemaVersion},
-		MediaType:   ispec.MediaTypeImageIndex,
-		Manifests:   result,
-		Annotations: map[string]string{},
-	}
-
-	// response was filtered by artifactType
-	if artifactType != "" {
-		index.Annotations[storageConstants.ReferrerFilterAnnotation] = artifactType
-	}
-
-	return index, nil
+	return storage.GetReferrers(is, repo, gdigest, artifactType, is.log)
 }
 
 func (is *ImageStoreLocal) GetOrasReferrers(repo string, gdigest godigest.Digest, artifactType string,
 ) ([]oras.Descriptor, error) {
-	var lockLatency time.Time
-
-	if err := gdigest.Validate(); err != nil {
-		return nil, err
-	}
-
-	dir := path.Join(is.rootDir, repo)
-	if !is.DirExists(dir) {
-		return nil, zerr.ErrRepoNotFound
-	}
-
-	index, err := storage.GetIndex(is, repo, is.log)
-	if err != nil {
-		return nil, err
-	}
-
-	is.RLock(&lockLatency)
-	defer is.RUnlock(&lockLatency)
-
-	found := false
-
-	result := []oras.Descriptor{}
-
-	for _, manifest := range index.Manifests {
-		if manifest.MediaType != oras.MediaTypeArtifactManifest {
-			continue
-		}
-
-		p := path.Join(dir, "blobs", manifest.Digest.Algorithm().String(), manifest.Digest.Encoded())
-
-		buf, err := os.ReadFile(p)
-		if err != nil {
-			is.log.Error().Err(err).Str("blob", p).Msg("failed to read manifest")
-
-			if os.IsNotExist(err) {
-				return nil, zerr.ErrManifestNotFound
-			}
-
-			return nil, err
-		}
-
-		var artManifest oras.Manifest
-		if err := json.Unmarshal(buf, &artManifest); err != nil {
-			is.log.Error().Err(err).Str("dir", dir).Msg("invalid JSON")
-
-			return nil, err
-		}
-
-		if artManifest.Subject.Digest != gdigest {
-			continue
-		}
-
-		// filter by artifact type
-		if artifactType != "" && artManifest.ArtifactType != artifactType {
-			continue
-		}
-
-		result = append(result, oras.Descriptor{
-			MediaType:    manifest.MediaType,
-			ArtifactType: artManifest.ArtifactType,
-			Digest:       manifest.Digest,
-			Size:         manifest.Size,
-			Annotations:  manifest.Annotations,
-		})
-
-		found = true
-	}
-
-	if !found {
-		return nil, zerr.ErrManifestNotFound
-	}
-
-	return result, nil
+	return storage.GetOrasReferrers(is, repo, gdigest, artifactType, is.log)
 }
 
 func (is *ImageStoreLocal) writeFile(filename string, data []byte) error {

pkg/storage/s3/s3.go

@@ -1224,14 +1224,14 @@ func (is *ObjectStorage) GetBlobContent(repo string, digest godigest.Digest) ([]
 	return buf.Bytes(), nil
 }
 
-func (is *ObjectStorage) GetReferrers(repo string, digest godigest.Digest, artifactType string,
+func (is *ObjectStorage) GetReferrers(repo string, gdigest godigest.Digest, artifactType string,
 ) (ispec.Index, error) {
-	return ispec.Index{}, zerr.ErrMethodNotSupported
+	return storage.GetReferrers(is, repo, gdigest, artifactType, is.log)
 }
 
-func (is *ObjectStorage) GetOrasReferrers(repo string, digest godigest.Digest, artifactType string,
+func (is *ObjectStorage) GetOrasReferrers(repo string, gdigest godigest.Digest, artifactType string,
 ) ([]artifactspec.Descriptor, error) {
-	return nil, zerr.ErrMethodNotSupported
+	return storage.GetOrasReferrers(is, repo, gdigest, artifactType, is.log)
 }
 
 func (is *ObjectStorage) GetIndexContent(repo string) ([]byte, error) {

pkg/storage/s3/s3_test.go

@@ -20,6 +20,7 @@ import (
 	guuid "github.com/gofrs/uuid"
 	godigest "github.com/opencontainers/go-digest"
 	ispec "github.com/opencontainers/image-spec/specs-go/v1"
+	artifactspec "github.com/oras-project/artifacts-spec/specs-go/v1"
 	"github.com/rs/zerolog"
 	. "github.com/smartystreets/goconvey/convey"
 	"gopkg.in/resty.v1"
@@ -64,7 +65,7 @@ func createMockStorage(rootDir string, cacheDir string, dedupe bool, store drive
 	var cacheDriver cache.Cache
 
 	// from pkg/cli/root.go/applyDefaultValues, s3 magic
-	if _, err := os.Stat(cacheDir); dedupe || (!dedupe && err == nil) {
+	if _, err := os.Stat(path.Join(cacheDir, "s3_cache.db")); dedupe || (!dedupe && err == nil) {
 		cacheDriver, _ = storage.Create("boltdb", cache.BoltDBDriverParameters{
 			RootDir:     cacheDir,
 			Name:        "s3_cache",
@@ -116,7 +117,7 @@ func createObjectsStore(rootDir string, cacheDir string, dedupe bool) (
 	var cacheDriver cache.Cache
 
 	// from pkg/cli/root.go/applyDefaultValues, s3 magic
-	if _, err := os.Stat(cacheDir); dedupe || (!dedupe && err == nil) {
+	if _, err := os.Stat(path.Join(cacheDir, "s3_cache.db")); dedupe || (!dedupe && err == nil) {
 		cacheDriver, _ = storage.Create("boltdb", cache.BoltDBDriverParameters{
 			RootDir:     cacheDir,
 			Name:        "s3_cache",
@@ -378,6 +379,201 @@ func TestStorageDriverStatFunction(t *testing.T) {
 	})
 }
 
+func TestGetOrasAndOCIReferrers(t *testing.T) {
+	repo := "zot-test"
+
+	uuid, err := guuid.NewV4()
+	if err != nil {
+		panic(err)
+	}
+
+	tdir := t.TempDir()
+	testDir := path.Join("/oci-repo-test", uuid.String())
+
+	_, imgStore, _ := createObjectsStore(testDir, tdir, true)
+
+	Convey("Upload test image", t, func(c C) {
+		cfg, layers, manifest, err := test.GetImageComponents(100)
+		So(err, ShouldBeNil)
+
+		for _, content := range layers {
+			upload, err := imgStore.NewBlobUpload(repo)
+			So(err, ShouldBeNil)
+			So(upload, ShouldNotBeEmpty)
+
+			buf := bytes.NewBuffer(content)
+			buflen := buf.Len()
+			digest := godigest.FromBytes(content)
+
+			blob, err := imgStore.PutBlobChunkStreamed(repo, upload, buf)
+			So(err, ShouldBeNil)
+			So(blob, ShouldEqual, buflen)
+			blobDigest1 := digest
+			So(blobDigest1, ShouldNotBeEmpty)
+
+			err = imgStore.FinishBlobUpload(repo, upload, buf, digest)
+			So(err, ShouldBeNil)
+			So(blob, ShouldEqual, buflen)
+		}
+
+		// upload config blob
+		cblob, err := json.Marshal(cfg)
+		So(err, ShouldBeNil)
+
+		buf := bytes.NewBuffer(cblob)
+		buflen := buf.Len()
+		digest := godigest.FromBytes(cblob)
+
+		_, clen, err := imgStore.FullBlobUpload(repo, buf, digest)
+		So(err, ShouldBeNil)
+		So(clen, ShouldEqual, buflen)
+
+		// upload manifest
+		mblob, err := json.Marshal(manifest)
+		So(err, ShouldBeNil)
+
+		mbuf := bytes.NewBuffer(mblob)
+		mbuflen := mbuf.Len()
+		mdigest := godigest.FromBytes(mblob)
+
+		d, err := imgStore.PutImageManifest(repo, "1.0", ispec.MediaTypeImageManifest, mbuf.Bytes())
+		So(d, ShouldEqual, mdigest)
+		So(err, ShouldBeNil)
+
+		body := []byte("this is an artifact")
+		digest = godigest.FromBytes(body)
+		buf = bytes.NewBuffer(body)
+		buflen = buf.Len()
+
+		_, n, err := imgStore.FullBlobUpload(repo, buf, digest)
+		So(err, ShouldBeNil)
+		So(n, ShouldEqual, buflen)
+
+		Convey("Get oci referrers - application/vnd.oci.image.manifest.v1+json", func(c C) {
+			artifactType := "application/vnd.example.icecream.v1"
+			// push artifact config blob
+			configBody := []byte("{}")
+			configDigest := godigest.FromBytes(configBody)
+			configBuf := bytes.NewBuffer(configBody)
+			configBufLen := configBuf.Len()
+
+			_, n, err := imgStore.FullBlobUpload(repo, configBuf, configDigest)
+			So(err, ShouldBeNil)
+			So(n, ShouldEqual, configBufLen)
+
+			artifactManifest := ispec.Manifest{
+				MediaType: ispec.MediaTypeImageManifest,
+				Config: ispec.Descriptor{
+					MediaType: artifactType,
+					Size:      int64(configBufLen),
+					Digest:    configDigest,
+				},
+				Layers: []ispec.Descriptor{
+					{
+						MediaType: "application/octet-stream",
+						Size:      int64(buflen),
+						Digest:    digest,
+					},
+				},
+				Subject: &ispec.Descriptor{
+					MediaType: ispec.MediaTypeImageManifest,
+					Size:      int64(mbuflen),
+					Digest:    mdigest,
+				},
+			}
+
+			manBuf, err := json.Marshal(artifactManifest)
+			So(err, ShouldBeNil)
+
+			manBufLen := len(manBuf)
+			manDigest := godigest.FromBytes(manBuf)
+
+			_, err = imgStore.PutImageManifest(repo, manDigest.Encoded(), ispec.MediaTypeImageManifest, manBuf)
+			So(err, ShouldBeNil)
+
+			index, err := imgStore.GetReferrers(repo, mdigest, artifactType)
+			So(err, ShouldBeNil)
+			So(index, ShouldNotBeEmpty)
+			So(index.Manifests[0].ArtifactType, ShouldEqual, artifactType)
+			So(index.Manifests[0].MediaType, ShouldEqual, ispec.MediaTypeImageManifest)
+			So(index.Manifests[0].Size, ShouldEqual, manBufLen)
+			So(index.Manifests[0].Digest, ShouldEqual, manDigest)
+		})
+
+		Convey("Get oci referrers - application/vnd.oci.artifact.manifest.v1+json", func(c C) {
+			artifactType := "application/vnd.example.icecream.v1"
+
+			artifactManifest := ispec.Artifact{
+				MediaType:    ispec.MediaTypeArtifactManifest,
+				ArtifactType: artifactType,
+				Blobs: []ispec.Descriptor{
+					{
+						MediaType: "application/octet-stream",
+						Size:      int64(buflen),
+						Digest:    digest,
+					},
+				},
+				Subject: &ispec.Descriptor{
+					MediaType: ispec.MediaTypeImageManifest,
+					Size:      int64(mbuflen),
+					Digest:    mdigest,
+				},
+			}
+
+			manBuf, err := json.Marshal(artifactManifest)
+			So(err, ShouldBeNil)
+
+			manBufLen := len(manBuf)
+			manDigest := godigest.FromBytes(manBuf)
+
+			_, err = imgStore.PutImageManifest(repo, manDigest.Encoded(), ispec.MediaTypeArtifactManifest, manBuf)
+			So(err, ShouldBeNil)
+
+			index, err := imgStore.GetReferrers(repo, mdigest, artifactType)
+			So(err, ShouldBeNil)
+			So(index, ShouldNotBeEmpty)
+			So(index.Manifests[1].ArtifactType, ShouldEqual, artifactType)
+			So(index.Manifests[1].MediaType, ShouldEqual, ispec.MediaTypeArtifactManifest)
+			So(index.Manifests[1].Size, ShouldEqual, manBufLen)
+			So(index.Manifests[1].Digest, ShouldEqual, manDigest)
+		})
+
+		Convey("Get oras referrers", func(c C) {
+			artifactManifest := artifactspec.Manifest{}
+			artifactManifest.ArtifactType = "signature-example"
+			artifactManifest.Subject = &artifactspec.Descriptor{
+				MediaType: ispec.MediaTypeImageManifest,
+				Digest:    mdigest,
+				Size:      int64(mbuflen),
+			}
+			artifactManifest.Blobs = []artifactspec.Descriptor{
+				{
+					Size:      int64(buflen),
+					Digest:    digest,
+					MediaType: "application/octet-stream",
+				},
+			}
+
+			manBuf, err := json.Marshal(artifactManifest)
+			So(err, ShouldBeNil)
+
+			manBufLen := len(manBuf)
+			manDigest := godigest.FromBytes(manBuf)
+
+			_, err = imgStore.PutImageManifest(repo, manDigest.Encoded(), artifactspec.MediaTypeArtifactManifest, manBuf)
+			So(err, ShouldBeNil)
+
+			descriptors, err := imgStore.GetOrasReferrers(repo, mdigest, "signature-example")
+			So(err, ShouldBeNil)
+			So(descriptors, ShouldNotBeEmpty)
+			So(descriptors[0].ArtifactType, ShouldEqual, "signature-example")
+			So(descriptors[0].MediaType, ShouldEqual, artifactspec.MediaTypeArtifactManifest)
+			So(descriptors[0].Size, ShouldEqual, manBufLen)
+			So(descriptors[0].Digest, ShouldEqual, manDigest)
+		})
+	})
+}
+
 func TestNegativeCasesObjectsStorage(t *testing.T) {
 	skipIt(t)
 
@@ -397,11 +593,13 @@ func TestNegativeCasesObjectsStorage(t *testing.T) {
 			So(imgStore.InitRepo(testImage), ShouldBeNil)
 			objects, err := storeDriver.List(context.Background(), path.Join(imgStore.RootDir(), testImage))
 			So(err, ShouldBeNil)
+
 			for _, object := range objects {
 				t.Logf("Removing object: %s", object)
 				err := storeDriver.Delete(context.Background(), object)
 				So(err, ShouldBeNil)
 			}
+
 			_, err = imgStore.ValidateRepo(testImage)
 			So(err, ShouldNotBeNil)
 			_, err = imgStore.GetRepositories()
@@ -467,7 +665,6 @@ func TestNegativeCasesObjectsStorage(t *testing.T) {
 
 	Convey("Without dedupe", t, func(c C) {
 		tdir := t.TempDir()
-
 		storeDriver, imgStore, _ := createObjectsStore(testDir, tdir, false)
 		defer cleanupStorage(storeDriver, testDir)
 
@@ -907,27 +1104,19 @@ func TestNegativeCasesObjectsStorage(t *testing.T) {
 		})
 
 		Convey("Test GetReferrers", func(c C) {
-			imgStore = createMockStorage(testDir, tdir, false, &StorageDriverMock{
-				DeleteFn: func(ctx context.Context, path string) error {
-					return errS3
-				},
-			})
+			imgStore = createMockStorage(testDir, tdir, false, &StorageDriverMock{})
 			d := godigest.FromBytes([]byte(""))
 			_, err := imgStore.GetReferrers(testImage, d, "application/image")
 			So(err, ShouldNotBeNil)
-			So(err, ShouldEqual, zerr.ErrMethodNotSupported)
+			So(err, ShouldEqual, zerr.ErrRepoBadVersion)
 		})
 
 		Convey("Test GetOrasReferrers", func(c C) {
-			imgStore = createMockStorage(testDir, tdir, false, &StorageDriverMock{
-				DeleteFn: func(ctx context.Context, path string) error {
-					return errS3
-				},
-			})
+			imgStore = createMockStorage(testDir, tdir, false, &StorageDriverMock{})
 			d := godigest.FromBytes([]byte(""))
 			_, err := imgStore.GetOrasReferrers(testImage, d, "application/image")
 			So(err, ShouldNotBeNil)
-			So(err, ShouldEqual, zerr.ErrMethodNotSupported)
+			So(err, ShouldEqual, zerr.ErrRepoBadVersion)
 		})
 	})
 }