updted storage.pluggable class

Author: chillaq

splitio/client/factory.py

@@ -523,7 +523,7 @@ def _build_pluggable_factory(api_key, cfg):
     pluggable_adapter = cfg.get('storageWrapper')
     storage_prefix = cfg.get('storagePrefix')
     storages = {
-        'splits': PluggableSplitStorage(pluggable_adapter, storage_prefix),
+        'splits': PluggableSplitStorage(pluggable_adapter, storage_prefix, cfg['flagSetsFilter'] if cfg['flagSetsFilter'] is not None else []),
         'segments': PluggableSegmentStorage(pluggable_adapter, storage_prefix),
         'impressions': PluggableImpressionsStorage(pluggable_adapter, sdk_metadata, storage_prefix),
         'events': PluggableEventsStorage(pluggable_adapter, sdk_metadata, storage_prefix),

splitio/storage/pluggable.py

@@ -8,15 +8,16 @@
 from splitio.models.impressions import Impression
 from splitio.models.telemetry import MethodExceptions, MethodLatencies, TelemetryConfig, MAX_TAGS, get_latency_bucket_index
 from splitio.storage import SplitStorage, SegmentStorage, ImpressionStorage, EventStorage, TelemetryStorage
+from splitio.util.storage_helper import get_valid_flag_sets, combine_valid_flag_sets
 
 _LOGGER = logging.getLogger(__name__)
 
 class PluggableSplitStorage(SplitStorage):
-    """InMemory implementation of a split storage."""
+    """InMemory implementation of feature flag storage."""
 
-    _SPLIT_NAME_LENGTH = 12
+    _FEATURE_FLAG_NAME_LENGTH = 19
 
-    def __init__(self, pluggable_adapter, prefix=None):
+    def __init__(self, pluggable_adapter, prefix=None, config_flag_sets=[]):
         """
         Class constructor.
 
@@ -26,51 +27,78 @@ def __init__(self, pluggable_adapter, prefix=None):
         :type prefix: str
         """
         self._pluggable_adapter = pluggable_adapter
-        self._prefix = "SPLITIO.split.{split_name}"
+        self._config_flag_sets = config_flag_sets
+        self._prefix = "SPLITIO.split.{feature_flag_name}"
         self._traffic_type_prefix = "SPLITIO.trafficType.{traffic_type_name}"
-        self._split_till_prefix = "SPLITIO.splits.till"
+        self._feature_flag_till_prefix = "SPLITIO.splits.till"
+        self._feature_flag_set_prefix = 'SPLITIO.set.{flag_set}'
         if prefix is not None:
             self._prefix = prefix + "." + self._prefix
             self._traffic_type_prefix = prefix + "." + self._traffic_type_prefix
-            self._split_till_prefix = prefix + "." + self._split_till_prefix
+            self._feature_flag_till_prefix = prefix + "." + self._feature_flag_till_prefix
+            self._feature_flag_set_prefix = prefix + "." + self._feature_flag_till_prefix
 
-    def get(self, split_name):
+    def get(self, feature_flag_name):
         """
-        Retrieve a split.
+        Retrieve a feature flag.
 
-        :param split_name: Name of the feature to fetch.
-        :type split_name: str
+        :param feature_flag_name: Name of the feature to fetch.
+        :type feature_flag_name: str
 
         :rtype: splitio.models.splits.Split
         """
         try:
-            split = self._pluggable_adapter.get(self._prefix.format(split_name=split_name))
-            if not split:
+            feature_flag = self._pluggable_adapter.get(self._prefix.format(feature_flag_name=feature_flag_name))
+            if not feature_flag:
                 return None
-            return splits.from_raw(split)
+            return splits.from_raw(feature_flag)
         except Exception:
-            _LOGGER.error('Error getting split from storage')
+            _LOGGER.error('Error getting feature flag from storage')
             _LOGGER.debug('Error: ', exc_info=True)
             return None
 
-    def fetch_many(self, split_names):
+    def fetch_many(self, feature_flag_names):
         """
-        Retrieve splits.
+        Retrieve feature flags.
 
-        :param split_names: Names of the features to fetch.
-        :type split_name: list(str)
+        :param feature_flag_names: Names of the features to fetch.
+        :type feature_flag_name: list(str)
 
         :return: A dict with split objects parsed from queue.
         :rtype: dict(split_name, splitio.models.splits.Split)
         """
         try:
-            prefix_added = [self._prefix.format(split_name=split_name) for split_name in split_names]
-            return {split['name']: splits.from_raw(split) for split in self._pluggable_adapter.get_many(prefix_added)}
+            prefix_added = [self._prefix.format(feature_flag_name=feature_flag_name) for feature_flag_name in feature_flag_names]
+            return {feature_flag['name']: splits.from_raw(feature_flag) for feature_flag in self._pluggable_adapter.get_many(prefix_added)}
         except Exception:
-            _LOGGER.error('Error getting split from storage')
+            _LOGGER.error('Error getting feature flag from storage')
             _LOGGER.debug('Error: ', exc_info=True)
             return None
 
+    def get_feature_flags_by_sets(self, flag_sets):
+        """
+        Retrieve feature flags by flag set.
+
+        :param flag_set: Names of the flag set to fetch.
+        :type flag_set: str
+
+        :return: Feature flag names that are tagged with the flag set
+        :rtype: listt(str)
+        """
+        try:
+            sets_to_fetch = get_valid_flag_sets(flag_sets, self._config_flag_sets)
+            if sets_to_fetch == []:
+                return []
+
+            keys = [self._prefix(feature_flag_name) for feature_flag_name in sets_to_fetch]
+            result_sets = self._pluggable_adapter.get_many(keys)
+            return list(combine_valid_flag_sets(result_sets))
+        except Exception:
+            _LOGGER.error('Error fetching feature flag from storage')
+            _LOGGER.debug('Error: ', exc_info=True)
+            return None
+
+
     # TODO: To be added when producer mode is supported
 #    def put_many(self, splits, change_number):
 #        """
@@ -127,14 +155,14 @@ def update(self, to_add, to_delete, new_change_number):
 
     def get_change_number(self):
         """
-        Retrieve latest split change number.
+        Retrieve latest feature flag change number.
 
         :rtype: int
         """
         try:
-            return self._pluggable_adapter.get(self._split_till_prefix)
+            return self._pluggable_adapter.get(self._feature_flag_till_prefix)
         except Exception:
-            _LOGGER.error('Error getting change number in split storage')
+            _LOGGER.error('Error getting change number in feature flag storage')
             _LOGGER.debug('Error: ', exc_info=True)
             return None
 
@@ -156,35 +184,35 @@ def get_change_number(self):
 
     def get_split_names(self):
         """
-        Retrieve a list of all split names.
+        Retrieve a list of all feature flag names.
 
-        :return: List of split names.
+        :return: List of feature flag names.
         :rtype: list(str)
         """
         try:
-            return [split.name for split in self.get_all()]
+            return [feature_flag.name for feature_flag in self.get_all()]
         except Exception:
-            _LOGGER.error('Error getting split names from storage')
+            _LOGGER.error('Error getting feature flag names from storage')
             _LOGGER.debug('Error: ', exc_info=True)
             return None
 
     def get_all(self):
         """
-        Return all the splits.
+        Return all the feature flags.
 
-        :return: List of all the splits.
+        :return: List of all the feature flags.
         :rtype: list
         """
         try:
-            return [splits.from_raw(self._pluggable_adapter.get(key)) for key in self._pluggable_adapter.get_keys_by_prefix(self._prefix[:-self._SPLIT_NAME_LENGTH])]
+            return [splits.from_raw(self._pluggable_adapter.get(key)) for key in self._pluggable_adapter.get_keys_by_prefix(self._prefix[:-self._FEATURE_FLAG_NAME_LENGTH])]
         except Exception:
-            _LOGGER.error('Error getting split keys from storage')
+            _LOGGER.error('Error getting feature flag keys from storage')
             _LOGGER.debug('Error: ', exc_info=True)
             return None
 
     def traffic_type_exists(self, traffic_type_name):
         """
-        Return whether the traffic type exists in at least one split in cache.
+        Return whether the traffic type exists in at least one feature flag in cache.
 
         :param traffic_type_name: Traffic type to validate.
         :type traffic_type_name: str
@@ -195,7 +223,7 @@ def traffic_type_exists(self, traffic_type_name):
         try:
             return self._pluggable_adapter.get(self._traffic_type_prefix.format(traffic_type_name=traffic_type_name)) != None
         except Exception:
-            _LOGGER.error('Error getting split info from storage')
+            _LOGGER.error('Error getting traffic type info from storage')
             _LOGGER.debug('Error: ', exc_info=True)
             return None
 
@@ -264,21 +292,21 @@ def kill_locally(self, split_name, default_treatment, change_number):
 
     def get_all_splits(self):
         """
-        Return all the splits.
+        Return all the feature flags.
 
-        :return: List of all the splits.
+        :return: List of all the feature flags.
         :rtype: list
         """
         try:
             return self.get_all()
         except Exception:
-            _LOGGER.error('Error fetching splits from storage')
+            _LOGGER.error('Error fetching feature flags from storage')
             _LOGGER.debug('Error: ', exc_info=True)
             return None
 
     def is_valid_traffic_type(self, traffic_type_name):
         """
-        Return whether the traffic type exists in at least one split in cache.
+        Return whether the traffic type exists in at least one feature flag in cache.
 
         :param traffic_type_name: Traffic type to validate.
         :type traffic_type_name: str
@@ -289,7 +317,7 @@ def is_valid_traffic_type(self, traffic_type_name):
         try:
             return self.traffic_type_exists(traffic_type_name)
         except Exception:
-            _LOGGER.error('Error getting split info from storage')
+            _LOGGER.error('Error getting traffic type info from storage')
             _LOGGER.debug('Error: ', exc_info=True)
             return None
 

tests/storage/test_pluggable.py

@@ -138,9 +138,9 @@ def test_init(self):
                 prefix = 'myprefix.'
             else:
                 prefix = ''
-        assert(pluggable_split_storage._prefix == prefix + "SPLITIO.split.{split_name}")
+        assert(pluggable_split_storage._prefix == prefix + "SPLITIO.split.{feature_flag_name}")
         assert(pluggable_split_storage._traffic_type_prefix == prefix + "SPLITIO.trafficType.{traffic_type_name}")
-        assert(pluggable_split_storage._split_till_prefix == prefix + "SPLITIO.splits.till")
+        assert(pluggable_split_storage._feature_flag_till_prefix == prefix + "SPLITIO.splits.till")
 
     # TODO: To be added when producer mode is aupported
 #    def test_put_many(self):
@@ -163,10 +163,10 @@ def test_get(self):
             pluggable_split_storage = PluggableSplitStorage(self.mock_adapter, prefix=sprefix)
 
             split1 = splits.from_raw(splits_json['splitChange1_2']['splits'][0])
-            split_name = splits_json['splitChange1_2']['splits'][0]['name']
+            feature_flag_name = splits_json['splitChange1_2']['splits'][0]['name']
 
-            self.mock_adapter.set(pluggable_split_storage._prefix.format(split_name=split_name), split1.to_json())
-            assert(pluggable_split_storage.get(split_name).to_json() ==  splits.from_raw(splits_json['splitChange1_2']['splits'][0]).to_json())
+            self.mock_adapter.set(pluggable_split_storage._prefix.format(feature_flag_name=feature_flag_name), split1.to_json())
+            assert(pluggable_split_storage.get(feature_flag_name).to_json() ==  splits.from_raw(splits_json['splitChange1_2']['splits'][0]).to_json())
             assert(pluggable_split_storage.get('not_existing') == None)
 
     def test_fetch_many(self):
@@ -178,8 +178,8 @@ def test_fetch_many(self):
             split2_temp['name'] = 'another_split'
             split2 = splits.from_raw(split2_temp)
 
-            self.mock_adapter.set(pluggable_split_storage._prefix.format(split_name=split1.name), split1.to_json())
-            self.mock_adapter.set(pluggable_split_storage._prefix.format(split_name=split2.name), split2.to_json())
+            self.mock_adapter.set(pluggable_split_storage._prefix.format(feature_flag_name=split1.name), split1.to_json())
+            self.mock_adapter.set(pluggable_split_storage._prefix.format(feature_flag_name=split2.name), split2.to_json())
             fetched = pluggable_split_storage.fetch_many([split1.name, split2.name])
             assert(fetched[split1.name].to_json() == split1.to_json())
             assert(fetched[split2.name].to_json() == split2.to_json())
@@ -217,8 +217,8 @@ def test_get_split_names(self):
             split2_temp = splits_json['splitChange1_2']['splits'][0].copy()
             split2_temp['name'] = 'another_split'
             split2 = splits.from_raw(split2_temp)
-            self.mock_adapter.set(pluggable_split_storage._prefix.format(split_name=split1.name), split1.to_json())
-            self.mock_adapter.set(pluggable_split_storage._prefix.format(split_name=split2.name), split2.to_json())
+            self.mock_adapter.set(pluggable_split_storage._prefix.format(feature_flag_name=split1.name), split1.to_json())
+            self.mock_adapter.set(pluggable_split_storage._prefix.format(feature_flag_name=split2.name), split2.to_json())
             assert(pluggable_split_storage.get_split_names() == [split1.name, split2.name])
 
     def test_get_all(self):
@@ -230,8 +230,8 @@ def test_get_all(self):
             split2_temp['name'] = 'another_split'
             split2 = splits.from_raw(split2_temp)
 
-            self.mock_adapter.set(pluggable_split_storage._prefix.format(split_name=split1.name), split1.to_json())
-            self.mock_adapter.set(pluggable_split_storage._prefix.format(split_name=split2.name), split2.to_json())
+            self.mock_adapter.set(pluggable_split_storage._prefix.format(feature_flag_name=split1.name), split1.to_json())
+            self.mock_adapter.set(pluggable_split_storage._prefix.format(feature_flag_name=split2.name), split2.to_json())
             all_splits = pluggable_split_storage.get_all()
             assert([all_splits[0].to_json(), all_splits[1].to_json()] == [split1.to_json(), split2.to_json()])