Split the endpoints cache and default cache (namespace and service) so that relation operations are independent and unblocking. Increase the size of the cache to 2048 accommodate large namespaces. (#249)

Author: runakash

pkg/cloudmap/cache.go

@@ -11,11 +11,10 @@ import (
 )
 
 const (
-	nsKey           = "ns-map"
-	svcKeyPrefix    = "svc-map"
-	endptsKeyPrefix = "endpts"
+	nsKey        = "ns-map"
+	svcKeyPrefix = "svc-map"
 
-	defaultCacheSize = 1024
+	defaultCacheSize = 2048
 	defaultNsTTL     = 10 * time.Second
 	defaultSvcTTL    = 10 * time.Second
 	defaultEndptTTL  = 5 * time.Second
@@ -34,9 +33,10 @@ type ServiceDiscoveryClientCache interface {
 }
 
 type sdCache struct {
-	log    common.Logger
-	cache  *cache.LRUExpireCache
-	config *SdCacheConfig
+	log            common.Logger
+	defaultCache   *cache.LRUExpireCache
+	endpointsCache *cache.LRUExpireCache
+	config         *SdCacheConfig
 }
 
 type SdCacheConfig struct {
@@ -47,9 +47,10 @@ type SdCacheConfig struct {
 
 func NewServiceDiscoveryClientCache(cacheConfig *SdCacheConfig) ServiceDiscoveryClientCache {
 	return &sdCache{
-		log:    common.NewLogger("cloudmap"),
-		cache:  cache.NewLRUExpireCache(defaultCacheSize),
-		config: cacheConfig,
+		log:            common.NewLogger("cloudmap"),
+		defaultCache:   cache.NewLRUExpireCache(defaultCacheSize),
+		endpointsCache: cache.NewLRUExpireCache(defaultCacheSize),
+		config:         cacheConfig,
 	}
 }
 
@@ -63,41 +64,41 @@ func NewDefaultServiceDiscoveryClientCache() ServiceDiscoveryClientCache {
 }
 
 func (sdCache *sdCache) GetNamespaceMap() (namespaceMap map[string]*model.Namespace, found bool) {
-	entry, exists := sdCache.cache.Get(nsKey)
+	entry, exists := sdCache.defaultCache.Get(nsKey)
 	if !exists {
 		return nil, false
 	}
 
 	namespaceMap, ok := entry.(map[string]*model.Namespace)
 	if !ok {
 		sdCache.log.Error(errors.New("failed to retrieve namespaceMap from cache"), "")
-		sdCache.cache.Remove(nsKey)
+		sdCache.defaultCache.Remove(nsKey)
 		return nil, false
 	}
 
 	return namespaceMap, true
 }
 
 func (sdCache *sdCache) CacheNamespaceMap(namespaces map[string]*model.Namespace) {
-	sdCache.cache.Add(nsKey, namespaces, sdCache.config.NsTTL)
+	sdCache.defaultCache.Add(nsKey, namespaces, sdCache.config.NsTTL)
 }
 
 func (sdCache *sdCache) EvictNamespaceMap() {
-	sdCache.cache.Remove(nsKey)
+	sdCache.defaultCache.Remove(nsKey)
 }
 
 func (sdCache *sdCache) GetServiceIdMap(nsName string) (serviceIdMap map[string]string, found bool) {
 	key := sdCache.buildSvcKey(nsName)
-	entry, exists := sdCache.cache.Get(key)
+	entry, exists := sdCache.defaultCache.Get(key)
 	if !exists {
 		return nil, false
 	}
 
 	serviceIdMap, ok := entry.(map[string]string)
 	if !ok {
-		sdCache.log.Error(errors.New("failed to retrieve service IDs from cache"), "",
-			"nsName", nsName)
-		sdCache.cache.Remove(key)
+		err := fmt.Errorf("failed to retrieve service IDs from cache")
+		sdCache.log.Error(err, err.Error(), "namespace", nsName)
+		sdCache.defaultCache.Remove(key)
 		return nil, false
 	}
 
@@ -106,26 +107,26 @@ func (sdCache *sdCache) GetServiceIdMap(nsName string) (serviceIdMap map[string]
 
 func (sdCache *sdCache) CacheServiceIdMap(nsName string, serviceIdMap map[string]string) {
 	key := sdCache.buildSvcKey(nsName)
-	sdCache.cache.Add(key, serviceIdMap, sdCache.config.SvcTTL)
+	sdCache.defaultCache.Add(key, serviceIdMap, sdCache.config.SvcTTL)
 }
 
 func (sdCache *sdCache) EvictServiceIdMap(nsName string) {
 	key := sdCache.buildSvcKey(nsName)
-	sdCache.cache.Remove(key)
+	sdCache.defaultCache.Remove(key)
 }
 
 func (sdCache *sdCache) GetEndpoints(nsName string, svcName string) (endpts []*model.Endpoint, found bool) {
 	key := sdCache.buildEndptsKey(nsName, svcName)
-	entry, exists := sdCache.cache.Get(key)
+	entry, exists := sdCache.endpointsCache.Get(key)
 	if !exists {
 		return nil, false
 	}
 
 	endpts, ok := entry.([]*model.Endpoint)
 	if !ok {
-		sdCache.log.Error(errors.New("failed to retrieve endpoints from cache"), "",
-			"ns", "nsName", "svc", svcName)
-		sdCache.cache.Remove(key)
+		err := fmt.Errorf("failed to retrieve endpoints from cache")
+		sdCache.log.Error(err, err.Error(), "namespace", nsName, "service", svcName)
+		sdCache.endpointsCache.Remove(key)
 		return nil, false
 	}
 
@@ -134,18 +135,18 @@ func (sdCache *sdCache) GetEndpoints(nsName string, svcName string) (endpts []*m
 
 func (sdCache *sdCache) CacheEndpoints(nsName string, svcName string, endpts []*model.Endpoint) {
 	key := sdCache.buildEndptsKey(nsName, svcName)
-	sdCache.cache.Add(key, endpts, sdCache.config.EndptTTL)
+	sdCache.endpointsCache.Add(key, endpts, sdCache.config.EndptTTL)
 }
 
 func (sdCache *sdCache) EvictEndpoints(nsName string, svcName string) {
 	key := sdCache.buildEndptsKey(nsName, svcName)
-	sdCache.cache.Remove(key)
+	sdCache.endpointsCache.Remove(key)
 }
 
 func (sdCache *sdCache) buildSvcKey(nsName string) (cacheKey string) {
 	return fmt.Sprintf("%s:%s", svcKeyPrefix, nsName)
 }
 
 func (sdCache *sdCache) buildEndptsKey(nsName string, svcName string) string {
-	return fmt.Sprintf("%s:%s:%s", endptsKeyPrefix, nsName, svcName)
+	return fmt.Sprintf("%s:%s", nsName, svcName)
 }

pkg/cloudmap/cache_test.go

@@ -59,7 +59,7 @@ func TestServiceDiscoveryClientCacheGetNamespaceMap_NotFound(t *testing.T) {
 
 func TestServiceDiscoveryClientCacheGetNamespaceMap_Corrupt(t *testing.T) {
 	sdc := getCacheImpl(t)
-	sdc.cache.Add(nsKey, &model.Plan{}, time.Minute)
+	sdc.defaultCache.Add(nsKey, &model.Plan{}, time.Minute)
 
 	nsMap, found := sdc.GetNamespaceMap()
 	assert.False(t, found)
@@ -99,7 +99,7 @@ func TestServiceDiscoveryClientCacheGetServiceIdMap_NotFound(t *testing.T) {
 
 func TestServiceDiscoveryClientCacheGetServiceIdMap_Corrupt(t *testing.T) {
 	sdc := getCacheImpl(t)
-	sdc.cache.Add(sdc.buildSvcKey(test.HttpNsName), &model.Plan{}, time.Minute)
+	sdc.defaultCache.Add(sdc.buildSvcKey(test.HttpNsName), &model.Plan{}, time.Minute)
 
 	svcIdMap, found := sdc.GetServiceIdMap(test.HttpNsName)
 	assert.False(t, found)
@@ -137,7 +137,7 @@ func TestServiceDiscoveryClientCacheGetEndpoints_NotFound(t *testing.T) {
 
 func TestServiceDiscoveryClientCacheGetEndpoints_Corrupt(t *testing.T) {
 	sdc := getCacheImpl(t)
-	sdc.cache.Add(sdc.buildEndptsKey(test.HttpNsName, test.SvcName), &model.Plan{}, time.Minute)
+	sdc.defaultCache.Add(sdc.buildEndptsKey(test.HttpNsName, test.SvcName), &model.Plan{}, time.Minute)
 
 	endpts, found := sdc.GetEndpoints(test.HttpNsName, test.SvcName)
 	assert.False(t, found)
@@ -156,7 +156,8 @@ func TestServiceDiscoveryClientEvictEndpoints(t *testing.T) {
 
 func getCacheImpl(t *testing.T) sdCache {
 	return sdCache{
-		log:   common.NewLoggerWithLogr(testr.New(t)),
-		cache: cache.NewLRUExpireCache(defaultCacheSize),
+		log:            common.NewLoggerWithLogr(testr.New(t)),
+		defaultCache:   cache.NewLRUExpireCache(defaultCacheSize),
+		endpointsCache: cache.NewLRUExpireCache(defaultCacheSize),
 	}
 }