Folder metadata in stat cache

internal/cache/metadata/stat_cache.go

@@ -18,6 +18,7 @@ import (
 	"math"
 	"time"
 
+	"cloud.google.com/go/storage/control/apiv2/controlpb"
 	"github.com/googlecloudplatform/gcsfuse/v2/internal/cache/lru"
 	"github.com/googlecloudplatform/gcsfuse/v2/internal/storage/gcs"
 	"github.com/googlecloudplatform/gcsfuse/v2/internal/util"
@@ -45,10 +46,24 @@ type StatCache interface {
 	// Erase the entry for the given object name, if any.
 	Erase(name string)
 
-	// Return the current entry for the given name, or nil if there is a negative
+	// Return the current object entry for the given name, or nil if there is a negative
 	// entry. Return hit == false when there is neither a positive nor a negative
 	// entry, or the entry has expired according to the supplied current time.
 	LookUp(name string, now time.Time) (hit bool, m *gcs.MinObject)
+
+	// Insert an entry for the given folder resource.
+	//
+	// In order to help cope with caching of arbitrarily out of date (i.e.
+	// inconsistent) object listings, entry will not replace any positive entry
+	// with a newer meta generation number.
+	//
+	// The entry will expire after the supplied time.
+	InsertFolder(f *controlpb.Folder, expiration time.Time)
+
+	// Return the current folder entry for the given name, or nil if there is a negative
+	// entry. Return hit == false when there is neither a positive nor a negative
+	// entry, or the entry has expired according to the supplied current time.
+	LookUpFolder(folderName string, now time.Time) (bool, *controlpb.Folder)
 }
 
 // Create a new bucket-view to the passed shared-cache object.
@@ -80,6 +95,7 @@ type statCacheBucketView struct {
 // entry. Nil object means negative entry.
 type entry struct {
 	m          *gcs.MinObject
+	f          *controlpb.Folder
 	expiration time.Time
 	key        string
 }
@@ -203,3 +219,46 @@ func (sc *statCacheBucketView) LookUp(
 
 	return
 }
+
+func (sc *statCacheBucketView) LookUpFolder(
+	folderName string,
+	now time.Time) (bool, *controlpb.Folder) {
+	// Look up in the LRU cache.
+	value := sc.sharedCache.LookUp(sc.key(folderName))
+	if value == nil {
+		return false, nil
+	}
+
+	e := value.(entry)
+
+	// Has this entry expired?
+	if e.expiration.Before(now) {
+		sc.Erase(folderName)
+		return false, nil
+	}
+
+	return true, e.f
+}
+
+func (sc *statCacheBucketView) InsertFolder(f *controlpb.Folder, expiration time.Time) {
+	name := sc.key(f.Name)
+
+	// Return if there is already a better entry?
+	existing := sc.sharedCache.LookUp(name)
+	if existing != nil && existing.(entry).f != nil {
+		existingFolder := existing.(entry).f
+		if f.Metageneration != existingFolder.Metageneration && f.Metageneration < existingFolder.Metageneration {
+			return
+		}
+	}
+
+	e := entry{
+		f:          f,
+		expiration: expiration,
+		key:        name,
+	}
+
+	if _, err := sc.sharedCache.Insert(name, e); err != nil {
+		panic(err)
+	}
+}

internal/cache/metadata/stat_cache_test.go

@@ -18,6 +18,7 @@ import (
 	"testing"
 	"time"
 
+	"cloud.google.com/go/storage/control/apiv2/controlpb"
 	"github.com/googlecloudplatform/gcsfuse/v2/internal/cache/lru"
 	"github.com/googlecloudplatform/gcsfuse/v2/internal/cache/metadata"
 	"github.com/googlecloudplatform/gcsfuse/v2/internal/mount"
@@ -100,7 +101,8 @@ var expiration = someTime.Add(time.Second)
 
 type StatCacheTest struct {
 	suite.Suite
-	cache testHelperCache
+	cache     testHelperCache
+	statCache metadata.StatCache
 }
 
 type MultiBucketStatCacheTest struct {
@@ -111,6 +113,7 @@ type MultiBucketStatCacheTest struct {
 func (t *StatCacheTest) SetupTest() {
 	cache := lru.NewCache(uint64((mount.AverageSizeOfPositiveStatCacheEntry + mount.AverageSizeOfNegativeStatCacheEntry) * capacity))
 	t.cache.wrapped = metadata.NewStatCacheBucketView(cache, "") // this demonstrates
+	t.statCache = metadata.NewStatCacheBucketView(cache, "")     // this demonstrates
 	// that if you are using a cache for a single bucket, then
 	// its prepending bucketName can be left empty("") without any problem.
 }
@@ -408,3 +411,72 @@ func (t *MultiBucketStatCacheTest) Test_ExpiresLeastRecentlyUsed() {
 	assert.Equal(t.T(), cardamom, spices.LookUpOrNil("cardamom", someTime))
 	assert.Equal(t.T(), saffron, spices.LookUpOrNil("saffron", someTime))
 }
+
+func (t *StatCacheTest) Test_Create_Entry_When_No_Entry_Is_Present() {
+	const name = "key1"
+	newEntry := &controlpb.Folder{
+		Name:           name,
+		Metageneration: 1,
+	}
+
+	t.statCache.InsertFolder(newEntry, expiration)
+
+	hit, entry := t.statCache.LookUpFolder(name, someTime)
+	assert.True(t.T(), hit)
+	assert.Equal(t.T(), "key1", entry.Name)
+	assert.Equal(t.T(), int64(1), entry.Metageneration)
+}
+
+func (t *StatCacheTest) Test_Override_Entry_Old_Entry_Is_Already_Present() {
+	const name = "key1"
+	existingEntry := &controlpb.Folder{
+		Name:           name,
+		Metageneration: 1,
+	}
+	t.statCache.InsertFolder(existingEntry, expiration)
+	newEntry := &controlpb.Folder{
+		Name:           name,
+		Metageneration: 2,
+	}
+
+	t.statCache.InsertFolder(newEntry, expiration)
+
+	hit, entry := t.statCache.LookUpFolder(name, someTime)
+	assert.True(t.T(), hit)
+	assert.Equal(t.T(), "key1", entry.Name)
+	assert.Equal(t.T(), int64(2), entry.Metageneration)
+}
+
+func (t *StatCacheTest) Test_Lookup_Return_False_If_Expiration_Is_Passed() {
+	const name = "key1"
+	entry := &controlpb.Folder{
+		Name:           name,
+		Metageneration: 1,
+	}
+	t.statCache.InsertFolder(entry, expiration)
+
+	hit, result := t.statCache.LookUpFolder(name, expiration.Add(time.Second))
+
+	assert.False(t.T(), hit)
+	assert.Nil(t.T(), result)
+}
+
+func (t *StatCacheTest) Test_Should_Not_Override_Entry_If_Metageneration_Is_Old() {
+	const name = "key1"
+	existingEntry := &controlpb.Folder{
+		Name:           name,
+		Metageneration: 2,
+	}
+	t.statCache.InsertFolder(existingEntry, expiration)
+	newEntry := &controlpb.Folder{
+		Name:           name,
+		Metageneration: 1,
+	}
+
+	t.statCache.InsertFolder(newEntry, expiration)
+
+	hit, entry := t.statCache.LookUpFolder(name, someTime)
+	assert.True(t.T(), hit)
+	assert.Equal(t.T(), "key1", entry.Name)
+	assert.Equal(t.T(), int64(2), entry.Metageneration)
+}