added requester to the dispatcher, and providing with highly customizable client

Author: pawels-optimizely

examples/main.go

@@ -5,9 +5,13 @@ package main
 
 import (
 	"fmt"
+	"time"
+
 	"github.com/optimizely/go-sdk/optimizely/client"
 	"github.com/optimizely/go-sdk/optimizely/entities"
+	"github.com/optimizely/go-sdk/optimizely/event"
 	"github.com/optimizely/go-sdk/optimizely/logging"
+	"github.com/optimizely/go-sdk/optimizely/notification"
 )
 
 func main() {
@@ -55,4 +59,15 @@ func main() {
 	enabled, _ = app.IsFeatureEnabled("mutext_feat", user)
 	fmt.Printf("Is feature enabled? %v\n", enabled)
 	app.Close() //  user can close dispatcher
+
+	/************* Setting Polling Interval ********************/
+
+	notificationCenter := notification.NewNotificationCenter()
+
+	app = optimizelyFactory.GetClient(
+		client.ConfigManager("4SLpaJA1r1pgE6T2CoMs9q", time.Second, nil),
+		client.DecisionService(notificationCenter),
+		client.EventProcessor(event.DefaultBatchSize, event.DefaultEventQueueSize, event.DefaultEventFlushInterval),
+	)
+	app.Close()
 }

optimizely/client/factory.go

@@ -19,15 +19,14 @@ package client
 
 import (
 	"errors"
-	"github.com/optimizely/go-sdk/optimizely/utils"
-
-	"github.com/optimizely/go-sdk/optimizely/event"
-
-	"github.com/optimizely/go-sdk/optimizely/notification"
+	"time"
 
 	"github.com/optimizely/go-sdk/optimizely"
 	"github.com/optimizely/go-sdk/optimizely/config"
 	"github.com/optimizely/go-sdk/optimizely/decision"
+	"github.com/optimizely/go-sdk/optimizely/event"
+	"github.com/optimizely/go-sdk/optimizely/notification"
+	"github.com/optimizely/go-sdk/optimizely/utils"
 )
 
 // Options are used to create an instance of the OptimizelyClient with custom configuration
@@ -43,6 +42,47 @@ type OptimizelyFactory struct {
 	Datafile []byte
 }
 
+// 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 {
+	executionCtx := utils.NewCancelableExecutionCtx()
+	appClient := &OptimizelyClient{
+		isValid:      false,
+		executionCtx: executionCtx,
+	}
+	for _, opt := range clientOptions {
+		opt(appClient, executionCtx)
+	}
+	return appClient
+}
+
+// ConfigManager sets config manager on a client
+func ConfigManager(sdkKey string, pollingInterval time.Duration, dataFile []byte) OptionFunc {
+	return func(f *OptimizelyClient, executionCtx utils.ExecutionCtx) {
+		options := config.PollingProjectConfigManagerOptions{
+			Datafile:        dataFile,
+			PollingInterval: pollingInterval,
+		}
+		f.configManager = config.NewPollingProjectConfigManagerWithOptions(f.executionCtx, sdkKey, options)
+	}
+}
+
+// DecisionService sets decision service on a client
+func DecisionService(notificationCenter notification.Center) OptionFunc {
+	return func(f *OptimizelyClient, executionCtx utils.ExecutionCtx) {
+		f.decisionService = decision.NewCompositeService(notificationCenter)
+	}
+}
+
+// EventProcessor sets event processor on a client
+func EventProcessor(batchSize, queueSize int, flushInterval time.Duration) OptionFunc {
+	return func(f *OptimizelyClient, executionCtx utils.ExecutionCtx) {
+		f.eventProcessor = event.NewEventProcessor(executionCtx, batchSize, queueSize, flushInterval)
+	}
+}
+
 // StaticClient returns a client initialized with a static project config
 func (f OptimizelyFactory) StaticClient() (*OptimizelyClient, error) {
 	var configManager optimizely.ProjectConfigManager

optimizely/config/polling_manager.go

@@ -39,12 +39,12 @@ var cmLogger = logging.GetLogger("PollingConfigManager")
 type PollingProjectConfigManagerOptions struct {
 	Datafile        []byte
 	PollingInterval time.Duration
-	Requester       Requester
+	Requester       utils.Requester
 }
 
 // PollingProjectConfigManager maintains a dynamic copy of the project config
 type PollingProjectConfigManager struct {
-	requester       Requester
+	requester       utils.Requester
 	pollingInterval time.Duration
 	projectConfig   optimizely.ProjectConfig
 	configLock      sync.RWMutex
@@ -99,12 +99,12 @@ func (cm *PollingProjectConfigManager) activate(initialPayload []byte, init bool
 // NewPollingProjectConfigManagerWithOptions returns new instance of PollingProjectConfigManager with the given options
 func NewPollingProjectConfigManagerWithOptions(exeCtx utils.ExecutionCtx, sdkKey string, options PollingProjectConfigManagerOptions) *PollingProjectConfigManager {
 
-	var requester Requester
+	var requester utils.Requester
 	if options.Requester != nil {
 		requester = options.Requester
 	} else {
 		url := fmt.Sprintf(DatafileURLTemplate, sdkKey)
-		requester = NewHTTPRequester(url)
+		requester = utils.NewHTTPRequester(url)
 	}
 
 	pollingInterval := options.PollingInterval

optimizely/config/polling_manager_test.go

@@ -17,21 +17,21 @@
 package config
 
 import (
-	"github.com/optimizely/go-sdk/optimizely/utils"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-
 	"github.com/optimizely/go-sdk/optimizely/config/datafileprojectconfig"
+	"github.com/optimizely/go-sdk/optimizely/utils"
+
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 )
 
 type MockRequester struct {
-	Requester
+	utils.Requester
 	mock.Mock
 }
 
-func (m *MockRequester) Get(headers ...Header) (response []byte, code int, err error) {
+func (m *MockRequester) Get(headers ...utils.Header) (response []byte, code int, err error) {
 	args := m.Called(headers)
 	return args.Get(0).([]byte), args.Int(1), args.Error(2)
 }
@@ -40,7 +40,7 @@ func TestNewPollingProjectConfigManagerWithOptions(t *testing.T) {
 	mockDatafile := []byte("{ revision: \"42\" }")
 	projectConfig, _ := datafileprojectconfig.NewDatafileProjectConfig(mockDatafile)
 	mockRequester := new(MockRequester)
-	mockRequester.On("Get", []Header(nil)).Return(mockDatafile, 200, nil)
+	mockRequester.On("Get", []utils.Header(nil)).Return(mockDatafile, 200, nil)
 
 	// Test we fetch using requester
 	sdkKey := "test_sdk_key"
@@ -60,7 +60,7 @@ func TestNewPollingProjectConfigManagerWithOptions(t *testing.T) {
 func TestNewPollingProjectConfigManagerWithNull(t *testing.T) {
 	mockDatafile := []byte("NOT-VALID")
 	mockRequester := new(MockRequester)
-	mockRequester.On("Get", []Header(nil)).Return(mockDatafile, 200, nil)
+	mockRequester.On("Get", []utils.Header(nil)).Return(mockDatafile, 200, nil)
 
 	// Test we fetch using requester
 	sdkKey := "test_sdk_key"

optimizely/event/dispatcher.go

@@ -18,18 +18,15 @@
 package event
 
 import (
-	"bytes"
 	"context"
-	"encoding/json"
 	"fmt"
-	"net/http"
 	"sync"
 	"time"
 
 	"github.com/optimizely/go-sdk/optimizely/logging"
+	"github.com/optimizely/go-sdk/optimizely/utils"
 )
 
-const jsonContentType = "application/json"
 const maxRetries = 3
 const defaultQueueSize = 1000
 const sleepTime = 5 * time.Second
@@ -48,19 +45,20 @@ type HTTPEventDispatcher struct {
 // DispatchEvent dispatches event with callback
 func (*HTTPEventDispatcher) DispatchEvent(event LogEvent) (bool, error) {
 
-	jsonValue, _ := json.Marshal(event.Event)
-	resp, err := http.Post(event.EndPoint, jsonContentType, bytes.NewBuffer(jsonValue))
+	requester := utils.NewHTTPRequester(event.EndPoint)
+	_, code, err := requester.Post(event.Event)
+
 	// also check response codes
 	// resp.StatusCode == 400 is an error
 	var success bool
 	if err != nil {
 		dispatcherLogger.Error("http.Post failed:", err)
 		success = false
 	} else {
-		if resp.StatusCode == 204 {
+		if code == 204 {
 			success = true
 		} else {
-			dispatcherLogger.Error(fmt.Sprintf("http.Post invalid response %d", resp.StatusCode), nil)
+			dispatcherLogger.Error(fmt.Sprintf("http.Post invalid response %d", code), nil)
 			success = false
 		}
 	}
@@ -80,15 +78,15 @@ func (ed *QueueEventDispatcher) DispatchEvent(event LogEvent) (bool, error) {
 	go func() {
 		ed.flushEvents()
 	}()
-	return true,nil
+	return true, nil
 }
 
 // flush the events
 func (ed *QueueEventDispatcher) flushEvents() {
 
 	ed.eventFlushLock.Lock()
 
-	defer func(){
+	defer func() {
 		ed.eventFlushLock.Unlock()
 	}()
 
@@ -136,7 +134,7 @@ func (ed *QueueEventDispatcher) flushEvents() {
 
 // NewQueueEventDispatcher creates a dispatcher that queues in memory and then sends via go routine.
 func NewQueueEventDispatcher(ctx context.Context) Dispatcher {
-	dispatcher := &QueueEventDispatcher{eventQueue: NewInMemoryQueue(defaultQueueSize), dispatcher:&HTTPEventDispatcher{}}
+	dispatcher := &QueueEventDispatcher{eventQueue: NewInMemoryQueue(defaultQueueSize), dispatcher: &HTTPEventDispatcher{}}
 
 	go func() {
 		<-ctx.Done()

optimizely/event/processor_test.go

@@ -18,19 +18,14 @@
 package event
 
 import (
-	"context"
-	"github.com/optimizely/go-sdk/optimizely/utils"
-	"sync"
 	"testing"
 	"time"
 
+	"github.com/optimizely/go-sdk/optimizely/utils"
+
 	"github.com/stretchr/testify/assert"
 )
 
-func close(wg *sync.WaitGroup, cancelFn context.CancelFunc) {
-	cancelFn()
-	wg.Wait()
-}
 func TestDefaultEventProcessor_ProcessImpression(t *testing.T) {
 	exeCtx := utils.NewCancelableExecutionCtx()
 	processor := NewEventProcessor(exeCtx, 10, 100, 100)

optimizely/config/requester.go renamed to optimizely/utils/requester.go

@@ -14,30 +14,35 @@
  * limitations under the License.                                           *
  ***************************************************************************/
 
-// Package config //
-package config
+// Package utils //
+package utils
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
+	"io"
 	"io/ioutil"
-	"log"
 	"net/http"
 	"time"
 
 	"github.com/optimizely/go-sdk/optimizely/logging"
 
-	"github.com/json-iterator/go"
+	jsoniter "github.com/json-iterator/go"
 )
 
 const defaultTTL = 5 * time.Second
 
 var requesterLogger = logging.GetLogger("Requester")
+var json = jsoniter.ConfigCompatibleWithStandardLibrary
 
 // Requester is used to make outbound requests with
 type Requester interface {
 	Get(...Header) (response []byte, code int, err error)
 	GetObj(result interface{}, headers ...Header) error
+
+	Post(body interface{}, headers ...Header) (response []byte, code int, err error)
+	PostObj(body interface{}, result interface{}, headers ...Header) error
 }
 
 // Header element to be sent
@@ -92,24 +97,41 @@ func NewHTTPRequester(url string, params ...func(*HTTPRequester)) *HTTPRequester
 	return &res
 }
 
-// Get executes HTTP GET with uri and optional extra headers, returns body in []bytes
+// Get executes HTTP GET with url and optional extra headers, returns body in []bytes
 // url created as url+sdkKey.json
 func (r HTTPRequester) Get(headers ...Header) (response []byte, code int, err error) {
-	return r.Do("GET", headers)
+	return r.Do("GET", nil, headers)
 }
 
-// GetObj executes HTTP GET with uri and optional extra headers, returns filled object
+// GetObj executes HTTP GET with url and optional extra headers, returns filled object
 func (r HTTPRequester) GetObj(result interface{}, headers ...Header) error {
-	b, _, err := r.Do("GET", headers)
+	b, _, err := r.Do("GET", nil, headers)
+	if err != nil {
+		return err
+	}
+	return json.Unmarshal(b, result)
+}
+
+// Post executes HTTP POST with url, body and optional extra headers
+func (r HTTPRequester) Post(body interface{}, headers ...Header) (response []byte, code int, err error) {
+	b, err := json.Marshal(body)
+	if err != nil {
+		return nil, 400, err
+	}
+	return r.Do("POST", bytes.NewBuffer(b), headers)
+}
+
+// PostObj executes HTTP POST with uri, body and optional extra headers. Returns filled object
+func (r HTTPRequester) PostObj(body, result interface{}, headers ...Header) error {
+	b, _, err := r.Post(body, headers...)
 	if err != nil {
 		return err
 	}
-	var json = jsoniter.ConfigCompatibleWithStandardLibrary
 	return json.Unmarshal(b, result)
 }
 
 // Do executes request and returns response body for requested uri (sdkKey.json).
-func (r HTTPRequester) Do(method string, headers []Header) (response []byte, code int, err error) {
+func (r HTTPRequester) Do(method string, body io.Reader, headers []Header) (response []byte, code int, err error) {
 
 	single := func(request *http.Request) (response []byte, code int, e error) {
 		resp, doErr := r.client.Do(request)
@@ -137,8 +159,7 @@ func (r HTTPRequester) Do(method string, headers []Header) (response []byte, cod
 	}
 
 	requesterLogger.Debug(fmt.Sprintf("request %s", r.url))
-	req, err := http.NewRequest(method, r.url, nil)
-	log.Print(req)
+	req, err := http.NewRequest(method, r.url, body)
 	if err != nil {
 		requesterLogger.Error(fmt.Sprintf("failed to make request %s", r.url), err)
 		return nil, 0, err

optimizely/config/requester_test.go renamed to optimizely/utils/requester_test.go

@@ -14,7 +14,7 @@
  * limitations under the License.                                           *
  ***************************************************************************/
 
-package config
+package utils
 
 import (
 	"errors"