Merge pull request #64 from launchdarkly/dr/changeSdkKey

Allow SDK key/config to be changed after client has been initialized.

Author: drichelson

CHANGELOG.md

@@ -4,7 +4,7 @@ All notable changes to the LaunchDarkly Python SDK will be documented in this fi
 
 ## [3.0.3] - 2016-11-03
 ### Changed
-- Add backoff when retryign stream connection.
+- Add backoff when retrying stream connection.
 - More correct initialized state.
 
 ## [3.0.2] - 2016-10-26

CONTRIBUTING.md

@@ -18,8 +18,8 @@ Development information (for developing this module itself)
         pip install -r test-requirements.txt
 
 1. Run tests: You'll need redis running locally on its default port of 6379.
-
-        $ py.test testing
+1. If you want integration tests to run, set the ```LD_SDK_KEY``` environment variable to a valid production SDK Key.
+1. ```$ py.test testing```
 
 Developing with different python versions
 -----------------------------------------

README.md

@@ -16,10 +16,10 @@ Quick setup
 2. Configure the library with your sdk key:
 
         import ldclient
-        ldclient.sdk_key = "your sdk key"
 
 3. Get the client:
 
+        ldclient.set_sdk_key("your sdk key")
         client = ldclient.get()
 
 Your first feature flag
@@ -40,7 +40,7 @@ Twisted is supported for LDD mode only. To run in Twisted/LDD mode,
 1. Use this dependency:
 
 	```
-	ldclient-py[twisted]==3.0.1
+	ldclient-py[twisted]>=3.0.1
 	```
 2. Configure the client:
 

demo/demo.py

@@ -15,11 +15,10 @@
 root.addHandler(ch)
 
 if __name__ == '__main__':
-    ldclient.sdk_key = 'sdk_key'
     ldclient.start_wait = 10
-    client = ldclient.get()
+    ldclient.set_sdk_key('YOUR_SDK_KEY')
 
     user = {u'key': 'userKey'}
-    print(client.variation("update-app", user, False))
+    print(ldclient.get().variation("update-app", user, False))
 
-    client.close()
+    ldclient.get().close()

ldclient/__init__.py

@@ -12,38 +12,92 @@
 __BUILTINS__ = ["key", "ip", "country", "email",
                 "firstName", "lastName", "avatar", "name", "anonymous"]
 
-
 """Settings."""
-client = None
-sdk_key = None
 start_wait = 5
-config = Config()
 
-_lock = ReadWriteLock()
+__client = None
+__config = Config()
+__lock = ReadWriteLock()
+
+
+# 2 Use Cases:
+# 1. Initial setup: sets the config for the uninitialized client
+# 2. Allows on-the-fly changing of the config. When this function is called after the client has been initialized
+#    the client will get re-initialized with the new config. In order for this to work, the return value of
+#    ldclient.get() should never be assigned
+def set_config(config):
+    global __config
+    global __client
+    global __lock
+    try:
+        __lock.lock()
+        if __client:
+            log.info("Reinitializing LaunchDarkly Client " + version.VERSION + " with new config")
+            new_client = LDClient(config=config, start_wait=start_wait)
+            old_client = __client
+            __client = new_client
+            old_client.close()
+    finally:
+        __config = config
+        __lock.unlock()
+
+
+# 2 Use Cases:
+# 1. Initial setup: sets the sdk key for the uninitialized client
+# 2. Allows on-the-fly changing of the sdk key. When this function is called after the client has been initialized
+#    the client will get re-initialized with the new sdk key. In order for this to work, the return value of
+#    ldclient.get() should never be assigned
+def set_sdk_key(sdk_key):
+    global __config
+    global __client
+    global __lock
+    sdk_key_changed = False
+    try:
+        __lock.rlock()
+        if sdk_key is __config.sdk_key:
+            log.info("New sdk_key is the same as the existing one. doing nothing.")
+        else:
+            sdk_key_changed = True
+    finally:
+        __lock.runlock()
+
+    if sdk_key_changed:
+        try:
+            __lock.lock()
+            __config = __config.copy_with_new_sdk_key(new_sdk_key=sdk_key)
+            if __client:
+                log.info("Reinitializing LaunchDarkly Client " + version.VERSION + " with new sdk key")
+                new_client = LDClient(config=__config, start_wait=start_wait)
+                old_client = __client
+                __client = new_client
+                old_client.close()
+        finally:
+            __lock.unlock()
 
 
 def get():
