Merge pull request #25 from configcat/sdk-improvements

Sdk improvements

Author: kp-cat

configcatclient/__init__.py

@@ -18,7 +18,9 @@ def create_client(sdk_key, data_governance=DataGovernance.Global):
 
 def create_client_with_auto_poll(sdk_key, poll_interval_seconds=60, max_init_wait_time_seconds=5,
                                  on_configuration_changed_callback=None, config_cache_class=None,
-                                 base_url=None, proxies=None, proxy_auth=None, data_governance=DataGovernance.Global):
+                                 base_url=None, proxies=None, proxy_auth=None, connect_timeout=10, read_timeout=30,
+                                 flag_overrides=None,
+                                 data_governance=DataGovernance.Global):
     """
     Create an instance of ConfigCatClient and setup Auto Poll mode with custom options
 
@@ -31,6 +33,10 @@ def create_client_with_auto_poll(sdk_key, poll_interval_seconds=60, max_init_wai
     :param base_url: You can set a base_url if you want to use a proxy server between your application and ConfigCat
     :param proxies: Proxy addresses. e.g. { 'https': 'your_proxy_ip:your_proxy_port' }
     :param proxy_auth: Proxy authentication. e.g. HTTPProxyAuth('username', 'password')
+    :param connect_timeout: The number of seconds to wait for the server to make the initial connection
+    (i.e. completing the TCP connection handshake). Default: 10 seconds.
+    :param read_timeout: The number of seconds to wait for the server to respond before giving up. Default: 30 seconds.
+    :param flag_overrides: An OverrideDataSource implementation used to override feature flags & settings.
     :param data_governance:
     Default: Global. Set this parameter to be in sync with the Data Governance preference on the Dashboard: \n
     https://app.configcat.com/organization/data-governance \n
@@ -46,13 +52,25 @@ def create_client_with_auto_poll(sdk_key, poll_interval_seconds=60, max_init_wai
     if max_init_wait_time_seconds < 0:
         max_init_wait_time_seconds = 0
 
-    return ConfigCatClient(sdk_key, poll_interval_seconds, max_init_wait_time_seconds,
-                           on_configuration_changed_callback, 0, config_cache_class, base_url, proxies, proxy_auth,
-                           data_governance)
+    return ConfigCatClient(sdk_key=sdk_key,
+                           poll_interval_seconds=poll_interval_seconds,
+                           max_init_wait_time_seconds=max_init_wait_time_seconds,
+                           on_configuration_changed_callback=on_configuration_changed_callback,
+                           cache_time_to_live_seconds=0,
+                           config_cache_class=config_cache_class,
+                           base_url=base_url,
+                           proxies=proxies,
+                           proxy_auth=proxy_auth,
+                           connect_timeout=connect_timeout,
+                           read_timeout=read_timeout,
+                           flag_overrides=flag_overrides,
+                           data_governance=data_governance)
 
 
 def create_client_with_lazy_load(sdk_key, cache_time_to_live_seconds=60, config_cache_class=None,
-                                 base_url=None, proxies=None, proxy_auth=None, data_governance=DataGovernance.Global):
+                                 base_url=None, proxies=None, proxy_auth=None, connect_timeout=10, read_timeout=30,
+                                 flag_overrides=None,
+                                 data_governance=DataGovernance.Global):
     """
     Create an instance of ConfigCatClient and setup Lazy Load mode with custom options
 
