refactor initialization part of optimizely client and polling manager.

Author: pawels-optimizely

examples/benchmark/main.go

@@ -44,10 +44,7 @@ func stressTest() {
 	notificationCenter := notification.NewNotificationCenter()
 	decisionService := decision.NewCompositeService(notificationCenter)
 
-	clientOptions := client.Options{
-		DecisionService: decisionService,
-	}
-	clientApp, err := optlyClient.ClientWithOptions(clientOptions)
+	clientApp, err := optlyClient.Client(client.DecisionService(decisionService))
 	if err != nil {
 		log.Print(err)
 	}

examples/main.go

@@ -64,8 +64,8 @@ func main() {
 
 	notificationCenter := notification.NewNotificationCenter()
 
-	app = optimizelyFactory.GetClient(
-		client.PollingConfigManager("4SLpaJA1r1pgE6T2CoMs9q", time.Second, nil),
+	app, _ = optimizelyFactory.Client(
+		client.PollingConfigManager("4SLpaJA1r1pgE6T2CoMs9q", time.Second, nil, notificationCenter),
 		client.CompositeDecisionService(notificationCenter),
 		client.BatchEventProcessor(event.DefaultBatchSize, event.DefaultEventQueueSize, event.DefaultEventFlushInterval),
 	)

optimizely/client/factory.go

@@ -29,13 +29,6 @@ import (
 	"github.com/optimizely/go-sdk/optimizely/utils"
 )
 
-// Options are used to create an instance of the OptimizelyClient with custom configuration
-type Options struct {
-	ProjectConfigManager optimizely.ProjectConfigManager
-	DecisionService      decision.Service
-	EventProcessor       event.Processor
-}
-
 // OptimizelyFactory is used to construct an instance of the OptimizelyClient
 type OptimizelyFactory struct {
 	SDKKey   string
@@ -45,26 +38,40 @@ type OptimizelyFactory struct {
 // OptionFunc is a type to a proper func
 type OptionFunc func(*OptimizelyClient, utils.ExecutionCtx)
 
-// GetClient gets client and sets some parameters
-func (f OptimizelyFactory) GetClient(clientOptions ...OptionFunc) *OptimizelyClient {
+// Client gets client and sets some parameters
+func (f OptimizelyFactory) Client(clientOptions ...OptionFunc) (*OptimizelyClient, error) {
+
 	executionCtx := utils.NewCancelableExecutionCtx()
+	notificationCenter := notification.NewNotificationCenter()
+
 	appClient := &OptimizelyClient{
-		executionCtx: executionCtx,
+		executionCtx:    executionCtx,
+		decisionService: decision.NewCompositeService(notificationCenter),
+		eventProcessor:  event.NewEventProcessor(executionCtx, event.DefaultBatchSize, event.DefaultEventQueueSize, event.DefaultEventFlushInterval),
 	}
+
 	for _, opt := range clientOptions {
 		opt(appClient, executionCtx)
 	}
-	return appClient
+
+	if f.SDKKey == "" && f.Datafile == nil && appClient.configManager == nil {
+		return nil, errors.New("unable to instantiate client: no project config manager, SDK key, or a Datafile provided")
+	}
+
+	if appClient.configManager == nil { // if it was not passed then assign here
+
+		appClient.configManager = config.NewPollingProjectConfigManager(executionCtx, f.SDKKey,
+			config.SetInitialDatafile(f.Datafile), config.SetPollingInterval(config.DefaultPollingInterval), config.SetNotification(notificationCenter))
+	}
+
+	return appClient, nil
 }
 
 // PollingConfigManager sets polling config manager on a client
-func PollingConfigManager(sdkKey string, pollingInterval time.Duration, dataFile []byte) OptionFunc {
+func PollingConfigManager(sdkKey string, pollingInterval time.Duration, initDataFile []byte, notificationCenter notification.Center) OptionFunc {
 	return func(f *OptimizelyClient, executionCtx utils.ExecutionCtx) {
-		options := config.PollingProjectConfigManagerOptions{
-			Datafile:        dataFile,
-			PollingInterval: pollingInterval,
-		}
-		f.configManager = config.NewPollingProjectConfigManagerWithOptions(f.executionCtx, sdkKey, options)
+		f.configManager = config.NewPollingProjectConfigManager(f.executionCtx, sdkKey, config.SetInitialDatafile(initDataFile),
+			config.SetPollingInterval(pollingInterval), config.SetNotification(notificationCenter))
 	}
 }
 
@@ -126,57 +133,12 @@ func (f OptimizelyFactory) StaticClient() (*OptimizelyClient, error) {
 		configManager = staticConfigManager
 	}
 
-	clientOptions := Options{
-		ProjectConfigManager: configManager,
-	}
-	client, err := f.ClientWithOptions(clientOptions)
-	return client, err
-}
-
-// ClientWithOptions returns a client initialized with the given configuration options
-func (f OptimizelyFactory) ClientWithOptions(clientOptions Options) (*OptimizelyClient, error) {
-
-	executionCtx := utils.NewCancelableExecutionCtx()
-	client := &OptimizelyClient{
-		executionCtx: executionCtx,
-	}
-
 	notificationCenter := notification.NewNotificationCenter()
 
-	switch {
-	case clientOptions.ProjectConfigManager != nil:
-		client.configManager = clientOptions.ProjectConfigManager
-	case f.SDKKey != "":
-		options := config.PollingProjectConfigManagerOptions{
-			Datafile: f.Datafile,
-		}
-		client.configManager = config.NewPollingProjectConfigManagerWithOptions(executionCtx, f.SDKKey, options)
-	case f.Datafile != nil:
-		staticConfigManager, _ := config.NewStaticProjectConfigManagerFromPayload(f.Datafile)
-		client.configManager = staticConfigManager
-	default:
-		return client, errors.New("unable to instantiate client: no project config manager, SDK key, or a Datafile provided")
-	}
-
-	if clientOptions.DecisionService != nil {
-		client.decisionService = clientOptions.DecisionService
-	} else {
-		client.decisionService = decision.NewCompositeService(notificationCenter)
-	}
-
-	if clientOptions.EventProcessor != nil {
-		client.eventProcessor = clientOptions.EventProcessor
-	} else {
-		client.eventProcessor = event.NewEventProcessor(executionCtx, event.DefaultBatchSize, event.DefaultEventQueueSize, event.DefaultEventFlushInterval)
-	}
-
-	return client, nil
-}
-
-// Client returns a client initialized with the defaults
-func (f OptimizelyFactory) Client() (*OptimizelyClient, error) {
-	// Creates a default, canceleable context
-	clientOptions := Options{}
-	client, err := f.ClientWithOptions(clientOptions)
-	return client, err
+	optlyClient, e := f.Client(
+		ConfigManager(configManager),
+		CompositeDecisionService(notificationCenter),
+		BatchEventProcessor(event.DefaultBatchSize, event.DefaultEventQueueSize, event.DefaultEventFlushInterval),
+	)
+	return optlyClient, e
 }

optimizely/client/factory_test.go

@@ -23,6 +23,7 @@ import (
 	"github.com/optimizely/go-sdk/optimizely/config"
 	"github.com/optimizely/go-sdk/optimizely/config/datafileprojectconfig"
 	"github.com/optimizely/go-sdk/optimizely/event"
+
 	"github.com/stretchr/testify/assert"
 )
 
@@ -48,41 +49,23 @@ func TestFactoryClientReturnsDefaultClient(t *testing.T) {
 func TestClientWithSDKKey(t *testing.T) {
 	factory := OptimizelyFactory{SDKKey: "1212"}
 
-	clientOptions := Options{}
-
-	client, err := factory.ClientWithOptions(clientOptions)
+	app, err := factory.Client()
 	assert.NoError(t, err)
-	assert.NotNil(t, client.configManager)
-	assert.NotNil(t, client.decisionService)
-	assert.NotNil(t, client.eventProcessor)
+	assert.NotNil(t, app.configManager)
+	assert.NotNil(t, app.decisionService)
+	assert.NotNil(t, app.eventProcessor)
 }
 
 func TestClientWithProjectConfigManagerInOptions(t *testing.T) {
 	factory := OptimizelyFactory{}
 	projectConfig := datafileprojectconfig.DatafileProjectConfig{}
 	configManager := config.NewStaticProjectConfigManager(projectConfig)
 
-	clientOptions := Options{ProjectConfigManager: configManager}
-
-	client, err := factory.ClientWithOptions(clientOptions)
-	assert.NoError(t, err)
-	assert.NotNil(t, client.configManager)
-	assert.NotNil(t, client.decisionService)
-	assert.NotNil(t, client.eventProcessor)
-}
-
-func TestClientWithNoDecisionServiceAndEventProcessorInOptions(t *testing.T) {
-	factory := OptimizelyFactory{}
-	projectConfig := datafileprojectconfig.DatafileProjectConfig{}
-	configManager := config.NewStaticProjectConfigManager(projectConfig)
-
-	clientOptions := Options{ProjectConfigManager: configManager}
-
-	client, err := factory.ClientWithOptions(clientOptions)
+	app, err := factory.Client(ConfigManager(configManager))
 	assert.NoError(t, err)
-	assert.NotNil(t, client.configManager)
-	assert.NotNil(t, client.decisionService)
-	assert.NotNil(t, client.eventProcessor)
+	assert.NotNil(t, app.configManager)
+	assert.NotNil(t, app.decisionService)
+	assert.NotNil(t, app.eventProcessor)
 }
 
 func TestClientWithDecisionServiceAndEventProcessorInOptions(t *testing.T) {
@@ -97,26 +80,8 @@ func TestClientWithDecisionServiceAndEventProcessorInOptions(t *testing.T) {
 		EventDispatcher: &MockDispatcher{},
 	}
 
-	clientOptions := Options{
-		ProjectConfigManager: configManager,
-		DecisionService:      decisionService,
-		EventProcessor:       processor,
-	}
-
-	client, err := factory.ClientWithOptions(clientOptions)
+	app, err := factory.Client(ConfigManager(configManager), DecisionService(decisionService), EventProcessor(processor))
 	assert.NoError(t, err)
-	assert.Equal(t, decisionService, client.decisionService)
-	assert.Equal(t, processor, client.eventProcessor)
-}
-
-func TestClientWithOptionsErrorCase(t *testing.T) {
-	// Error when no config manager, sdk key, or datafile is provided
-	factory := OptimizelyFactory{}
-	clientOptions := Options{}
-
-	_, err := factory.ClientWithOptions(clientOptions)
-	expectedErr := errors.New("unable to instantiate client: no project config manager, SDK key, or a Datafile provided")
-	if assert.Error(t, err) {
-		assert.Equal(t, err, expectedErr)
-	}
+	assert.Equal(t, decisionService, app.decisionService)
+	assert.Equal(t, processor, app.eventProcessor)
 }

optimizely/config/polling_manager.go

@@ -29,31 +29,67 @@ import (
 	"github.com/optimizely/go-sdk/optimizely/utils"
 )
 
-const defaultPollingInterval = 5 * time.Minute // default to 5 minutes for polling
+// DefaultPollingInterval sets default interval for polling manager
+const DefaultPollingInterval = 5 * time.Minute // default to 5 minutes for polling
 
 // DatafileURLTemplate is used to construct the endpoint for retrieving the datafile from the CDN
 const DatafileURLTemplate = "https://cdn.optimizely.com/datafiles/%s.json"
 
 var cmLogger = logging.GetLogger("PollingConfigManager")
 
-// PollingProjectConfigManagerOptions used to create an instance with custom configuration
-type PollingProjectConfigManagerOptions struct {
-	Datafile           []byte
-	PollingInterval    time.Duration
-	Requester          utils.Requester
-	NotificationCenter notification.Center
-}
-
 // PollingProjectConfigManager maintains a dynamic copy of the project config
 type PollingProjectConfigManager struct {
 	requester          utils.Requester
 	pollingInterval    time.Duration
-	projectConfig      optimizely.ProjectConfig
-	configLock         sync.RWMutex
-	err                error
 	notificationCenter notification.Center
+	initDatafile       []byte
+
+	configLock    sync.RWMutex
+	err           error
+	projectConfig optimizely.ProjectConfig
+	exeCtx        utils.ExecutionCtx // context used for execution control
+}
+
+// OptionFunc is a type to a proper func
+type OptionFunc func(*PollingProjectConfigManager)
+
+// SetDefaultRequester is an optional function, sets default requester based on a key.
+func SetDefaultRequester(sdkKey string) OptionFunc {
+	return func(p *PollingProjectConfigManager) {
+
+		url := fmt.Sprintf(DatafileURLTemplate, sdkKey)
+		requester := utils.NewHTTPRequester(url)
 
-	exeCtx utils.ExecutionCtx // context used for execution control
+		p.requester = requester
+	}
+}
+
+// SetRequester is an optional function, sets a passed requester
+func SetRequester(requester utils.Requester) OptionFunc {
+	return func(p *PollingProjectConfigManager) {
+		p.requester = requester
+	}
+}
+
+// SetPollingInterval is an optional function, sets a passed polling interval
+func SetPollingInterval(interval time.Duration) OptionFunc {
+	return func(p *PollingProjectConfigManager) {
+		p.pollingInterval = interval
+	}
+}
+
+// SetNotification is an optional function, sets a passed notification
+func SetNotification(notificationCenter notification.Center) OptionFunc {
+	return func(p *PollingProjectConfigManager) {
+		p.notificationCenter = notificationCenter
+	}
+}
+
+// SetInitialDatafile is an optional function, sets a passed datafile
+func SetInitialDatafile(datafile []byte) OptionFunc {
+	return func(p *PollingProjectConfigManager) {
+		p.initDatafile = datafile
+	}
 }
 
 // SyncConfig gets current datafile and updates projectConfig
@@ -98,12 +134,7 @@ func (cm *PollingProjectConfigManager) SyncConfig(datafile []byte) {
 	cm.configLock.Unlock()
 }
 
-func (cm *PollingProjectConfigManager) start(initialDatafile []byte, init bool) {
-
-	if init {
-		cm.SyncConfig(initialDatafile)
-		return
-	}
+func (cm *PollingProjectConfigManager) start() {
 
 	t := time.NewTicker(cm.pollingInterval)
 	for {
@@ -117,38 +148,24 @@ func (cm *PollingProjectConfigManager) start(initialDatafile []byte, init bool)
 	}
 }
 
-// NewPollingProjectConfigManagerWithOptions returns new instance of PollingProjectConfigManager with the given options
-func NewPollingProjectConfigManagerWithOptions(exeCtx utils.ExecutionCtx, sdkKey string, options PollingProjectConfigManagerOptions) *PollingProjectConfigManager {
+// NewPollingProjectConfigManager returns an instance of the polling config manager with the customized configuration
+func NewPollingProjectConfigManager(exeCtx utils.ExecutionCtx, sdkKey string, pollingMangerOptions ...OptionFunc) *PollingProjectConfigManager {
+	url := fmt.Sprintf(DatafileURLTemplate, sdkKey)
 
-	var requester utils.Requester
-	if options.Requester != nil {
-		requester = options.Requester
-	} else {
-		url := fmt.Sprintf(DatafileURLTemplate, sdkKey)
-		requester = utils.NewHTTPRequester(url)
-	}
+	pollingProjectConfigManager := PollingProjectConfigManager{exeCtx: exeCtx, pollingInterval: DefaultPollingInterval, requester: utils.NewHTTPRequester(url)}
 
-	pollingInterval := options.PollingInterval
-	if pollingInterval == 0 {
-		pollingInterval = defaultPollingInterval
+	for _, opt := range pollingMangerOptions {
+		opt(&pollingProjectConfigManager)
 	}
 
-	pollingProjectConfigManager := PollingProjectConfigManager{requester: requester, pollingInterval: pollingInterval, notificationCenter: options.NotificationCenter, exeCtx: exeCtx}
-
-	pollingProjectConfigManager.SyncConfig(options.Datafile) // initial poll
+	initDatafile := pollingProjectConfigManager.initDatafile
+	pollingProjectConfigManager.SyncConfig(initDatafile) // initial poll
 
 	cmLogger.Debug("Polling Config Manager Initiated")
-	go pollingProjectConfigManager.start([]byte{}, false)
+	go pollingProjectConfigManager.start()
 	return &pollingProjectConfigManager
 }
 
-// NewPollingProjectConfigManager returns an instance of the polling config manager with the default configuration
-func NewPollingProjectConfigManager(exeCtx utils.ExecutionCtx, sdkKey string) *PollingProjectConfigManager {
-	options := PollingProjectConfigManagerOptions{}
-	configManager := NewPollingProjectConfigManagerWithOptions(exeCtx, sdkKey, options)
-	return configManager
-}
-
 // GetConfig returns the project config
 func (cm *PollingProjectConfigManager) GetConfig() (optimizely.ProjectConfig, error) {
 	cm.configLock.RLock()