refactor

Author: wbrowne

backend/instancemgmt/instance_manager.go

@@ -2,15 +2,14 @@ package instancemgmt
 
 import (
 	"context"
-	"fmt"
 	"reflect"
+	"sync"
 	"time"
 
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
-	gocache "github.com/patrickmn/go-cache"
 )
 
 var (
@@ -19,10 +18,7 @@ var (
 		Name:      "active_instances",
 		Help:      "The number of active plugin instances",
 	})
-	defaultDisposeTTL = 5 * time.Second
-
-	defaultInstanceTTL     = 24 * time.Hour
-	defaultInstanceCleanup = 48 * time.Hour
+	disposeTTL = 5 * time.Second
 )
 
 // Instance is a marker interface for an instance.
@@ -77,35 +73,21 @@ type InstanceProvider interface {
 
 // New create a new instance manager.
 func New(provider InstanceProvider) InstanceManager {
-	return NewWithOptions(provider, defaultInstanceTTL, defaultInstanceCleanup, defaultDisposeTTL)
-}
-
-func NewWithOptions(provider InstanceProvider, instanceTTL, instanceCleanup, disposeTTL time.Duration) InstanceManager {
 	if provider == nil {
 		panic("provider cannot be nil")
 	}
-	cache := gocache.New(instanceTTL, instanceCleanup)
-	cache.OnEvicted(func(_ string, i interface{}) {
-		ci := i.(CachedInstance)
-		if disposer, valid := ci.instance.(InstanceDisposer); valid {
-			time.AfterFunc(disposeTTL, func() {
-				disposer.Dispose()
-			})
-		}
-		activeInstances.Dec()
-	})
 
 	return &instanceManager{
 		provider: provider,
-		cache:    cache,
+		cache:    sync.Map{},
 		locker:   newLocker(),
 	}
 }
 
 type instanceManager struct {
 	locker   *locker
 	provider InstanceProvider
-	cache    *gocache.Cache
+	cache    sync.Map
 }
 
 func (im *instanceManager) Get(ctx context.Context, pluginContext backend.PluginContext) (Instance, error) {
@@ -114,8 +96,9 @@ func (im *instanceManager) Get(ctx context.Context, pluginContext backend.Plugin
 		return nil, err
 	}
 	// Double-checked locking for update/create criteria
-	strKey := fmt.Sprintf("%v", cacheKey)
-	item, ok := im.cache.Get(strKey)
+	im.locker.RLock(cacheKey)
+	item, ok := im.cache.Load(cacheKey)
+	im.locker.RUnlock(cacheKey)
 
 	if ok {
 		ci := item.(CachedInstance)
@@ -126,25 +109,32 @@ func (im *instanceManager) Get(ctx context.Context, pluginContext backend.Plugin
 		}
 	}
 
-	im.locker.Lock(strKey)
-	defer im.locker.Unlock(strKey)
+	im.locker.Lock(cacheKey)
+	defer im.locker.Unlock(cacheKey)
 
-	if item, ok := im.cache.Get(strKey); ok {
+	if item, ok := im.cache.Load(cacheKey); ok {
 		ci := item.(CachedInstance)
 		needsUpdate := im.provider.NeedsUpdate(ctx, pluginContext, ci)
 
 		if !needsUpdate {
 			return ci.instance, nil
 		}
 
-		im.cache.Delete(strKey)
+		if disposer, valid := ci.instance.(InstanceDisposer); valid {
+			time.AfterFunc(disposeTTL, func() {
+				disposer.Dispose()
+				activeInstances.Dec()
+			})
+		} else {
+			activeInstances.Dec()
+		}
 	}
 
 	instance, err := im.provider.NewInstance(ctx, pluginContext)
 	if err != nil {
 		return nil, err
 	}
-	im.cache.SetDefault(strKey, CachedInstance{
+	im.cache.Store(cacheKey, CachedInstance{
 		PluginContext: pluginContext,
 		instance:      instance,
 	})

backend/instancemgmt/intance_manager_ttl.go

@@ -0,0 +1,75 @@
+package instancemgmt
+
+import (
+	"context"
+	"fmt"
+
+	gocache "github.com/patrickmn/go-cache"
+
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
+)
+
+type instanceManagerWithTTL struct {
+	locker   *locker
+	provider InstanceProvider
+	cache    *gocache.Cache
+}
+
+func (im *instanceManagerWithTTL) Get(ctx context.Context, pluginContext backend.PluginContext) (Instance, error) {
+	providerKey, err := im.provider.GetKey(ctx, pluginContext)
+	if err != nil {
+		return nil, err
+	}
+	// Double-checked locking for update/create criteria
+	cacheKey := fmt.Sprintf("%v", providerKey)
+	item, ok := im.cache.Get(cacheKey)
+
+	if ok {
+		ci := item.(CachedInstance)
+		needsUpdate := im.provider.NeedsUpdate(ctx, pluginContext, ci)
+
+		if !needsUpdate {
+			return ci.instance, nil
+		}
+	}
+
+	im.locker.Lock(cacheKey)
+	defer im.locker.Unlock(cacheKey)
+
+	if item, ok := im.cache.Get(cacheKey); ok {
+		ci := item.(CachedInstance)
+		needsUpdate := im.provider.NeedsUpdate(ctx, pluginContext, ci)
+
+		if !needsUpdate {
+			return ci.instance, nil
+		}
+
+		im.cache.Delete(cacheKey)
+	}
+
+	instance, err := im.provider.NewInstance(ctx, pluginContext)
+	if err != nil {
+		return nil, err
+	}
+	im.cache.SetDefault(cacheKey, CachedInstance{
+		PluginContext: pluginContext,
+		instance:      instance,
+	})
+	activeInstances.Inc()
+
+	return instance, nil
+}
+
+func (im *instanceManagerWithTTL) Do(ctx context.Context, pluginContext backend.PluginContext, fn InstanceCallbackFunc) error {
+	if fn == nil {
+		panic("fn cannot be nil")
+	}
+
+	instance, err := im.Get(ctx, pluginContext)
+	if err != nil {
+		return err
+	}
+
+	callInstanceHandlerFunc(fn, instance)
+	return nil
+}