+    global __config
+    global __client
+    global __lock
     try:
-        _lock.rlock()
-        if client:
-            return client
+        __lock.rlock()
+        if __client:
+            return __client
     finally:
-        _lock.runlock()
+        __lock.runlock()
 
     try:
-        global client
-        _lock.lock()
-        if not client:
+        __lock.lock()
+        if not __client:
             log.info("Initializing LaunchDarkly Client " + version.VERSION)
-            client = LDClient(sdk_key, config, start_wait)
-        return client
+            __client = LDClient(config=__config, start_wait=start_wait)
+        return __client
     finally:
-        _lock.unlock()
+        __lock.unlock()
 
 
 # Add a NullHandler for Python < 2.7 compatibility
 class NullHandler(logging.Handler):
-
     def emit(self, record):
         pass
 

ldclient/client.py

@@ -8,11 +8,9 @@
 import requests
 from builtins import object
 
-from ldclient.event_consumer import EventConsumerImpl
+from ldclient.config import Config as Config
 from ldclient.feature_requester import FeatureRequesterImpl
-from ldclient.feature_store import InMemoryFeatureStore
 from ldclient.flag import evaluate
-from ldclient.interfaces import FeatureStore
 from ldclient.polling import PollingUpdateProcessor
 from ldclient.streaming import StreamingUpdateProcessor
 from ldclient.util import check_uwsgi, log
@@ -27,80 +25,21 @@
 from cachecontrol import CacheControl
 from threading import Lock
 
-GET_LATEST_FEATURES_PATH = '/sdk/latest-flags'
-STREAM_FEATURES_PATH = '/flags'
-
-
-class Config(object):
-    def __init__(self,
-                 base_uri='https://app.launchdarkly.com',
-                 events_uri='https://events.launchdarkly.com',
-                 connect_timeout=10,
-                 read_timeout=15,
-                 events_upload_max_batch_size=100,
-                 events_max_pending=10000,
-                 stream_uri='https://stream.launchdarkly.com',
-                 stream=True,
-                 verify_ssl=True,
-                 defaults=None,
-                 events_enabled=True,
-                 update_processor_class=None,
-                 poll_interval=1,
-                 use_ldd=False,
-                 feature_store=InMemoryFeatureStore(),
-                 feature_requester_class=None,
-                 event_consumer_class=None,
-                 offline=False):
-        """
-
-        :param update_processor_class: A factory for an UpdateProcessor implementation taking the sdk key, config,
-                                       and FeatureStore implementation
-        :type update_processor_class: (str, Config, FeatureStore) -> UpdateProcessor
-        :param feature_store: A FeatureStore implementation
-        :type feature_store: FeatureStore
-        :param feature_requester_class: A factory for a FeatureRequester implementation taking the sdk key and config
-        :type feature_requester_class: (str, Config, FeatureStore) -> FeatureRequester
-        :param event_consumer_class: A factory for an EventConsumer implementation taking the event queue, sdk key, and config
-        :type event_consumer_class: (queue.Queue, str, Config) -> EventConsumer
-        """
-        if defaults is None:
-            defaults = {}
-
-        self.base_uri = base_uri.rstrip('\\')
-        self.get_latest_features_uri = self.base_uri + GET_LATEST_FEATURES_PATH
-        self.events_uri = events_uri.rstrip('\\') + '/bulk'
-        self.stream_uri = stream_uri.rstrip('\\') + STREAM_FEATURES_PATH
-        self.update_processor_class = update_processor_class
-        self.stream = stream
-        if poll_interval < 1:
-            poll_interval = 1
-        self.poll_interval = poll_interval
-        self.use_ldd = use_ldd
-        self.feature_store = InMemoryFeatureStore() if not feature_store else feature_store
-        self.event_consumer_class = EventConsumerImpl if not event_consumer_class else event_consumer_class
-        self.feature_requester_class = feature_requester_class
-        self.connect_timeout = connect_timeout
-        self.read_timeout = read_timeout
-        self.events_enabled = events_enabled
-        self.events_upload_max_batch_size = events_upload_max_batch_size
-        self.events_max_pending = events_max_pending
-        self.verify_ssl = verify_ssl
-        self.defaults = defaults
-        self.offline = offline
-
-    def get_default(self, key, default):
-        return default if key not in self.defaults else self.defaults[key]
-
-    @classmethod
-    def default(cls):
-        return cls()
-
 
 class LDClient(object):
