can use feature store even if update processor not inited

If redis is initialized at start time (even if fetching flags from the service failed), allow the clients to use the values from redis.

Author: eplusminus

ldclient/client.py

@@ -154,10 +154,13 @@ def send_event(value, version=None):
                               'user': user, 'value': value, 'default': default, 'version': version})
 
         if not self.is_initialized():
-            log.warn("Feature Flag evaluation attempted before client has initialized! Returning default: "
-                     + str(default) + " for feature key: " + key)
-            send_event(default)
-            return default
+            if self._store.initialized:
+                log.warn("Feature Flag evaluation attempted before client has initialized - using last known values from feature store for feature key: " + key)
+            else:
+                log.warn("Feature Flag evaluation attempted before client has initialized! Feature store unavailable - returning default: "
+                         + str(default) + " for feature key: " + key)
+                send_event(default)
+                return default
 
         if user is None or user.get('key') is None:
             log.warn("Missing user or user key when evaluating Feature Flag key: " + key + ". Returning default.")
@@ -203,8 +206,11 @@ def all_flags(self, user):
             return None
 
         if not self.is_initialized():
-            log.warn("all_flags() called before client has finished initializing! Returning None")
-            return None
+            if self._store.initialized:
+                log.warn("all_flags() called before client has finished initializing! Using last known values from feature store")
+            else:
+                log.warn("all_flags() called before client has finished initializing! Feature store unavailable - returning None")
+                return None
 
         if user is None or user.get('key') is None:
             log.warn("User or user key is None when calling all_flags(). Returning None.")

ldclient/memoized_value.py

@@ -0,0 +1,26 @@
+'''
+Simple implementation of a thread-safe memoized value whose generator function will never be
+run more than once, and whose value can be overridden by explicit assignment.
+'''
+
+from threading import RLock
+
+class MemoizedValue(object):
+
+    def __init__(self, generator):
+        self.generator = generator
+        self.inited = False
+        self.value = None
+        self.lock = RLock()
+
+    def get(self):
+        with self.lock:
+            if not self.inited:
+                self.value = self.generator()
+                self.inited = True
+            return self.value
+
+    def set(self, value):
+        with self.lock:
+            self.value = value
+            self.inited = True

ldclient/redis_feature_store.py

@@ -6,8 +6,7 @@
 from ldclient import log
 from ldclient.expiringdict import ExpiringDict
 from ldclient.interfaces import FeatureStore
-
-INIT_KEY = "$initialized$"
+from ldclient.memoized_value import MemoizedValue
 
 
 class ForgetfulDict(dict):
@@ -27,6 +26,7 @@ def __init__(self,
         self._cache = ForgetfulDict() if expiration == 0 else ExpiringDict(max_len=capacity,
                                                                            max_age_seconds=expiration)
         self._pool = redis.ConnectionPool.from_url(url=url, max_connections=max_connections)
+        self._inited = MemoizedValue(lambda: self._query_init())
         log.info("Started RedisFeatureStore connected to URL: " + url + " using prefix: " + prefix)
 
     def init(self, features):
@@ -41,6 +41,7 @@ def init(self, features):
             self._cache[k] = f
         pipe.execute()
         log.info("Initialized RedisFeatureStore with " + str(len(features)) + " feature flags")
+        self._inited.set(True)
 
     def all(self, callback):
         r = redis.Redis(connection_pool=self._pool)
@@ -109,17 +110,11 @@ def delete(self, key, version):
 
     @property
     def initialized(self):
-        initialized = self._cache.get(INIT_KEY)
-        if initialized:
-            # reset ttl
-            self._cache[INIT_KEY] = True
-            return True
+        return self._inited.get()
 
+    def _query_init(self):
         r = redis.Redis(connection_pool=self._pool)
-        if r.exists(self._features_key):
-            self._cache[INIT_KEY] = True
-            return True
-        return False
+        return r.exists(self._features_key)
 
     def upsert(self, key, feature):
         r = redis.Redis(connection_pool=self._pool)