feat(lib): set Offline flag for ff client (thomaspoignant#1774)

* Feature to set Offline flag for ff client

Why: To optimize the ff client

How: Added a new function named SetOffline, and that takes boolean as a
parameter, and returns the updated value. It will start or stop the flag
updater daemon based on the input. The background_updater is also
updated to check for close() signals.

Tags: [ffclient, enhancement, feature]

* Added sync.Once

* fix: race condition

Signed-off-by: Thomas Poignant <[email protected]>

* fix data race

Signed-off-by: Thomas Poignant <[email protected]>

* remove unused checks

Signed-off-by: Thomas Poignant <[email protected]>

---------

Signed-off-by: Thomas Poignant <[email protected]>
Co-authored-by: Thomas Poignant <[email protected]>

Author: sarvsav

background_updater.go

@@ -35,7 +35,7 @@ func newBackgroundUpdater(pollingInterval time.Duration, useJitter bool) backgro
 	}
 }
 
-// close stop the ticker and close the channel.
+// close stops the ticker and closes the channel.
 func (bgu *backgroundUpdater) close() {
 	bgu.ticker.Stop()
 	close(bgu.updaterChan)

config.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"log"
+	"sync"
 	"time"
 
 	"github.com/thomaspoignant/go-feature-flag/retriever"
@@ -77,6 +78,9 @@ type Config struct {
 	// if in the evaluation context you have a field with the same name, it will override the common one.
 	// Default: nil
 	EvaluationContextEnrichment map[string]interface{}
+
+	// offlineMutex is a mutex to protect the Offline field.
+	offlineMutex *sync.RWMutex
 }
 
 // GetRetrievers returns a retriever.Retriever configure with the retriever available in the config.
@@ -96,3 +100,23 @@ func (c *Config) GetRetrievers() ([]retriever.Retriever, error) {
 	}
 	return retrievers, nil
 }
+
+// SetOffline set GO Feature Flag in offline mode.
+func (c *Config) SetOffline(control bool) {
+	if c.offlineMutex == nil {
+		c.offlineMutex = &sync.RWMutex{}
+	}
+	c.offlineMutex.Lock()
+	defer c.offlineMutex.Unlock()
+	c.Offline = control
+}
+
+// IsOffline return if the GO Feature Flag is in offline mode.
+func (c *Config) IsOffline() bool {
+	if c.offlineMutex == nil {
+		c.offlineMutex = &sync.RWMutex{}
+	}
+	c.offlineMutex.RLock()
+	defer c.offlineMutex.RUnlock()
+	return c.Offline
+}

feature_flag.go