@@ -63,6 +81,10 @@ def create_client_with_lazy_load(sdk_key, cache_time_to_live_seconds=60, config_
     :param base_url: You can set a base_url if you want to use a proxy server between your application and ConfigCat
     :param proxies: Proxy addresses. e.g. { "https": "your_proxy_ip:your_proxy_port" }
     :param proxy_auth: Proxy authentication. e.g. HTTPProxyAuth('username', 'password')
+    :param connect_timeout: The number of seconds to wait for the server to make the initial connection
+    (i.e. completing the TCP connection handshake). Default: 10 seconds.
+    :param read_timeout: The number of seconds to wait for the server to respond before giving up. Default: 30 seconds.
+    :param flag_overrides: An OverrideDataSource implementation used to override feature flags & settings.
     :param data_governance:
     Default: Global. Set this parameter to be in sync with the Data Governance preference on the Dashboard: \n
     https://app.configcat.com/organization/data-governance \n
@@ -75,12 +97,25 @@ def create_client_with_lazy_load(sdk_key, cache_time_to_live_seconds=60, config_
     if cache_time_to_live_seconds < 1:
         cache_time_to_live_seconds = 1
 
-    return ConfigCatClient(sdk_key, 0, 0, None, cache_time_to_live_seconds, config_cache_class, base_url,
-                           proxies, proxy_auth, data_governance)
+    return ConfigCatClient(sdk_key=sdk_key,
+                           poll_interval_seconds=0,
+                           max_init_wait_time_seconds=0,
+                           on_configuration_changed_callback=None,
+                           cache_time_to_live_seconds=cache_time_to_live_seconds,
+                           config_cache_class=config_cache_class,
+                           base_url=base_url,
+                           proxies=proxies,
+                           proxy_auth=proxy_auth,
+                           connect_timeout=connect_timeout,
+                           read_timeout=read_timeout,
+                           flag_overrides=flag_overrides,
+                           data_governance=data_governance)
 
 
 def create_client_with_manual_poll(sdk_key, config_cache_class=None,
-                                   base_url=None, proxies=None, proxy_auth=None, data_governance=DataGovernance.Global):
+                                   base_url=None, proxies=None, proxy_auth=None, connect_timeout=10, read_timeout=30,
+                                   flag_overrides=None,
+                                   data_governance=DataGovernance.Global):
     """
     Create an instance of ConfigCatClient and setup Manual Poll mode with custom options
 
@@ -90,6 +125,10 @@ def create_client_with_manual_poll(sdk_key, config_cache_class=None,
     :param base_url: You can set a base_url if you want to use a proxy server between your application and ConfigCat
     :param proxies: Proxy addresses. e.g. { "https": "your_proxy_ip:your_proxy_port" }
     :param proxy_auth: Proxy authentication. e.g. HTTPProxyAuth('username', 'password')
+    :param connect_timeout: The number of seconds to wait for the server to make the initial connection
+    (i.e. completing the TCP connection handshake). Default: 10 seconds.
+    :param read_timeout: The number of seconds to wait for the server to respond before giving up. Default: 30 seconds.
+    :param flag_overrides: An OverrideDataSource implementation used to override feature flags & settings.
     :param data_governance:
     Default: Global. Set this parameter to be in sync with the Data Governance preference on the Dashboard: \n
     https://app.configcat.com/organization/data-governance \n
@@ -99,4 +138,16 @@ def create_client_with_manual_poll(sdk_key, config_cache_class=None,
     if sdk_key is None:
         raise ConfigCatClientException('SDK Key is required.')
 
-    return ConfigCatClient(sdk_key, 0, 0, None, 0, config_cache_class, base_url, proxies, proxy_auth, data_governance)
+    return ConfigCatClient(sdk_key=sdk_key,
+                           poll_interval_seconds=0,
+                           max_init_wait_time_seconds=0,
+                           on_configuration_changed_callback=None,
+                           cache_time_to_live_seconds=0,
+                           config_cache_class=config_cache_class,
+                           base_url=base_url,
+                           proxies=proxies,
+                           proxy_auth=proxy_auth,
+                           connect_timeout=connect_timeout,
+                           read_timeout=read_timeout,
+                           flag_overrides=flag_overrides,
+                           data_governance=data_governance)

configcatclient/autopollingcachepolicy.py

@@ -4,6 +4,7 @@
 import time
 from threading import Thread, Event
 from requests import HTTPError
+from requests import Timeout
 
 from .readwritelock import ReadWriteLock
 from .interfaces import CachePolicy
@@ -93,6 +94,9 @@ def force_refresh(self):
         except HTTPError as e:
             log.error('Double-check your SDK Key at https://app.configcat.com/sdkkey.'
                       ' Received unexpected response: %s' % str(e.response))
+        except Timeout:
+            log.exception('Request timed out. Timeout values: [connect: {}s, read: {}s]'.format(
+                self._config_fetcher.get_connect_timeout(), self._config_fetcher.get_read_timeout()))
         except Exception:
             log.exception(sys.exc_info()[0])
 

configcatclient/configcatclient.py

@@ -6,18 +6,21 @@
 from .configfetcher import ConfigFetcher
 from .configcache import InMemoryConfigCache
 from .datagovernance import DataGovernance
+from .overridedatasource import OverrideBehaviour
 from .rolloutevaluator import RolloutEvaluator
 import logging
 import sys
 import hashlib
 from collections import namedtuple
+import copy
 
 log = logging.getLogger(sys.modules[__name__].__name__)
 
 KeyValue = namedtuple('KeyValue', 'key value')
 
 
 class ConfigCatClient(object):
+    sdk_keys = []
 
     def __init__(self,
                  sdk_key,
@@ -29,37 +32,52 @@ def __init__(self,
                  base_url=None,
                  proxies=None,
                  proxy_auth=None,
+                 connect_timeout=10,
+                 read_timeout=30,
+                 flag_overrides=None,
                  data_governance=DataGovernance.Global):
 
         if sdk_key is None:
             raise ConfigCatClientException('SDK Key is required.')
 
+        if sdk_key in ConfigCatClient.sdk_keys:
+            log.warning('A ConfigCat Client is already initialized with sdk_key %s. '
+                        'We strongly recommend you to use the ConfigCat Client as '
+                        'a Singleton object in your application.' % sdk_key)
+        else:
+            ConfigCatClient.sdk_keys.append(sdk_key)
+
         self._sdk_key = sdk_key
+        self._override_data_source = flag_overrides
         self._rollout_evaluator = RolloutEvaluator()
 
         if config_cache_class:
             self._config_cache = config_cache_class()
         else:
             self._config_cache = InMemoryConfigCache()
 
-        if poll_interval_seconds > 0:
-            self._config_fetcher = ConfigFetcher(sdk_key, 'p', base_url, proxies, proxy_auth, data_governance)
-            self._cache_policy = AutoPollingCachePolicy(self._config_fetcher, self._config_cache,
-                                                        self.__get_cache_key(),
-                                                        poll_interval_seconds, max_init_wait_time_seconds,
-                                                        on_configuration_changed_callback)
-        elif cache_time_to_live_seconds > 0:
-            self._config_fetcher = ConfigFetcher(sdk_key, 'l', base_url, proxies, proxy_auth, data_governance)
-            self._cache_policy = LazyLoadingCachePolicy(self._config_fetcher, self._config_cache,
-                                                        self.__get_cache_key(),
-                                                        cache_time_to_live_seconds)
+        if self._override_data_source and self._override_data_source.get_behaviour() == OverrideBehaviour.LocalOnly:
+            self._config_fetcher = None
+            self._cache_policy = None
         else:
-            self._config_fetcher = ConfigFetcher(sdk_key, 'm', base_url, proxies, proxy_auth, data_governance)
-            self._cache_policy = ManualPollingCachePolicy(self._config_fetcher, self._config_cache,
-                                                          self.__get_cache_key())
+            if poll_interval_seconds > 0:
+                self._config_fetcher = ConfigFetcher(sdk_key, 'p', base_url, proxies, proxy_auth, connect_timeout, read_timeout, data_governance)
+                self._cache_policy = AutoPollingCachePolicy(self._config_fetcher, self._config_cache,
+                                                            self.__get_cache_key(),
+                                                            poll_interval_seconds, max_init_wait_time_seconds,
+                                                            on_configuration_changed_callback)
+            elif cache_time_to_live_seconds > 0:
+                self._config_fetcher = ConfigFetcher(sdk_key, 'l', base_url, proxies, proxy_auth, connect_timeout, read_timeout, data_governance)
+                self._cache_policy = LazyLoadingCachePolicy(self._config_fetcher, self._config_cache,
+                                                            self.__get_cache_key(),
+                                                            cache_time_to_live_seconds)
+            else:
+                self._config_fetcher = ConfigFetcher(sdk_key, 'm', base_url, proxies, proxy_auth, connect_timeout, read_timeout, data_governance)
+                self._cache_policy = ManualPollingCachePolicy(self._config_fetcher, self._config_cache,
+                                                              self.__get_cache_key())
 
     def get_value(self, key, default_value, user=None):
-        config = self._cache_policy.get()
+        config = self.__get_settings()
         if config is None:
             log.warning('Evaluating get_value(\'%s\') failed. Cache is empty. '
                         'Returning default_value in your get_value call: [%s].' %
@@ -70,7 +88,7 @@ def get_value(self, key, default_value, user=None):
         return value
 
     def get_all_keys(self):
-        config = self._cache_policy.get()
+        config = self.__get_settings()
         if config is None:
             return []
 
@@ -81,7 +99,7 @@ def get_all_keys(self):
         return list(feature_flags)
 
     def get_variation_id(self, key, default_variation_id, user=None):
-        config = self._cache_policy.get()
+        config = self.__get_settings()
         if config is None:
             log.warning('Evaluating get_variation_id(\'%s\') failed. Cache is empty. '
                         'Returning default_variation_id in your get_variation_id call: [%s].' %
@@ -102,7 +120,7 @@ def get_all_variation_ids(self, user=None):
         return variation_ids
 
     def get_key_and_value(self, variation_id):
-        config = self._cache_policy.get()
+        config = self.__get_settings()
         if config is None:
             log.warning('Evaluating get_key_and_value(\'%s\') failed. Cache is empty. '
                         'Returning None.' % variation_id)
@@ -131,11 +149,47 @@ def get_key_and_value(self, variation_id):
         log.error('Could not find the setting for the given variation_id: ' + variation_id)
         return None
 
+    def get_all_values(self, user=None):
+        keys = self.get_all_keys()
+        all_values = {}
+        for key in keys:
+            value = self.get_value(key, None, user)
+            if value is not None:
+                all_values[key] = value
+
+        return all_values
+
     def force_refresh(self):
-        self._cache_policy.force_refresh()
+        if self._cache_policy:
+            self._cache_policy.force_refresh()
 
     def stop(self):
-        self._cache_policy.stop()
+        if self._cache_policy:
+            self._cache_policy.stop()
+        ConfigCatClient.sdk_keys.remove(self._sdk_key)
+
+    def __get_settings(self):
+        if self._override_data_source:
+            behaviour = self._override_data_source.get_behaviour()
+
+            if behaviour == OverrideBehaviour.LocalOnly:
+                return self._override_data_source.get_overrides()
+            elif behaviour == OverrideBehaviour.RemoteOverLocal:
+                remote_settings = self._cache_policy.get()
+                local_settings = self._override_data_source.get_overrides()
+                result = copy.deepcopy(local_settings)
+                if FEATURE_FLAGS in remote_settings and FEATURE_FLAGS in local_settings:
+                    result[FEATURE_FLAGS].update(remote_settings[FEATURE_FLAGS])
+                return result
+            elif behaviour == OverrideBehaviour.LocalOverRemote:
+                remote_settings = self._cache_policy.get()
+                local_settings = self._override_data_source.get_overrides()
+                result = copy.deepcopy(remote_settings)
+                if FEATURE_FLAGS in remote_settings and FEATURE_FLAGS in local_settings:
+                    result[FEATURE_FLAGS].update(local_settings[FEATURE_FLAGS])
+                return result
+
+        return self._cache_policy.get()
 
     def __get_cache_key(self):
         return hashlib.sha1(('python_' + CONFIG_FILE_NAME + '_' + self._sdk_key).encode('utf-8'))

configcatclient/configfetcher.py

@@ -49,10 +49,12 @@ def is_not_modified(self):
 
 class ConfigFetcher(object):
     def __init__(self, sdk_key, mode, base_url=None, proxies=None, proxy_auth=None,
-                 data_governance=DataGovernance.Global):
+                 connect_timeout=10, read_timeout=30, data_governance=DataGovernance.Global):
         self._sdk_key = sdk_key
         self._proxies = proxies
         self._proxy_auth = proxy_auth
+        self._connect_timeout = connect_timeout
+        self._read_timeout = read_timeout
         self._etag = ''
         self._headers = {'User-Agent': 'ConfigCat-Python/' + mode + '-' + CONFIGCATCLIENT_VERSION,
                          'X-ConfigCat-UserAgent': 'ConfigCat-Python/' + mode + '-' + CONFIGCATCLIENT_VERSION,
@@ -67,6 +69,12 @@ def __init__(self, sdk_key, mode, base_url=None, proxies=None, proxy_auth=None,
             else:
                 self._base_url = BASE_URL_GLOBAL
 
+    def get_connect_timeout(self):
+        return self._connect_timeout
+
+    def get_read_timeout(self):
+        return self._read_timeout
+
     def get_configuration_json(self, force_fetch=False, retries=0):
         """
         :return: Returns the FetchResponse object contains configuration json Dictionary
@@ -78,7 +86,7 @@ def get_configuration_json(self, force_fetch=False, retries=0):
         else:
             headers['If-None-Match'] = None
 
-        response = requests.get(uri, headers=headers, timeout=(10, 30),
+        response = requests.get(uri, headers=headers, timeout=(self._connect_timeout, self._read_timeout),
                                 proxies=self._proxies, auth=self._proxy_auth)
         response.raise_for_status()
         etag = response.headers.get('Etag')

configcatclient/localdictionarydatasource.py

@@ -0,0 +1,14 @@
+from .constants import VALUE, FEATURE_FLAGS
+from .overridedatasource import OverrideDataSource
+
+
+class LocalDictionaryDataSource(OverrideDataSource):
+    def __init__(self, source, override_behaviour):
+        OverrideDataSource.__init__(self, override_behaviour=override_behaviour)
+        dictionary = {}
+        for key, value in source.items():
+            dictionary[key] = {VALUE: value}
+        self._settings = {FEATURE_FLAGS: dictionary}
+
+    def get_overrides(self):
+        return self._settings