Merge pull request #66 from hyperledger/cache-tagging

Cache utility needs namespace grouping and reset capability

Author: peterbroadhurst

pkg/cache/cache.go

@@ -18,6 +18,7 @@ package cache
 
 import (
 	"context"
+	"fmt"
 	"sync"
 	"time"
 
@@ -29,8 +30,9 @@ import (
 // Each cache instance has unique name and its own cache size and TTL configuration.
 type Manager interface {
 	// Get a cache by name, if a cache already exists with the same name, it will be returned as is without checking maxSize, ttl and enabled matches
-	GetCache(ctx context.Context, cacheName string, maxSize int64, ttl time.Duration, enabled bool) (CInterface, error)
-	ListCacheNames() []string
+	GetCache(ctx context.Context, namespace, name string, maxSize int64, ttl time.Duration, enabled bool) (CInterface, error)
+	ListCacheNames(namespace string) []string
+	ResetCaches(namespace string)
 	IsEnabled() bool
 }
 
@@ -53,11 +55,12 @@ type CInterface interface {
 }
 
 type CCache struct {
-	enabled  bool
-	ctx      context.Context
-	name     string
-	cache    *ccache.Cache
-	cacheTTL time.Duration
+	enabled   bool
+	ctx       context.Context
+	namespace string
+	name      string
+	cache     *ccache.Cache
+	cacheTTL  time.Duration
 }
 
 func (c *CCache) Set(key string, val interface{}) {
@@ -138,47 +141,64 @@ type cacheManager struct {
 	enabled          bool // global default, when set to true, each cache instance can have an override
 	ctx              context.Context
 	m                sync.Mutex
-	configuredCaches map[string]CInterface // Cache manager maintain a list of named configured CCache, the names are unique
+	configuredCaches map[string]*CCache // Cache manager maintain a list of named configured CCache, the names are unique
 }
 
-func (cm *cacheManager) GetCache(ctx context.Context, cacheName string, maxSize int64, ttl time.Duration, enabled bool) (CInterface, error) {
+func (cm *cacheManager) GetCache(ctx context.Context, namespace, name string, maxSize int64, ttl time.Duration, enabled bool) (CInterface, error) {
 	cm.m.Lock()
 	defer cm.m.Unlock()
-	cache, exists := cm.configuredCaches[cacheName]
+	fqName := fmt.Sprintf("%s:%s", namespace, name)
+	cache, exists := cm.configuredCaches[fqName]
 	enabledValue := enabled
 	if !cm.IsEnabled() {
 		// when cache manager is disabled, the enabled toggle doesn't make any difference
 		enabledValue = false
 	}
 	if !exists {
 		cache = &CCache{
-			ctx:      ctx,
-			name:     cacheName,
-			cache:    ccache.New(ccache.Configure().MaxSize(maxSize)),
-			cacheTTL: ttl,
-			enabled:  enabledValue,
+			ctx:       ctx,
+			namespace: namespace,
+			name:      name,
+			cache:     ccache.New(ccache.Configure().MaxSize(maxSize)),
+			cacheTTL:  ttl,
+			enabled:   enabledValue,
 		}
-		cm.configuredCaches[cacheName] = cache
+		cm.configuredCaches[fqName] = cache
 	}
 	return cache, nil
 }
 
-func (cm *cacheManager) ListCacheNames() []string {
+func (cm *cacheManager) ListCacheNames(namespace string) []string {
 	keys := make([]string, 0, len(cm.configuredCaches))
-	for k := range cm.configuredCaches {
-		keys = append(keys, k)
+	for k, c := range cm.configuredCaches {
+		if c.namespace == namespace {
+			keys = append(keys, k)
+		}
 	}
 	return keys
 }
 
+func (cm *cacheManager) ResetCaches(namespace string) {
+	cm.m.Lock()
+	defer cm.m.Unlock()
+	for k, c := range cm.configuredCaches {
+		if c.namespace == namespace {
+			// Clear the cache to free the memory immediately
+			c.cache.Clear()
+			// Remove it from the map, so the next call will generate a new one
+			delete(cm.configuredCaches, k)
+		}
+	}
+}
+
 func (cm *cacheManager) IsEnabled() bool {
 	return cm.enabled
 }
 
 func NewCacheManager(ctx context.Context, enabled bool) Manager {
 	cm := &cacheManager{
 		ctx:              ctx,
-		configuredCaches: map[string]CInterface{},
+		configuredCaches: map[string]*CCache{},
 		enabled:          enabled,
 	}
 	return cm

pkg/cache/cache_test.go

@@ -27,22 +27,22 @@ import (
 func TestGetCacheReturnsSameCacheForSameConfig(t *testing.T) {
 	ctx := context.Background()
 	cacheManager := NewCacheManager(ctx, true)
-	cache0, _ := cacheManager.GetCache(ctx, "cacheA", 85, time.Second, true)
-	cache1, _ := cacheManager.GetCache(ctx, "cacheA", 85, time.Second, true)
+	cache0, _ := cacheManager.GetCache(ctx, "ns1", "cacheA", 85, time.Second, true)
+	cache1, _ := cacheManager.GetCache(ctx, "ns1", "cacheA", 85, time.Second, true)
 
 	assert.Equal(t, cache0, cache1)
-	assert.Equal(t, []string{"cacheA"}, cacheManager.ListCacheNames())
+	assert.Equal(t, []string{"ns1:cacheA"}, cacheManager.ListCacheNames("ns1"))
 
-	cache2, _ := cacheManager.GetCache(ctx, "cacheB", 85, time.Second, true)
+	cache2, _ := cacheManager.GetCache(ctx, "ns1", "cacheB", 85, time.Second, true)
 	assert.NotEqual(t, cache0, cache2)
-	assert.Equal(t, 2, len(cacheManager.ListCacheNames()))
+	assert.Equal(t, 2, len(cacheManager.ListCacheNames("ns1")))
 }
 
 func TestTwoSeparateCacheWorksIndependently(t *testing.T) {
 	ctx := context.Background()
 	cacheManager := NewCacheManager(ctx, true)
-	cache0, _ := cacheManager.GetCache(ctx, "cacheA", 85, time.Second, true)
-	cache1, _ := cacheManager.GetCache(ctx, "cacheB", 85, time.Second, true)
+	cache0, _ := cacheManager.GetCache(ctx, "ns1", "cacheA", 85, time.Second, true)
+	cache1, _ := cacheManager.GetCache(ctx, "ns1", "cacheB", 85, time.Second, true)
 
 	cache0.SetInt("int0", 100)
 	assert.Equal(t, 100, cache0.GetInt("int0"))
@@ -66,29 +66,29 @@ func TestCacheEnablement(t *testing.T) {
 	var zero int64 = 0
 	// test global enablement set to false
 	disabledCacheManager := NewCacheManager(ctx, false)
-	cache0, _ := disabledCacheManager.GetCache(ctx, "cache0", 85, time.Second, false)
+	cache0, _ := disabledCacheManager.GetCache(ctx, "ns1", "cache0", 85, time.Second, false)
 	assert.Equal(t, false, cache0.IsEnabled())
 
 	cache0.SetInt64("int0", hundred)
 	assert.Equal(t, nil, cache0.Get("int0"))
 
 	// check individual cache cannot be turned on when the cache manager is disabled
-	cache1, _ := disabledCacheManager.GetCache(ctx, "cache1", 85, time.Second, true)
+	cache1, _ := disabledCacheManager.GetCache(ctx, "ns1", "cache1", 85, time.Second, true)
 	assert.Equal(t, false, cache1.IsEnabled())
 
 	// test global enablement set to true
 
 	enabledCacheManager := NewCacheManager(ctx, true)
 	// check individual cache can be turned off when the cache manager is enabled
-	cache0, _ = enabledCacheManager.GetCache(ctx, "cache0", 85, time.Second, false)
+	cache0, _ = enabledCacheManager.GetCache(ctx, "ns1", "cache0", 85, time.Second, false)
 	assert.Equal(t, false, cache0.IsEnabled())
 
 	cache0.SetInt64("int0", hundred)
 	assert.Equal(t, zero, cache0.GetInt64("int0"))
 	deleted := cache0.Delete("int0")
 	assert.False(t, deleted)
 
-	cache1, _ = enabledCacheManager.GetCache(ctx, "cache1", 85, time.Second, true)
+	cache1, _ = enabledCacheManager.GetCache(ctx, "ns1", "cache1", 85, time.Second, true)
 	assert.Equal(t, true, cache1.IsEnabled())
 
 	cache1.SetInt64("int0", hundred)
@@ -101,3 +101,28 @@ func TestUmmanagedCacheInstance(t *testing.T) {
 	uc1 := NewUmanagedCache(context.Background(), 100, 5*time.Minute)
 	assert.NotEqual(t, uc0, uc1)
 }
+
+func TestResetCachesForNamespace(t *testing.T) {
+	ctx := context.Background()
+	cacheManager := NewCacheManager(ctx, true)
+	cacheNS1, _ := cacheManager.GetCache(ctx, "ns1", "cache1", 85, time.Second, true)
+	cacheNS1.Set("key1", "value1")
+
+	cacheNS2, _ := cacheManager.GetCache(ctx, "ns2", "cache1", 85, time.Second, true)
+	cacheNS2.Set("key2", "value2")
+
+	cacheNS1_a, _ := cacheManager.GetCache(ctx, "ns1", "cache1", 85, time.Second, true)
+	assert.Equal(t, cacheNS1, cacheNS1_a)
+	assert.Equal(t, "value1", cacheNS1_a.Get("key1"))
+
+	cacheManager.ResetCaches("ns1")
+
+	cacheNS2_a, _ := cacheManager.GetCache(ctx, "ns2", "cache1", 85, time.Second, true)
+	assert.Equal(t, cacheNS2, cacheNS2_a)
+	assert.Equal(t, "value2", cacheNS2_a.Get("key2"))
+
+	cacheNS1_b, _ := cacheManager.GetCache(ctx, "ns1", "cache1", 85, time.Second, true)
+	assert.NotEqual(t, cacheNS1, cacheNS1_b)
+	assert.Nil(t, cacheNS1_b.Get("key1"))
+
+}