refac(context): Refactor to make execution context optional for components (#130)

Author: Michael Ng

examples/benchmark/main.go

@@ -42,7 +42,7 @@ func stressTest() {
 	// Creates a default, canceleable context
 	decisionService := decision.NewCompositeService("sdk_key")
 
-	clientApp, err := optlyClient.Client(client.DecisionService(decisionService))
+	clientApp, err := optlyClient.Client(client.WithDecisionService(decisionService))
 	if err != nil {
 		log.Print(err)
 	}

examples/main.go

@@ -62,9 +62,9 @@ func main() {
 	/************* Setting Polling Interval ********************/
 
 	optimizelyClient, _ = optimizelyFactory.Client(
-		client.PollingConfigManager(sdkKey, time.Second, nil),
-		client.CompositeDecisionService(sdkKey),
-		client.BatchEventProcessor(event.DefaultBatchSize, event.DefaultEventQueueSize, event.DefaultEventFlushInterval),
+		client.WithPollingConfigManager(sdkKey, time.Second, nil),
+		client.WithCompositeDecisionService(sdkKey),
+		client.WithBatchEventProcessor(event.DefaultBatchSize, event.DefaultEventQueueSize, event.DefaultEventFlushInterval),
 	)
 	optimizelyClient.Close()
 }

optimizely/client/client_test.go

@@ -24,35 +24,12 @@ import (
 	"github.com/optimizely/go-sdk/optimizely/decision"
 	"github.com/optimizely/go-sdk/optimizely/entities"
 	"github.com/optimizely/go-sdk/optimizely/event"
-	"github.com/optimizely/go-sdk/optimizely/notification"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 )
 
-type MockProjectConfigManager struct {
-	projectConfig optimizely.ProjectConfig
-	mock.Mock
-}
-
-func (p *MockProjectConfigManager) GetConfig() (optimizely.ProjectConfig, error) {
-	if p.projectConfig != nil {
-		return p.projectConfig, nil
-	}
-
-	args := p.Called()
-	return args.Get(0).(optimizely.ProjectConfig), args.Error(1)
-}
-
-func (p *MockProjectConfigManager) OnProjectConfigUpdate(callback func(notification.ProjectConfigUpdateNotification)) (int, error) {
-	return 0, nil
-}
-
-func (p *MockProjectConfigManager) RemoveOnProjectConfigUpdate(id int) error {
-	return nil
-}
-
 func ValidProjectConfigManager() *MockProjectConfigManager {
 	p := new(MockProjectConfigManager)
 	p.projectConfig = new(TestConfig)

optimizely/client/factory.go

@@ -35,7 +35,7 @@ type OptimizelyFactory struct {
 }
 
 // OptionFunc is a type to a proper func
-type OptionFunc func(*OptimizelyClient, utils.ExecutionCtx)
+type OptionFunc func(*OptimizelyClient)
 
 // Client gets client and sets some parameters
 func (f OptimizelyFactory) Client(clientOptions ...OptionFunc) (*OptimizelyClient, error) {
@@ -45,79 +45,94 @@ func (f OptimizelyFactory) Client(clientOptions ...OptionFunc) (*OptimizelyClien
 	appClient := &OptimizelyClient{
 		executionCtx:    executionCtx,
 		DecisionService: decision.NewCompositeService(f.SDKKey),
-		EventProcessor: event.NewEventProcessor(executionCtx, event.BatchSize(event.DefaultBatchSize),
+		EventProcessor: event.NewEventProcessor(event.BatchSize(event.DefaultBatchSize),
 			event.QueueSize(event.DefaultEventQueueSize), event.FlushInterval(event.DefaultEventFlushInterval)),
 	}
 
 	for _, opt := range clientOptions {
-		opt(appClient, executionCtx)
+		opt(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,
+		appClient.ConfigManager = config.NewPollingProjectConfigManager(f.SDKKey,
 			config.InitialDatafile(f.Datafile), config.PollingInterval(config.DefaultPollingInterval))
 	}
 
+	// Initialize the default services with the execution context
+	if pollingConfigManager, ok := appClient.ConfigManager.(*config.PollingProjectConfigManager); ok {
+		pollingConfigManager.Start(appClient.executionCtx)
+	}
+
+	if queueingProcessor, ok := appClient.EventProcessor.(*event.QueueingEventProcessor); ok {
+		queueingProcessor.Start(appClient.executionCtx)
+	}
+
 	return appClient, nil
 }
 
-// PollingConfigManager sets polling config manager on a client
-func PollingConfigManager(sdkKey string, pollingInterval time.Duration, initDataFile []byte) OptionFunc {
-	return func(f *OptimizelyClient, executionCtx utils.ExecutionCtx) {
-		f.ConfigManager = config.NewPollingProjectConfigManager(f.executionCtx, sdkKey, config.InitialDatafile(initDataFile),
+// WithPollingConfigManager sets polling config manager on a client
+func WithPollingConfigManager(sdkKey string, pollingInterval time.Duration, initDataFile []byte) OptionFunc {
+	return func(f *OptimizelyClient) {
+		f.ConfigManager = config.NewPollingProjectConfigManager(sdkKey, config.InitialDatafile(initDataFile),
 			config.PollingInterval(pollingInterval))
 	}
 }
 
-// PollingConfigManagerRequester sets polling config manager on a client
-func PollingConfigManagerRequester(requester utils.Requester, pollingInterval time.Duration, initDataFile []byte) OptionFunc {
-	return func(f *OptimizelyClient, executionCtx utils.ExecutionCtx) {
-		f.ConfigManager = config.NewPollingProjectConfigManager(f.executionCtx, "", config.InitialDatafile(initDataFile),
+// WithPollingConfigManagerRequester sets polling config manager on a client
+func WithPollingConfigManagerRequester(requester utils.Requester, pollingInterval time.Duration, initDataFile []byte) OptionFunc {
+	return func(f *OptimizelyClient) {
+		f.ConfigManager = config.NewPollingProjectConfigManager("", config.InitialDatafile(initDataFile),
 			config.PollingInterval(pollingInterval), config.Requester(requester))
 	}
 }
 
-// ConfigManager sets polling config manager on a client
-func ConfigManager(configManager optimizely.ProjectConfigManager) OptionFunc {
-	return func(f *OptimizelyClient, executionCtx utils.ExecutionCtx) {
+// WithConfigManager sets polling config manager on a client
+func WithConfigManager(configManager optimizely.ProjectConfigManager) OptionFunc {
+	return func(f *OptimizelyClient) {
 		f.ConfigManager = configManager
 	}
 }
 
-// CompositeDecisionService sets decision service on a client
-func CompositeDecisionService(sdkKey string) OptionFunc {
-	return func(f *OptimizelyClient, executionCtx utils.ExecutionCtx) {
+// WithCompositeDecisionService sets decision service on a client
+func WithCompositeDecisionService(sdkKey string) OptionFunc {
+	return func(f *OptimizelyClient) {
 		f.DecisionService = decision.NewCompositeService(sdkKey)
 	}
 }
 
-// DecisionService sets decision service on a client
-func DecisionService(decisionService decision.Service) OptionFunc {
-	return func(f *OptimizelyClient, executionCtx utils.ExecutionCtx) {
+// WithDecisionService sets decision service on a client
+func WithDecisionService(decisionService decision.Service) OptionFunc {
+	return func(f *OptimizelyClient) {
 		f.DecisionService = decisionService
 	}
 }
 
-// BatchEventProcessor sets event processor on a client
-func BatchEventProcessor(batchSize, queueSize int, flushInterval time.Duration) OptionFunc {
-	return func(f *OptimizelyClient, executionCtx utils.ExecutionCtx) {
-		f.EventProcessor = event.NewEventProcessor(executionCtx, event.BatchSize(batchSize),
+// WithBatchEventProcessor sets event processor on a client
+func WithBatchEventProcessor(batchSize, queueSize int, flushInterval time.Duration) OptionFunc {
+	return func(f *OptimizelyClient) {
+		f.EventProcessor = event.NewEventProcessor(event.BatchSize(batchSize),
 			event.QueueSize(queueSize), event.FlushInterval(flushInterval))
 	}
 }
 
-// EventProcessor sets event processor on a client
-func EventProcessor(eventProcessor event.Processor) OptionFunc {
-	return func(f *OptimizelyClient, executionCtx utils.ExecutionCtx) {
+// WithEventProcessor sets event processor on a client
+func WithEventProcessor(eventProcessor event.Processor) OptionFunc {
+	return func(f *OptimizelyClient) {
 		f.EventProcessor = eventProcessor
 	}
 }
 
+// WithExecutionContext allows user to pass in their own execution context to override the default one in the client
+func WithExecutionContext(executionContext utils.ExecutionCtx) OptionFunc {
+	return func(f *OptimizelyClient) {
+		f.executionCtx = executionContext
+	}
+}
+
 // StaticClient returns a client initialized with a static project config
 func (f OptimizelyFactory) StaticClient() (*OptimizelyClient, error) {
 	var configManager optimizely.ProjectConfigManager
@@ -142,9 +157,9 @@ func (f OptimizelyFactory) StaticClient() (*OptimizelyClient, error) {
 	}
 
 	optlyClient, e := f.Client(
-		ConfigManager(configManager),
-		CompositeDecisionService(f.SDKKey),
-		BatchEventProcessor(event.DefaultBatchSize, event.DefaultEventQueueSize, event.DefaultEventFlushInterval),
+		WithConfigManager(configManager),
+		WithCompositeDecisionService(f.SDKKey),
+		WithBatchEventProcessor(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/optimizely/go-sdk/optimizely/utils"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -61,7 +62,7 @@ func TestClientWithProjectConfigManagerInOptions(t *testing.T) {
 	projectConfig := datafileprojectconfig.DatafileProjectConfig{}
 	configManager := config.NewStaticProjectConfigManager(projectConfig)
 
-	optimizelyClient, err := factory.Client(ConfigManager(configManager))
+	optimizelyClient, err := factory.Client(WithConfigManager(configManager))
 	assert.NoError(t, err)
 	assert.NotNil(t, optimizelyClient.ConfigManager)
 	assert.NotNil(t, optimizelyClient.DecisionService)
@@ -80,8 +81,29 @@ func TestClientWithDecisionServiceAndEventProcessorInOptions(t *testing.T) {
 		EventDispatcher: &MockDispatcher{},
 	}
 
-	optimizelyClient, err := factory.Client(ConfigManager(configManager), DecisionService(decisionService), EventProcessor(processor))
+	optimizelyClient, err := factory.Client(WithConfigManager(configManager), WithDecisionService(decisionService), WithEventProcessor(processor))
 	assert.NoError(t, err)
 	assert.Equal(t, decisionService, optimizelyClient.DecisionService)
 	assert.Equal(t, processor, optimizelyClient.EventProcessor)
 }
+
+func TestClientWithCustomCtx(t *testing.T) {
+	factory := OptimizelyFactory{}
+	testExecutionCtx := utils.NewCancelableExecutionCtx()
+	mockConfigManager := new(MockProjectConfigManager)
+	client, err := factory.Client(
+		WithConfigManager(mockConfigManager),
+		WithExecutionContext(testExecutionCtx),
+	)
+	assert.NoError(t, err)
+	assert.Equal(t, client.executionCtx, testExecutionCtx)
+}
+
+func TestStaticClient(t *testing.T) {
+	factory := OptimizelyFactory{Datafile: []byte(`{"revision": "42"}`)}
+	optlyClient, err := factory.StaticClient()
+	assert.NoError(t, err)
+
+	parsedConfig, _ := optlyClient.ConfigManager.GetConfig()
+	assert.Equal(t, "42", parsedConfig.GetRevision())
+}

optimizely/client/fixtures_test.go

@@ -78,6 +78,28 @@ func (c *MockProjectConfig) GetBotFiltering() bool {
 	return false
 }
 
+type MockProjectConfigManager struct {
+	projectConfig optimizely.ProjectConfig
+	mock.Mock
+}
+
+func (p *MockProjectConfigManager) GetConfig() (optimizely.ProjectConfig, error) {
+	if p.projectConfig != nil {
+		return p.projectConfig, nil
+	}
+
+	args := p.Called()
+	return args.Get(0).(optimizely.ProjectConfig), args.Error(1)
+}
+
+func (p *MockProjectConfigManager) OnProjectConfigUpdate(callback func(notification.ProjectConfigUpdateNotification)) (int, error) {
+	return 0, nil
+}
+
+func (p *MockProjectConfigManager) RemoveOnProjectConfigUpdate(id int) error {
+	return nil
+}
+
 type MockDecisionService struct {
 	decision.Service
 	mock.Mock

optimizely/config/polling_manager.go

@@ -48,7 +48,6 @@ type PollingProjectConfigManager struct {
 	configLock    sync.RWMutex
 	err           error
 	projectConfig optimizely.ProjectConfig
-	exeCtx        utils.ExecutionCtx // context used for execution control
 }
 
 // OptionFunc is a type to a proper func
@@ -132,26 +131,28 @@ func (cm *PollingProjectConfigManager) SyncConfig(datafile []byte) {
 	}
 }
 
-func (cm *PollingProjectConfigManager) start() {
-
-	t := time.NewTicker(cm.pollingInterval)
-	for {
-		select {
-		case <-t.C:
-			cm.SyncConfig([]byte{})
-		case <-cm.exeCtx.GetContext().Done():
-			cmLogger.Debug("Polling Config Manager Stopped")
-			return
+// Start starts the polling
+func (cm *PollingProjectConfigManager) Start(exeCtx utils.ExecutionCtx) {
+	go func() {
+		cmLogger.Debug("Polling Config Manager Initiated")
+		t := time.NewTicker(cm.pollingInterval)
+		for {
+			select {
+			case <-t.C:
+				cm.SyncConfig([]byte{})
+			case <-exeCtx.GetContext().Done():
+				cmLogger.Debug("Polling Config Manager Stopped")
+				return
+			}
 		}
-	}
+	}()
 }
 
 // NewPollingProjectConfigManager returns an instance of the polling config manager with the customized configuration
-func NewPollingProjectConfigManager(exeCtx utils.ExecutionCtx, sdkKey string, pollingMangerOptions ...OptionFunc) *PollingProjectConfigManager {
+func NewPollingProjectConfigManager(sdkKey string, pollingMangerOptions ...OptionFunc) *PollingProjectConfigManager {
 	url := fmt.Sprintf(DatafileURLTemplate, sdkKey)
 
 	pollingProjectConfigManager := PollingProjectConfigManager{
-		exeCtx:             exeCtx,
 		notificationCenter: registry.GetNotificationCenter(sdkKey),
 		pollingInterval:    DefaultPollingInterval,
 		requester:          utils.NewHTTPRequester(url),
@@ -163,9 +164,6 @@ func NewPollingProjectConfigManager(exeCtx utils.ExecutionCtx, sdkKey string, po
 
 	initDatafile := pollingProjectConfigManager.initDatafile
 	pollingProjectConfigManager.SyncConfig(initDatafile) // initial poll
-
-	cmLogger.Debug("Polling Config Manager Initiated")
-	go pollingProjectConfigManager.start()
 	return &pollingProjectConfigManager
 }