added flagset and flagsetfilter classes and updated other classes

Author: chillaq

splitio/client/client.py

@@ -429,8 +429,11 @@ def _get_feature_flag_names_by_flag_sets(self, flag_sets):
         :rtype: list
         """
         sanitized_flag_sets = config.sanitize_flag_sets(flag_sets)
-        feature_flags_names = self._split_storage.get_feature_flags_by_sets(sanitized_flag_sets)
-        return feature_flags_names
+        feature_flags_by_set = self._split_storage.get_feature_flags_by_sets(sanitized_flag_sets)
+        if feature_flags_by_set is None:
+            _LOGGER.warning("Fetching feature flags for flag set %s encountered an error, skipping this flag set." % (flag_sets))
+            return []
+        return feature_flags_by_set
 
     def _build_impression(  # pylint: disable=too-many-arguments
             self,

splitio/models/splits.py

@@ -93,7 +93,7 @@ def __init__(  # pylint: disable=too-many-arguments
             self._algo = HashAlgorithm.LEGACY
 
         self._configurations = configurations
-        self._sets = sets
+        self._sets = set(sets) if sets is not None else set()
 
     @property
     def name(self):

splitio/push/splitworker.py

@@ -10,7 +10,7 @@
 from splitio.models.splits import from_raw, Status
 from splitio.models.telemetry import UpdateFromSSE
 from splitio.push.parser import UpdateType
-
+from splitio.util.storage_helper import update_feature_flag_storage
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -88,17 +88,12 @@ def _run(self):
             try:
                 if self._check_instant_ff_update(event):
                     try:
-                        new_split = from_raw(json.loads(self._get_feature_flag_definition(event)))
-                        if new_split.status == Status.ACTIVE:
-                            self._feature_flag_storage.put(new_split)
-                            _LOGGER.debug('Feature flag %s is updated', new_split.name)
-                            for segment_name in new_split.get_segment_names():
-                                if self._segment_storage.get(segment_name) is None:
-                                    _LOGGER.debug('Fetching new segment %s', segment_name)
-                                    self._segment_handler(segment_name, event.change_number)
-                        else:
-                            self._feature_flag_storage.remove(new_split.name)
-                        self._feature_flag_storage.set_change_number(event.change_number)
+                        new_feature_flag = from_raw(json.loads(self._get_feature_flag_definition(event)))
+                        segment_list = update_feature_flag_storage(self._feature_flag_storage, [new_feature_flag], event.change_number)
+                        for segment_name in segment_list:
+                            if self._segment_storage.get(segment_name) is None:
+                                _LOGGER.debug('Fetching new segment %s', segment_name)
+                                self._segment_handler(segment_name, event.change_number)
                         self._telemetry_runtime_producer.record_update_from_sse(UpdateFromSSE.SPLIT_UPDATE)
                         continue
                     except Exception as e:

splitio/storage/inmemmory.py

@@ -13,20 +13,79 @@
 
 _LOGGER = logging.getLogger(__name__)
 
+class FlagSetsFilter(object):
+    """Config Flagsets Filter storage."""
+
+    def __init__(self, flag_sets=[]):
+        self.flag_sets = set(flag_sets)
+        self.should_filter = any(flag_sets)
+
+    def set_exist(self, flag_set):
+        if not self.should_filter:
+            return True
+        if not isinstance(flag_set, str) or flag_set == '':
+            return False
+
+        return any(self.flag_sets.intersection(set([flag_set])))
+
+    def intersect(self, flag_sets):
+        if not self.should_filter:
+            return True
+        if not isinstance(flag_sets, set) or len(flag_sets) == 0:
+            return False
+        return any(self.flag_sets.intersection(flag_sets))
+
+
+class FlagSets(object):
+    """InMemory Flagsets storage."""
+
+    def __init__(self, flag_sets=[]):
+        self._lock = threading.RLock()
+        self.sets_feature_flag_map = {}
+        for flag_set in flag_sets:
+            self.sets_feature_flag_map[flag_set] = set()
+
+    def flag_set_exist(self, flag_set):
+        with self._lock:
+            return flag_set in self.sets_feature_flag_map.keys()
+
+    def get_flag_set(self, flag_set):
+        with self._lock:
+            if self.flag_set_exist(flag_set):
+                return self.sets_feature_flag_map[flag_set]
+
+    def add_flag_set(self, flag_set):
+        with self._lock:
+            if not self.flag_set_exist(flag_set):
+                self.sets_feature_flag_map[flag_set] = set()
+
+    def remove_flag_set(self, flag_set):
+        with self._lock:
+            if self.flag_set_exist(flag_set):
+                del self.sets_feature_flag_map[flag_set]
+
+    def add_feature_flag_to_flag_set(self, flag_set, feature_flag):
+        with self._lock:
+            if self.flag_set_exist(flag_set):
+                self.sets_feature_flag_map[flag_set].add(feature_flag)
+
+    def remove_feature_flag_to_flag_set(self, flag_set, feature_flag):
+        with self._lock:
+            if self.flag_set_exist(flag_set):
+                self.sets_feature_flag_map[flag_set].remove(feature_flag)
+
 
 class InMemorySplitStorage(SplitStorage):
-    """InMemory implementation of a split storage."""
+    """InMemory implementation of a feature flag storage."""
 
     def __init__(self, flag_sets=[]):
         """Constructor."""
         self._lock = threading.RLock()
         self._splits = {}
         self._change_number = -1
         self._traffic_types = Counter()
-        self._sets_feature_flag_map = {}
-        self.config_flag_sets_used = len(flag_sets)
-        for flag_set in flag_sets:
-            self._sets_feature_flag_map[flag_set] = set()
+        self.flag_set = FlagSets(flag_sets)
+        self.flag_set_filter = FlagSetsFilter(flag_sets)
 
     def get(self, split_name):
         """