-    def __init__(self, sdk_key, config=None, start_wait=5):
+    def __init__(self, sdk_key=None, config=None, start_wait=5):
         check_uwsgi()
-        self._sdk_key = sdk_key
-        self._config = config or Config.default()
+
+        if config is not None and config.sdk_key is not None and sdk_key is not None:
+            raise Exception("LaunchDarkly client init received both sdk_key and config with sdk_key. "
+                            "Only one of either is expected")
+
+        if sdk_key is not None:
+            log.warn("Deprecated sdk_key argument was passed to init. Use config object instead.")
+            self._config = Config(sdk_key=sdk_key)
+        else:
+            self._config = config or Config.default()
+
         self._session = CacheControl(requests.Session())
         self._queue = queue.Queue(self._config.events_max_pending)
         self._event_consumer = None
@@ -110,39 +49,36 @@ def __init__(self, sdk_key, config=None, start_wait=5):
         """ :type: FeatureStore """
 
         if self._config.offline:
-            self._config.events_enabled = False
             log.info("Started LaunchDarkly Client in offline mode")
             return
 
         if self._config.events_enabled:
-            self._event_consumer = self._config.event_consumer_class(
-                self._queue, self._sdk_key, self._config)
+            self._event_consumer = self._config.event_consumer_class(self._queue, self._config)
             self._event_consumer.start()
 
         if self._config.use_ldd:
             log.info("Started LaunchDarkly Client in LDD mode")
             return
 
         if self._config.feature_requester_class:
-            self._feature_requester = self._config.feature_requester_class(
-                sdk_key, self._config)
+            self._feature_requester = self._config.feature_requester_class(self._config)
         else:
-            self._feature_requester = FeatureRequesterImpl(sdk_key, self._config)
+            self._feature_requester = FeatureRequesterImpl(self._config)
         """ :type: FeatureRequester """
 
         update_processor_ready = threading.Event()
 
         if self._config.update_processor_class:
             log.info("Using user-specified update processor: " + str(self._config.update_processor_class))
             self._update_processor = self._config.update_processor_class(
-                sdk_key, self._config, self._feature_requester, self._store, update_processor_ready)
+                self._config, self._feature_requester, self._store, update_processor_ready)
         else:
             if self._config.stream:
                 self._update_processor = StreamingUpdateProcessor(
-                    sdk_key, self._config, self._feature_requester, self._store, update_processor_ready)
+                    self._config, self._feature_requester, self._store, update_processor_ready)
             else:
                 self._update_processor = PollingUpdateProcessor(
-                    sdk_key, self._config, self._feature_requester, self._store, update_processor_ready)
+                    self._config, self._feature_requester, self._store, update_processor_ready)
         """ :type: UpdateProcessor """
 
         self._update_processor.start()
@@ -155,9 +91,8 @@ def __init__(self, sdk_key, config=None, start_wait=5):
             log.warn("Initialization timeout exceeded for LaunchDarkly Client or an error occurred. "
                      "Feature Flags may not yet be available.")
 
-    @property
-    def sdk_key(self):
-        return self._sdk_key
+    def get_sdk_key(self):
+        return self._config.sdk_key
 
     def close(self):
         log.info("Closing LaunchDarkly client..")
@@ -285,9 +220,9 @@ def _evaluate_multi(self, user, flags):
         return {k: self._evaluate(v, user)[0] for k, v in flags.items() or {}}
 
     def secure_mode_hash(self, user):
-        if user.get('key') is None:
+        if user.get('key') is None or self._config.sdk_key is None:
             return ""
-        return hmac.new(self._sdk_key.encode(), user.get('key').encode(), hashlib.sha256).hexdigest()
+        return hmac.new(self._config.sdk_key.encode(), user.get('key').encode(), hashlib.sha256).hexdigest()
 
     @staticmethod
     def _sanitize_user(user):