pkg/storage: make Checker optional in storage.Backend (#1580)

* pkg/storage: make Checker optional in storage.Backend

* pass storage

cmd/proxy/actions/app_proxy.go

@@ -91,8 +91,8 @@ func addProxyRoutes(
 	}
 
 	lister := module.NewVCSLister(c.GoBinary, c.GoBinaryEnvVars, fs)
-
-	withSingleFlight, err := getSingleFlight(c, s)
+	checker := storage.WithChecker(s)
+	withSingleFlight, err := getSingleFlight(c, checker)
 	if err != nil {
 		return err
 	}

pkg/stash/stasher.go

@@ -28,7 +28,7 @@ type Wrapper func(Stasher) Stasher
 // a module from a download.Protocol and
 // stashes it into a backend.Storage.
 func New(f module.Fetcher, s storage.Backend, wrappers ...Wrapper) Stasher {
-	var st Stasher = &stasher{f, s}
+	var st Stasher = &stasher{f, s, storage.WithChecker(s)}
 	for _, w := range wrappers {
 		st = w(st)
 	}
@@ -39,6 +39,7 @@ func New(f module.Fetcher, s storage.Backend, wrappers ...Wrapper) Stasher {
 type stasher struct {
 	fetcher module.Fetcher
 	storage storage.Backend
+	checker storage.Checker
 }
 
 func (s *stasher) Stash(ctx context.Context, mod, ver string) (string, error) {
@@ -58,7 +59,7 @@ func (s *stasher) Stash(ctx context.Context, mod, ver string) (string, error) {
 	}
 	defer v.Zip.Close()
 	if v.Semver != ver {
-		exists, err := s.storage.Exists(ctx, mod, v.Semver)
+		exists, err := s.checker.Exists(ctx, mod, v.Semver)
 		if err != nil {
 			return "", errors.E(op, err)
 		}

pkg/stash/with_azureblob_test.go

@@ -30,7 +30,7 @@ func TestWithAzureBlob(t *testing.T) {
 		t.Fatal(err)
 	}
 	ms := &mockAzureBlobStasher{strg: strg}
-	wpr, err := WithAzureBlobLock(cfg, time.Second*10, strg)
+	wpr, err := WithAzureBlobLock(cfg, time.Second*10, storage.WithChecker(strg))
 	if err != nil {
 		t.Fatal(err)
 	}

pkg/stash/with_etcd_test.go

@@ -28,7 +28,7 @@ func TestEtcdSingleFlight(t *testing.T) {
 	}
 	ms := &mockEtcdStasher{strg: strg}
 	endpoints := strings.Split(endpointsStr, ",")
-	wrapper, err := WithEtcd(endpoints, strg)
+	wrapper, err := WithEtcd(endpoints, storage.WithChecker(strg))
 	if err != nil {
 		t.Fatal(err)
 	}

pkg/stash/with_redis_sentinel_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/gomods/athens/pkg/storage"
 	"github.com/gomods/athens/pkg/storage/mem"
 	"golang.org/x/sync/errgroup"
 )
@@ -25,7 +26,7 @@ func TestWithRedisSentinelLock(t *testing.T) {
 		t.Fatal(err)
 	}
 	ms := &mockRedisStasher{strg: strg}
-	wrapper, err := WithRedisSentinelLock([]string{endpoint}, masterName, password, strg)
+	wrapper, err := WithRedisSentinelLock([]string{endpoint}, masterName, password, storage.WithChecker(strg))
 	if err != nil {
 		t.Fatal(err)
 	}

pkg/stash/with_redis_test.go

@@ -28,7 +28,7 @@ func TestWithRedisLock(t *testing.T) {
 		t.Fatal(err)
 	}
 	ms := &mockRedisStasher{strg: strg}
-	wrapper, err := WithRedisLock(endpoint, password, strg)
+	wrapper, err := WithRedisLock(endpoint, password, storage.WithChecker(strg))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -63,7 +63,7 @@ func TestWithRedisLockWithPassword(t *testing.T) {
 		t.Fatal(err)
 	}
 	ms := &mockRedisStasher{strg: strg}
-	wrapper, err := WithRedisLock(endpoint, password, strg)
+	wrapper, err := WithRedisLock(endpoint, password, storage.WithChecker(strg))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -97,7 +97,7 @@ func TestWithRedisLockWithWrongPassword(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	_, err = WithRedisLock(endpoint, password, strg)
+	_, err = WithRedisLock(endpoint, password, storage.WithChecker(strg))
 	if err == nil {
 		t.Fatal("Expected Connection Error")
 	}

pkg/storage/backend.go

@@ -4,7 +4,6 @@ package storage
 type Backend interface {
 	Lister
 	Getter
-	Checker
 	Saver
 	Deleter
 }

pkg/storage/checker.go

@@ -1,6 +1,10 @@
 package storage
 
-import "context"
+import (
+	"context"
+
+	"github.com/gomods/athens/pkg/errors"
+)
 
 // Checker is the interface that checks if the version of the module exists
 type Checker interface {
@@ -8,3 +12,27 @@ type Checker interface {
 	// in the backing storage
 	Exists(ctx context.Context, module, version string) (bool, error)
 }
+
+// WithChecker wraps the backend with a Checker implementaiton
+func WithChecker(strg Backend) Checker {
+	if checker, ok := strg.(Checker); ok {
+		return checker
+	}
+	return &checker{strg}
+}
+
+type checker struct {
+	strg Backend
+}
+
+func (c *checker) Exists(ctx context.Context, module, version string) (bool, error) {
+	const op errors.Op = "checker.Exists"
+	_, err := c.strg.Info(ctx, module, version)
+	if err != nil {
+		if errors.Is(err, errors.KindNotFound) {
+			return false, nil
+		}
+		return false, err
+	}
+	return true, nil
+}

pkg/storage/compliance/benchmarks.go

@@ -104,7 +104,7 @@ func benchExists(b *testing.B, s storage.Backend, clear func() error) {
 
 	b.Run("exists", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
-			exists, err := s.Exists(ctx, module, version)
+			exists, err := storage.WithChecker(s).Exists(ctx, module, version)
 			require.NoError(b, err)
 			require.True(b, exists)
 		}

pkg/storage/compliance/tests.go

@@ -163,8 +163,8 @@ func testExists(t *testing.T, b storage.Backend) {
 	zipBts, _ := ioutil.ReadAll(mock.Zip)
 	b.Save(ctx, modname, ver, mock.Mod, bytes.NewReader(zipBts), mock.Info)
 	defer b.Delete(ctx, modname, ver)
-
-	exists, err := b.Exists(ctx, modname, ver)
+	checker := storage.WithChecker(b)
+	exists, err := checker.Exists(ctx, modname, ver)
 	require.NoError(t, err)
 	require.Equal(t, true, exists)
 }
@@ -180,7 +180,8 @@ func testShouldNotExist(t *testing.T, b storage.Backend) {
 	defer b.Delete(ctx, mod, ver)
 
 	prefixVer := "v1.2.3-pre"
-	exists, err := b.Exists(ctx, mod, prefixVer)
+
+	exists, err := storage.WithChecker(b).Exists(ctx, mod, prefixVer)
 	require.NoError(t, err)
 	if exists {
 		t.Fatal("a non existing version that has the same prefix of an existing version should not exist")
@@ -202,7 +203,7 @@ func testDelete(t *testing.T, b storage.Backend) {
 	err = b.Delete(ctx, modname, version)
 	require.NoError(t, err)
 
-	exists, err := b.Exists(ctx, modname, version)
+	exists, err := storage.WithChecker(b).Exists(ctx, modname, version)
 	require.NoError(t, err)
 	require.Equal(t, false, exists)
 }