allegro · Glebvvss · Feb 9, 2022
@@ -123,6 +123,32 @@ func (c *BigCache) Get(key string) ([]byte, error) {
 	return shard.get(key, hashedKey)
 }

+// GetWithFallback reads entry for the key and if it is not exists
+// tries to call second argument callback function to resolve actual value,
+// after tries to save it as new cached value for the key and returns it as result.
+func (c *BigCache) GetWithFallback(key string, fallbackFn func() ([]byte, error)) ([]byte, error) {
+	entry, err := c.Get(key)
+	if err == nil {
+		return entry, nil
+	}
+
+	if err != ErrEntryNotFound {
+		return nil, err
+	}
+
+	entry, err = fallbackFn()
+	if err != nil {
+		return nil, err
+	}
+
+	err = c.Set(key, entry)
+	if err != nil {
+		return nil, err
+	}
+
+	return entry, nil
+}
+
 // GetWithInfo reads entry for the key with Response info.
 // It returns an ErrEntryNotFound when
 // no entry exists for the given key.

@@ -2,6 +2,7 @@ package bigcache

 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"math"
 	"math/rand"
@@ -28,6 +29,39 @@ func TestWriteAndGetOnCache(t *testing.T) {
 	assertEqual(t, value, cachedValue)
 }

+func TestGetWithFallbackOnCache(t *testing.T) {
+	t.Parallel()
+
+	// given
+	cache, _ := NewBigCache(DefaultConfig(5 * time.Second))
+	value := []byte("value")
+
+	// when
+	cachedValue, err := cache.GetWithFallback("key", func() ([]byte, error) {
+		return value, nil
+	})
+
+	// then
+	noError(t, err)
+	assertEqual(t, value, cachedValue)
+}
+
+func TestGetWithFallbackOnCacheWithError(t *testing.T) {
+	t.Parallel()
+
+	// given
+	cache, _ := NewBigCache(DefaultConfig(5 * time.Second))
+	errStub := errors.New("some error")
+
+	// when
+	_, err := cache.GetWithFallback("key", func() ([]byte, error) {
+		return nil, errStub
+	})
+
+	// then
+	assertEqual(t, errStub, err)
+}
+
 func TestAppendAndGetOnCache(t *testing.T) {
 	t.Parallel()


@@ -18,6 +18,18 @@ func Example() {
 	// Output: value
 }

+func Example_getWithFallback() {
+	cache, _ := bigcache.NewBigCache(bigcache.DefaultConfig(10 * time.Minute))
+
+	entry, _ := cache.GetWithFallback("my-unique-key", func() ([]byte, error) {
+		/* Some amount of code for resolving value... */
+		return []byte("value"), nil
+	})
+
+	fmt.Println(string(entry))
+	// Output: value
+}
+
 func Example_custom() {
 	// When cache load can be predicted in advance then it is better to use custom initialization
 	// because additional memory allocation can be avoided in that way.