@@ -59,7 +59,7 @@ type GoFeatureFlag struct {
 var ff *GoFeatureFlag
 var onceFF sync.Once
 
-// New creates a new go-feature-flag instance that retrieve the config from a YAML file
+// New creates a new go-feature-flag instances that retrieve the config from a YAML file
 // and return everything you need to manage your flags.
 func New(config Config) (*GoFeatureFlag, error) {
 	switch {
@@ -76,6 +76,10 @@ func New(config Config) (*GoFeatureFlag, error) {
 		// do nothing
 	}
 
+	if config.offlineMutex == nil {
+		config.offlineMutex = &sync.RWMutex{}
+	}
+
 	goFF := &GoFeatureFlag{
 		config: config,
 	}
@@ -145,9 +149,11 @@ func (g *GoFeatureFlag) startFlagUpdaterDaemon() {
 	for {
 		select {
 		case <-g.bgUpdater.ticker.C:
-			err := retrieveFlagsAndUpdateCache(g.config, g.cache, g.retrieverManager)
-			if err != nil {
-				fflog.Printf(g.config.Logger, "error while updating the cache: %v\n", err)
+			if !g.IsOffline() {
+				err := retrieveFlagsAndUpdateCache(g.config, g.cache, g.retrieverManager)
+				if err != nil {
+					fflog.Printf(g.config.Logger, "error while updating the cache: %v\n", err)
+				}
 			}
 		case <-g.bgUpdater.updaterChan:
 			return
@@ -231,12 +237,32 @@ func (g *GoFeatureFlag) GetCacheRefreshDate() time.Time {
 	return g.cache.GetLatestUpdateDate()
 }
 
+// SetOffline updates the config Offline parameter
+func (g *GoFeatureFlag) SetOffline(control bool) {
+	g.config.SetOffline(control)
+}
+
+// IsOffline allows knowing if the feature flag is in offline mode
+func (g *GoFeatureFlag) IsOffline() bool {
+	return g.config.IsOffline()
+}
+
+// SetOffline updates the config Offline parameter
+func SetOffline(control bool) {
+	ff.SetOffline(control)
+}
+
+// IsOffline allows knowing if the feature flag is in offline mode
+func IsOffline() bool {
+	return ff.IsOffline()
+}
+
 // GetCacheRefreshDate gives the date of the latest refresh of the cache
 func GetCacheRefreshDate() time.Time {
 	return ff.GetCacheRefreshDate()
 }
 
-// GetPollingInterval is the polling interval between 2 refresh of the cache
+// GetPollingInterval is the polling interval between 2 refreshes of the cache
 func (g *GoFeatureFlag) GetPollingInterval() int64 {
 	return g.config.PollingInterval.Milliseconds()
 }

feature_flag_test.go

@@ -2,22 +2,20 @@ package ffclient_test
 
 import (
 	"errors"
-	"github.com/thomaspoignant/go-feature-flag/ffcontext"
-	"github.com/thomaspoignant/go-feature-flag/testutils/initializableretriever"
 	"log"
 	"os"
 	"testing"
 	"time"
 
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/stretchr/testify/assert"
+	ffclient "github.com/thomaspoignant/go-feature-flag"
+	"github.com/thomaspoignant/go-feature-flag/ffcontext"
 	"github.com/thomaspoignant/go-feature-flag/internal/flag"
 	"github.com/thomaspoignant/go-feature-flag/retriever"
-
 	"github.com/thomaspoignant/go-feature-flag/retriever/fileretriever"
 	"github.com/thomaspoignant/go-feature-flag/retriever/s3retriever"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/stretchr/testify/assert"
-	ffclient "github.com/thomaspoignant/go-feature-flag"
+	"github.com/thomaspoignant/go-feature-flag/testutils/initializableretriever"
 	"github.com/thomaspoignant/go-feature-flag/testutils/mock"
 )
 
@@ -118,6 +116,11 @@ func TestValidUseCase(t *testing.T) {
 
 	allFlags := ffclient.AllFlagsState(user)
 	assert.Equal(t, 2, len(allFlags.GetFlags()))
+
+	ffclient.SetOffline(true)
+	assert.True(t, ffclient.IsOffline())
+	ffclient.SetOffline(false)
+	assert.False(t, ffclient.IsOffline())
 }
 
 func TestAllFlagsFromCache(t *testing.T) {
@@ -466,6 +469,25 @@ func TestGoFeatureFlag_GetCacheRefreshDate(t *testing.T) {
 	}
 }
 
+func TestGoFeatureFlag_SetOffline(t *testing.T) {
+	gffClient, err := ffclient.New(ffclient.Config{
+		PollingInterval: 1 * time.Second,
+		Retriever:       &fileretriever.Retriever{Path: "testdata/flag-config.yaml"},
+		Logger:          log.New(os.Stdout, "", 0),
+		Offline:         false,
+	})
+	assert.NoError(t, err)
+	defer gffClient.Close()
+
+	gffClient.SetOffline(true)
+	assert.True(t, gffClient.IsOffline())
+
+	time.Sleep(2 * time.Second)
+
+	gffClient.SetOffline(false)
+	assert.False(t, gffClient.IsOffline())
+}
+
 func Test_GetPollingInterval(t *testing.T) {
 	tests := []struct {
 		name            string