Add List interface to snapshotter cache

Add a List interface to Cache and implement it for SnapshotterCache. The
List interface returns keys existing in a cache.

These changes also modify the SnapshotterCache to use a RWMutex rather
than a vanilla Mutex https://pkg.go.dev/sync#RWMutex . This way any
number of readers can read from cache, but only one writer may acquire
the lock at a time.

Signed-off-by: Gavin Inglis <giinglis@amazon.com>

Author: ginglis13

snapshotter/demux/cache/cache.go

@@ -33,4 +33,7 @@ type Cache interface {
 
 	// Releases the cache's internal resources and closes any cached snapshotters.
 	Close() error
+
+	// Lists keys present in the cache.
+	List() []string
 }

snapshotter/demux/cache/snapshotter_cache.go

@@ -25,13 +25,13 @@ import (
 // SnapshotterCache implements a read, write protected cache mechanism
 // for keyed snapshotters.
 type SnapshotterCache struct {
-	mutex        *sync.Mutex
+	mutex        *sync.RWMutex
 	snapshotters map[string]snapshots.Snapshotter
 }
 
 // NewSnapshotterCache creates a new instance with an empty cache.
 func NewSnapshotterCache() *SnapshotterCache {
-	return &SnapshotterCache{&sync.Mutex{}, make(map[string]snapshots.Snapshotter)}
+	return &SnapshotterCache{&sync.RWMutex{}, make(map[string]snapshots.Snapshotter)}
 }
 
 // Get fetches and caches the snapshotter for a given key.
@@ -58,7 +58,9 @@ func (cache *SnapshotterCache) Get(ctx context.Context, key string, fetch Snapsh
 
 // Evict removes a cached snapshotter for a given key.
 func (cache *SnapshotterCache) Evict(key string) error {
+	cache.mutex.RLock()
 	snapshotter, ok := cache.snapshotters[key]
+	cache.mutex.RUnlock()
 
 	if !ok {
 		return fmt.Errorf("snapshotter %s not found in cache", key)
@@ -81,3 +83,15 @@ func (cache *SnapshotterCache) Close() error {
 	}
 	return compiledErr
 }
+
+// List returns keys of a snapshotter cache.
+func (cache *SnapshotterCache) List() []string {
+	cache.mutex.RLock()
+	defer cache.mutex.RUnlock()
+	keys := make([]string, 0, len(cache.snapshotters))
+	for k := range cache.snapshotters {
+		keys = append(keys, k)
+	}
+
+	return keys
+}

snapshotter/demux/cache/snapshotter_cache_test.go

@@ -124,6 +124,29 @@ func closeCacheReturnsAllOccurringErrors(uut *SnapshotterCache) error {
 	return nil
 }
 
+func listEmptyCache(uut *SnapshotterCache) error {
+	keys := uut.List()
+	if len(keys) > 0 {
+		return errors.New("List did not return an empty list for an empty snapshotter cache")
+	}
+
+	return nil
+}
+
+func listNonEmptyCache(uut *SnapshotterCache) error {
+	uut.Get(context.Background(), "OkSnapshotterKey", getSnapshotterOkFunction)
+
+	keys := uut.List()
+	if len(keys) != 1 {
+		return errors.New("List should return a non-empty list of keys")
+	}
+	if keys[0] != "OkSnapshotterKey" {
+		return errors.New("List did not return correct list of keys")
+	}
+
+	return nil
+}
+
 func TestGetSnapshotterFromCache(t *testing.T) {
 	t.Parallel()
 
@@ -189,3 +212,25 @@ func TestCloseCache(t *testing.T) {
 		})
 	}
 }
+
+func TestListSnapshotters(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		run  func(*SnapshotterCache) error
+	}{
+		{"ListEmptyCache", listEmptyCache},
+		{"ListNonEmptyCache", listNonEmptyCache},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			uut := NewSnapshotterCache()
+			if err := test.run(uut); err != nil {
+				t.Fatal(test.name + ": " + err.Error())
+			}
+		})
+	}
+
+}