@@ -82,11 +141,11 @@ def _put(self, split):
             self._increase_traffic_type_count(split.traffic_type_name)
             if split.sets is not None:
                 for flag_set in split.sets:
-                    if flag_set not in self._sets_feature_flag_map.keys():
-                        if self.config_flag_sets_used > 0:
+                    if not self.flag_set.flag_set_exist(flag_set):
+                        if self.flag_set_filter.should_filter:
                             continue
-                        self._sets_feature_flag_map[flag_set] = set()
-                    self._sets_feature_flag_map[flag_set].add(split.name)
+                        self.flag_set.add_flag_set(flag_set)
+                    self.flag_set.add_feature_flag_to_flag_set(flag_set, split.name)
 
     def _remove(self, split_name):
         """
@@ -118,9 +177,9 @@ def _remove_from_flag_sets(self, feature_flag):
         """
         if feature_flag.sets is not None:
             for flag_set in feature_flag.sets:
-                self._sets_feature_flag_map[flag_set].remove(feature_flag.name)
-                if len(self._sets_feature_flag_map[flag_set]) == 0 and self.config_flag_sets_used == 0:
-                    del self._sets_feature_flag_map[flag_set]
+                self.flag_set.remove_feature_flag_to_flag_set(flag_set, feature_flag.name)
+                if len(self.flag_set.get_flag_set(flag_set)) == 0 and not self.flag_set_filter.should_filter:
+                    self.flag_set.remove_flag_set(flag_set)
 
     def get_feature_flags_by_sets(self, sets):
         """
@@ -135,19 +194,13 @@ def get_feature_flags_by_sets(self, sets):
         with self._lock:
             sets_to_fetch = []
             for flag_set in sets:
-                if flag_set not in self._sets_feature_flag_map.keys():
-                    if self.config_flag_sets_used > 0:
-                        _LOGGER.warning("Flag set %s is not part of the configured flag set list, ignoring the request." % (flag_set))
-                        continue
-                    else:
-                        self._sets_feature_flag_map[flag_set] = set()
+                if not self.flag_set.flag_set_exist(flag_set):
+                    _LOGGER.warning("Flag set %s is not part of the configured flag set list, ignoring it." % (flag_set))
+                    continue
                 sets_to_fetch.append(flag_set)
 
-            if sets_to_fetch == []:
-                return []
-
             to_return = set()
-            [to_return.update(self._sets_feature_flag_map[flag_set]) for flag_set in sets_to_fetch]
+            [to_return.update(self.flag_set.get_flag_set(flag_set)) for flag_set in sets_to_fetch]
             return list(to_return)
 
     def get_change_number(self):
@@ -260,10 +313,7 @@ def is_flag_set_exist(self, flag_set):
         :return: True if the flag_set exist. False otherwise.
         :rtype: bool
         """
-        if flag_set in self._sets_feature_flag_map.keys():
-            return True
-        return False
-
+        return self.flag_set.flag_set_exist(flag_set)
 
 class InMemorySegmentStorage(SegmentStorage):
     """In-memory implementation of a segment storage."""