Merge pull request #2 from rocketlaunchr/ristretto

Add Ristretto as A caching Storage

Author: pjebs

README.md

@@ -67,6 +67,12 @@ var rs = red.NewRedisStore(&redis.Pool{
 An experimental (and untested) memcached driver is provided.
 It relies on Brad Fitzpatrick's [memcache driver](https://godoc.org/github.com/bradfitz/gomemcache/memcache).
 
+### Ristretto
+
+DGraph's [Ristretto](https://github.com/dgraph-io/ristretto) is a fast, fixed size, in-memory cache with a dual focus on throughput and hit ratio performance.
+
+The API is potentially still in flux so no backward compatibility guarantee is provided for this driver.
+
 ## Create a SlowRetrieve Function
 
 The package initially checks if data exists in the cache. If it doesn’t, then it elegantly fetches the data directly from the database by calling the `SlowRetrieve` function. It then saves the data into the cache so that next time it doesn’t have to refetch it from the database.
@@ -127,7 +133,7 @@ return results.([]Result) // Type assert in order to use
 
 ## Gob Register Errors
 
-The Redis storage driver stores the data in a [`gob`](https://golang.org/pkg/encoding/gob/) encoded form. You have to register with the gob package the data type returned by the `SlowRetrieve` function. It can be done inside a `func init()`. Alternatively, you can set the `GobRegister` option to true. This will slightly impact concurrency performance however.
+The Redis storage driver stores the data in a `gob` encoded form. You have to register with the [`gob`](https://golang.org/pkg/encoding/gob/) package the data type returned by the `SlowRetrieve` function. It can be done inside a `func init()`. Alternatively, you can set the `GobRegister` option to true. This will slightly impact concurrency performance however.
 
 ## Other useful packages
 

memcached/memcached.go

@@ -41,7 +41,7 @@ func (c *MemcachedStore) StorePointer() bool {
 }
 
 // Get retrieves a value from the cache. The key must be at most 250 bytes in length.
-func (c *MemcachedStore) Get(key string) (interface{}, bool, error) {
+func (c *MemcachedStore) Get(key string) (_ interface{}, found bool, _ error) {
 
 	item, err := c.client.Get(key)
 	if err != nil {

memory/memory.go

@@ -40,7 +40,7 @@ func (c *MemoryStore) StorePointer() bool {
 }
 
 // Get returns a value from the cache if the key exists.
-func (c *MemoryStore) Get(key string) (interface{}, bool, error) {
+func (c *MemoryStore) Get(key string) (_ interface{}, found bool, _ error) {
 	item, found := c.cache.Get(key)
 	return item, found, nil
 }

redis/redis.go

@@ -48,7 +48,7 @@ func (c *RedisConn) StorePointer() bool {
 }
 
 // Get returns a value from the cache if the key exists.
-func (c *RedisConn) Get(key string) (interface{}, bool, error) {
+func (c *RedisConn) Get(key string) (_ interface{}, found bool, _ error) {
 
 	val, err := redis.Bytes(c.conn.Do("GET", key))
 	if err != nil {

ristretto/ristretto.go

@@ -0,0 +1,89 @@
+package ristretto
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"github.com/dgraph-io/ristretto"
+	"github.com/rocketlaunchr/remember-go"
+)
+
+// ErrItemDropped signifies that the item to store was not inserted into the cache.
+//
+// See: https://godoc.org/github.com/dgraph-io/ristretto#Cache.Set
+var ErrItemDropped = errors.New("item dropped")
+
+// RistrettoStore is used to create an in-memory ristretto cache.
+//
+// See: https://godoc.org/github.com/dgraph-io/ristretto
+type RistrettoStore struct {
+	Cache *ristretto.Cache
+}
+
+// NewRistrettoStore creates an in-memory ristretto cache.
+//
+// See: https://godoc.org/github.com/dgraph-io/ristretto#Config
+func NewRistrettoStore(config *ristretto.Config) *RistrettoStore {
+	cache, err := ristretto.NewCache(config)
+	if err != nil {
+		panic(err)
+	}
+
+	return &RistrettoStore{
+		Cache: cache,
+	}
+}
+
+// Conn does nothing for this storage driver.
+func (r *RistrettoStore) Conn(ctx context.Context) (remember.Cacher, error) {
+	return r, nil
+}
+
+// StorePointer sets whether a storage driver requires itemToStore to be
+// stored as a pointer or as a concrete value.
+func (r *RistrettoStore) StorePointer() bool {
+	return false
+}
+
+// Get returns a value from the cache if the key exists.
+// It is possible for nil to be returned while found is also true.
+//
+// See: https://godoc.org/github.com/dgraph-io/ristretto#Cache.Get
+func (r *RistrettoStore) Get(key string) (_ interface{}, found bool, _ error) {
+	item, found := r.Cache.Get(key)
+	return item, found, nil
+}
+
+// Set sets a item into the cache for a particular key.
+// cost must be converted to a time.Duration despite being unrelated to time.
+//
+// See: https://godoc.org/github.com/dgraph-io/ristretto#Cache.Set
+func (r *RistrettoStore) Set(key string, cost time.Duration, itemToStore interface{}) error {
+	stored := r.Cache.Set(key, itemToStore, int64(cost))
+	if stored {
+		return nil
+	}
+	return ErrItemDropped
+}
+
+// Close returns the connection back to the pool for storage drivers that utilize a pool.
+// For this driver, it does nothing.
+func (r *RistrettoStore) Close() {}
+
+// Forget clears the value from the cache for the particular key.
+//
+// See: https://godoc.org/github.com/dgraph-io/ristretto#Cache.Del
+func (r *RistrettoStore) Forget(key string) error {
+	r.Cache.Del(key)
+	return nil
+}
+
+// ForgetAll clears all values from the cache.
+// Note that this is not an atomic operation.
+//
+// See: https://godoc.org/github.com/dgraph-io/ristretto#Cache.Clear
+func (r *RistrettoStore) ForgetAll() error {
+	r.Cache.Clear()
+	return nil
+}

ristretto/ristretto_test.go

@@ -0,0 +1,75 @@
+package ristretto_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	rist "github.com/dgraph-io/ristretto"
+	"github.com/rocketlaunchr/remember-go"
+	"github.com/rocketlaunchr/remember-go/ristretto"
+)
+
+var cfg = &rist.Config{
+	NumCounters: 1e7,     // number of keys to track frequency of (10M).
+	MaxCost:     1 << 30, // maximum cost of cache (1GB).
+	BufferItems: 64,      // number of keys per Get buffer.
+}
+
+func TestKeyBasicOperation(t *testing.T) {
+	ctx := context.Background()
+	var ms = ristretto.NewRistrettoStore(cfg)
+
+	key := "key"
+	exp := 10 * time.Minute
+
+	slowQuery := func(ctx context.Context) (interface{}, error) {
+		return "val", nil
+	}
+
+	actual, _, _ := remember.Cache(ctx, ms, key, exp, slowQuery)
+
+	expected := "val"
+
+	if actual.(string) != expected {
+		t.Errorf("wrong val: expected: %v actual: %v", expected, actual)
+	}
+}
+
+func TestFetchFromCacheAndDisableCache(t *testing.T) {
+	ctx := context.Background()
+	var ms = ristretto.NewRistrettoStore(cfg)
+
+	key := "key"
+	exp := 10 * time.Minute
+
+	slowQuery := func(ctx context.Context) (interface{}, error) {
+		return "val", nil
+	}
+
+	// warm up cache
+	remember.Cache(ctx, ms, key, exp, slowQuery)
+
+	// This time fetch from cache
+	actual, _, _ := remember.Cache(ctx, ms, key, exp, slowQuery)
+
+	expected := "val"
+
+	if actual.(string) != expected {
+		t.Errorf("wrong val: expected: %v actual: %v", expected, actual)
+	}
+
+	// Actual is now "val", Let's change it to "val2" and disable cache usage.
+
+	slowQuery = func(ctx context.Context) (interface{}, error) {
+		return "val2", nil
+	}
+
+	actual, _, _ = remember.Cache(ctx, ms, key, exp, slowQuery, remember.Options{DisableCacheUsage: true})
+
+	expected = "val2"
+
+	if actual.(string) != expected {
+		t.Errorf("wrong val: expected: %v actual: %v", expected, actual)
+	}
+}