Added RefreshIfModifiedAfter function for LoadingCache

Function will asynchronously reloads value for Key if the provided timestamp indicates the data was modified after the entry was last loaded

Author: pt-nguyen

cache.go

@@ -2,6 +2,8 @@
 // including support for LRU, Segmented LRU and TinyLFU.
 package cache
 
+import "time"
+
 // Key is any value which is comparable.
 // See http://golang.org/ref/spec#Comparison_operators for details.
 type Key interface{}
@@ -65,6 +67,11 @@ type LoadingCache interface {
 	// will continue to be returned by Get while the new value is loading.
 	// If Key does not exist, this function will block until the value is loaded.
 	Refresh(Key)
+
+	// RefreshIfModifiedAfter asynchronously reloads value for Key if the provided timestamp
+	// indicates the data was modified after the entry was last loaded. If the entry doesn't exist,
+	// it will synchronously load and block until the value is loaded.
+	RefreshIfModifiedAfter(Key, time.Time)
 }
 
 // LoaderFunc retrieves the value corresponding to given Key.

local.go

@@ -195,17 +195,17 @@ func (c *localCache) GetActive(k Key) (Value, error) {
 		return nil, err
 	}
 	en := c.cache.get(k, sum(k))
-	if en != nil && ! en.getInvalidated() {
+	if en != nil && !en.getInvalidated() {
 		return obj, nil
 	}
-	return nil, errors.New ("entry invalidated")
+	return nil, errors.New("entry invalidated")
 }
 
 // GetAllKeys returns all keys.
 func (c *localCache) GetAllKeys() []interface{} {
 	keys := make([]interface{}, 0, c.cache.len())
 	c.cache.walk(func(en *entry) {
-		if ! en.getInvalidated() {
+		if !en.getInvalidated() {
 			keys = append(keys, en.key)
 		}
 	})
@@ -216,7 +216,7 @@ func (c *localCache) GetAllKeys() []interface{} {
 func (c *localCache) GetAllValues() []interface{} {
 	values := make([]interface{}, 0, c.cache.len())
 	c.cache.walk(func(en *entry) {
-		if ! en.getInvalidated() {
+		if !en.getInvalidated() {
 			values = append(values, en.getValue())
 		}
 	})
@@ -227,7 +227,7 @@ func (c *localCache) GetAllValues() []interface{} {
 func (c *localCache) GetAll() map[interface{}]interface{} {
 	var values = make(map[interface{}]interface{}, c.cache.len())
 	c.cache.walk(func(en *entry) {
-		if ! en.getInvalidated() {
+		if !en.getInvalidated() {
 			values[en.key] = en.getValue()
 		}
 	})
@@ -253,6 +253,24 @@ func (c *localCache) Refresh(k Key) {
 	}
 }
 
+// RefreshIfModifiedAfter asynchronously reloads value for Key if the provided timestamp
+// indicates the data was modified after the entry was last loaded. If the entry doesn't exist,
+// it will synchronously load and block until the value is loaded.
+func (c *localCache) RefreshIfModifiedAfter(k Key, modifiedTime time.Time) {
+	if c.loader == nil {
+		return
+	}
+	en := c.cache.get(k, sum(k))
+	if en == nil {
+		c.load(k)
+	} else {
+		// Only refresh if the data was modified after the entry was last loaded
+		if modifiedTime.UnixNano() > en.getWriteTime() {
+			c.refreshAsync(en)
+		}
+	}
+}
+
 // Stats copies cache stats to t.
 func (c *localCache) Stats(t *Stats) {
 	c.stats.Snapshot(t)

local_test.go

@@ -395,6 +395,73 @@ func TestRefreshAterWrite(t *testing.T) {
 	}
 }
 
+func TestRefreshIfModifiedAfter(t *testing.T) {
+	loadCount := 0
+	loader := func(k Key) (Value, error) {
+		loadCount++
+		return loadCount, nil
+	}
+	wg := sync.WaitGroup{}
+	insFunc := func(Key, Value) {
+		wg.Done()
+	}
+	mockTime := newMockTime()
+	currentTime = mockTime.now
+	c := NewLoadingCache(loader, WithRefreshAfterWrite(1*time.Minute),
+		WithReloader(&syncReloader{loader}), withInsertionListener(insFunc))
+	defer c.Close()
+
+	key := "mykey"
+
+	// 1. Entry does not exist, should load synchronously.
+	wg.Add(1)
+	c.RefreshIfModifiedAfter(key, mockTime.now())
+	wg.Wait()
+
+	if loadCount != 1 {
+		t.Fatalf("expected loadCount to be 1 after initial load, got %d", loadCount)
+	}
+
+	// 2. Entry exists, but modifiedTime is not after entry's write time. Should not refresh.
+	c.RefreshIfModifiedAfter(key, mockTime.now().Add(-1*time.Millisecond)) // modified time is before write time
+	// No wg.Add/Wait as it should be synchronous and do nothing.
+	if loadCount != 1 {
+		t.Fatalf("expected loadCount to be 1 when not modified, got %d", loadCount)
+	}
+
+	// 3. Entry exists, and modifiedTime is after entry's write time. Should refresh.
+	wg.Add(1)
+	c.RefreshIfModifiedAfter(key, mockTime.now().Add(1*time.Millisecond)) // modified time is after write time
+	wg.Wait()
+	if loadCount != 2 {
+		t.Fatalf("expected loadCount to be 2 after refresh, got %d", loadCount)
+	}
+
+	// 4. Manually put new value, then refresh with old modifiedTime, should not refresh.
+	key2 := "mykey2"
+
+	wg.Add(1)
+	c.Put(key2, 1)
+	wg.Wait()
+	v, err := c.Get(key2)
+	if err != nil || v.(int) != 1 {
+		t.Fatalf("unexpected get: %v %v", v, err)
+	}
+
+	c.RefreshIfModifiedAfter(key2, mockTime.now()) // modified time is the same as write time
+	// No wg.Add/Wait as it should be synchronous and do nothing.
+	if loadCount != 2 {
+		t.Fatalf("expected loadCount to be 2 when not modified, got %d", loadCount)
+	}
+
+	wg.Add(1)
+	c.RefreshIfModifiedAfter(key, mockTime.now().Add(1*time.Millisecond)) // modified time is after write time
+	wg.Wait()
+	if loadCount != 3 {
+		t.Fatalf("expected loadCount to be 3 after refresh, got %d", loadCount)
+	}
+}
+
 func TestGetIfPresentExpired(t *testing.T) {
 	wg := sync.WaitGroup{}
 	insFunc := func(Key, Value) {