Add bootstrap sdk key config. (#75)

* Remove support for default client in client middleware.
* Bootstrap SDK instances based on config.

Author: Mike Davis

pkg/api/middleware/cached.go

@@ -19,6 +19,7 @@ package middleware
 
 import (
 	"context"
+	"fmt"
 	"net/http"
 
 	"github.com/go-chi/chi"
@@ -49,18 +50,13 @@ type CachedOptlyMiddleware struct {
 // else the default OptlyClient will be used.
 func (ctx *CachedOptlyMiddleware) ClientCtx(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-
 		sdkKey := r.Header.Get(OptlySDKHeader)
-
-		GetLogger(r).Info().Msg("Fetching OptimizelyClient")
-		var err error
-		var optlyClient *optimizely.OptlyClient
 		if sdkKey == "" {
-			optlyClient, err = ctx.Cache.GetDefaultClient()
-		} else {
-			optlyClient, err = ctx.Cache.GetClient(sdkKey)
+			http.Error(w, fmt.Sprintf("Missing required %s header", OptlySDKHeader), http.StatusBadRequest)
+			return
 		}
 
+		optlyClient, err := ctx.Cache.GetClient(sdkKey)
 		if err != nil {
 			GetLogger(r).Error().Err(err).Msg("Initializing OptimizelyClient")
 			http.Error(w, "Failed to instantiate Optimizely", http.StatusInternalServerError)

pkg/api/middleware/cached_test.go

@@ -42,10 +42,6 @@ func (m *MockCache) GetClient(key string) (*optimizely.OptlyClient, error) {
 	return args.Get(0).(*optimizely.OptlyClient), args.Error(1)
 }
 
-func (m *MockCache) GetDefaultClient() (*optimizely.OptlyClient, error) {
-	return &defaultClient, nil
-}
-
 type OptlyMiddlewareTestSuite struct {
 	suite.Suite
 	mw *CachedOptlyMiddleware
@@ -68,15 +64,15 @@ func (suite *OptlyMiddlewareTestSuite) TestGetError() {
 	suite.Equal(http.StatusInternalServerError, rec.Code)
 }
 
-func (suite *OptlyMiddlewareTestSuite) TestGetDefault() {
+func (suite *OptlyMiddlewareTestSuite) TestGetClientMissingHeader() {
 	handler := suite.mw.ClientCtx(AssertOptlyClientHandler(suite, &defaultClient))
 	req := httptest.NewRequest("GET", "/", nil)
 	rec := httptest.NewRecorder()
 	handler.ServeHTTP(rec, req)
-	suite.Equal(http.StatusOK, rec.Code)
+	suite.Equal(http.StatusBadRequest, rec.Code)
 }
 
-func (suite *OptlyMiddlewareTestSuite) TestGetExpected() {
+func (suite *OptlyMiddlewareTestSuite) TestGetClient() {
 	handler := suite.mw.ClientCtx(AssertOptlyClientHandler(suite, &expectedClient))
 	req := httptest.NewRequest("GET", "/", nil)
 	req.Header.Add(OptlySDKHeader, "EXPECTED")

pkg/optimizely/cache.go

@@ -18,9 +18,9 @@
 package optimizely
 
 import (
-	"os"
-
 	"github.com/optimizely/go-sdk/pkg/config"
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/viper"
 
 	"github.com/optimizely/go-sdk/pkg/client"
 	"github.com/optimizely/go-sdk/pkg/decision"
@@ -30,26 +30,28 @@ import (
 // OptlyCache implements the Cache interface backed by a concurrent map.
 // The default OptlyClient lookup is based on supplied configuration via env variables.
 type OptlyCache struct {
-	defaultKey string
-	loader     func(string) (*OptlyClient, error)
-	optlyMap   cmap.ConcurrentMap
+	loader   func(string) (*OptlyClient, error)
+	optlyMap cmap.ConcurrentMap
 }
 
 // NewCache returns a new implementation of OptlyCache interface backed by a concurrent map.
 func NewCache() *OptlyCache {
-	// TODO replace with actual configuration component
-	// If Map lookup are expensive we can store a direct reference to the "default" client.
-	sdkKey := os.Getenv("SDK_KEY")
-	return &OptlyCache{
-		defaultKey: sdkKey,
-		optlyMap:   cmap.New(),
-		loader:     initOptlyClient,
+	cache := &OptlyCache{
+		optlyMap: cmap.New(),
+		loader:   initOptlyClient,
 	}
+
+	cache.init()
+	return cache
 }
 
-// GetDefaultClient returns a default OptlyClient where the SDK Key is sourced via server configuration.
-func (c *OptlyCache) GetDefaultClient() (*OptlyClient, error) {
-	return c.GetClient(c.defaultKey)
+func (c *OptlyCache) init() {
+	sdkKeys := viper.GetStringSlice("optimizely.sdkKeys")
+	for _, sdkKey := range sdkKeys {
+		if _, err := c.GetClient(sdkKey); err != nil {
+			log.Warn().Str("sdkKey", sdkKey).Msg("Failed to initialize Opimizely Client.")
+		}
+	}
 }
 
 // GetClient is used to fetch an instance of the OptlyClient when the SDK Key is explicitly supplied.
@@ -61,7 +63,7 @@ func (c *OptlyCache) GetClient(sdkKey string) (*OptlyClient, error) {
 
 	oc, err := c.loader(sdkKey)
 	if err != nil {
-		return &OptlyClient{}, err
+		return oc, err
 	}
 
 	set := c.optlyMap.SetIfAbsent(sdkKey, oc)
@@ -75,10 +77,14 @@ func (c *OptlyCache) GetClient(sdkKey string) (*OptlyClient, error) {
 }
 
 func initOptlyClient(sdkKey string) (*OptlyClient, error) {
-
-	optimizelyFactory := &client.OptimizelyFactory{}
+	log.Info().Str("sdkKey", sdkKey).Msg("Loading Optimizely instance")
 	configManager := config.NewPollingProjectConfigManager(sdkKey)
+	if _, err := configManager.GetConfig(); err != nil {
+		return &OptlyClient{}, err
+	}
+
 	forcedVariations := decision.NewMapExperimentOverridesStore()
+	optimizelyFactory := &client.OptimizelyFactory{}
 	optimizelyClient, err := optimizelyFactory.Client(
 		client.WithConfigManager(configManager),
 		client.WithExperimentOverrides(forcedVariations),

pkg/optimizely/cache_test.go

@@ -22,6 +22,7 @@ import (
 	"testing"
 
 	cmap "github.com/orcaman/concurrent-map"
+	"github.com/spf13/viper"
 	"github.com/stretchr/testify/suite"
 
 	"github.com/optimizely/sidedoor/pkg/optimizelytest"
@@ -36,21 +37,11 @@ type CacheTestSuite struct {
 
 func (suite *CacheTestSuite) SetupTest() {
 	suite.cache = &OptlyCache{
-		defaultKey: "default",
-		loader:     mockLoader,
-		optlyMap:   cmap.New(),
+		loader:   mockLoader,
+		optlyMap: cmap.New(),
 	}
 }
 
-func (suite *CacheTestSuite) TestGetDefault() {
-	optltyClient1, err1 := suite.cache.GetDefaultClient()
-	optltyClient2, err2 := suite.cache.GetDefaultClient()
-
-	suite.NoError(err1)
-	suite.NoError(err2)
-	suite.Equal(optltyClient1, optltyClient2)
-}
-
 func (suite *CacheTestSuite) TestGetCacheHit() {
 	optltyClient1, err1 := suite.cache.GetClient("one")
 	optltyClient2, err2 := suite.cache.GetClient("one")
@@ -74,6 +65,13 @@ func (suite *CacheTestSuite) TestGetError() {
 	suite.Error(err1)
 }
 
+func (suite *CacheTestSuite) TestInit() {
+	viper.SetDefault("optimizely.sdkKeys", "one")
+	suite.cache.init()
+	suite.True(suite.cache.optlyMap.Has("one"))
+	suite.False(suite.cache.optlyMap.Has("two"))
+}
+
 // In order for 'go test' to run this suite, we need to create
 // a normal test function and pass our suite to suite.Run
 func TestCacheTestSuite(t *testing.T) {

pkg/optimizely/interface.go

@@ -19,6 +19,5 @@ package optimizely
 
 // Cache defines a basic interface for retrieving an instance of the OptlyClient keyed off of the SDK Key
 type Cache interface {
-	GetDefaultClient() (*OptlyClient, error)
 	GetClient(sdkKey string) (*OptlyClient, error)
 }