moved flagset and flagset filter classes to storage

Author: chillaq

splitio/models/flag_sets.py

@@ -1,5 +1,6 @@
 """Base storage interfaces."""
 import abc
+import threading
 
 
 class SplitStorage(object, metaclass=abc.ABCMeta):
@@ -315,3 +316,42 @@ def record_bur_time_out(self):
 
         """
         pass
+
+class FlagSetsFilter(object):
+    """Config Flagsets Filter storage."""
+
+    def __init__(self, flag_sets=[]):
+        """Constructor."""
+        self.flag_sets = set(flag_sets)
+        self.should_filter = any(flag_sets)
+
+    def set_exist(self, flag_set):
+        """
+        Check if a flagset exist in flagset filter
+
+        :param flag_set: set name
+        :type flag_set: str
+
+        :rtype: bool
+        """
+        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):
+        """
+        Check if a set exist in config flagset filter
+
+        :param flag_set: set of flagsets
+        :type flag_set: set
+
+        :rtype: bool
+        """
+        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))

splitio/storage/__init__.py

@@ -6,14 +6,97 @@
 
 from splitio.models.segments import Segment
 from splitio.models.telemetry import HTTPErrors, HTTPLatencies, MethodExceptions, MethodLatencies, LastSynchronization, StreamingEvents, TelemetryConfig, TelemetryCounters, CounterConstants
-from splitio.models.flag_sets import FlagSets, FlagSetsFilter
+from splitio.storage import FlagSetsFilter
 from splitio.storage import SplitStorage, SegmentStorage, ImpressionStorage, EventStorage, TelemetryStorage
 
 MAX_SIZE_BYTES = 5 * 1024 * 1024
 MAX_TAGS = 10
 
 _LOGGER = logging.getLogger(__name__)
 
+class FlagSets(object):
+    """InMemory Flagsets storage."""
+
+    def __init__(self, flag_sets=[]):
+        """Constructor."""
+        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):
+        """
+        Check if a flagset exist in stored flagset
+
+        :param flag_set: set name
+        :type flag_set: str
+
+        :rtype: bool
+        """
+        with self._lock:
+            return flag_set in self.sets_feature_flag_map.keys()
+
+    def get_flag_set(self, flag_set):
+        """
+        fetch feature flags stored in a flag set
+
+        :param flag_set: set name
+        :type flag_set: str
+
+        :rtype: list(str)
+        """
+        with self._lock:
+            return self.sets_feature_flag_map.get(flag_set)
+
+    def add_flag_set(self, flag_set):
+        """
+        Add new flag set to storage
+
+        :param flag_set: set name
+        :type flag_set: str
+        """
+        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):
+        """
+        Remove existing flag set from storage
+
+        :param flag_set: set name
+        :type flag_set: str
+        """
+        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):
+        """
+        Add a feature flag to existing flag set
+
+        :param flag_set: set name
+        :type flag_set: str
+        :param feature_flag: feature flag name
+        :type feature_flag: str
+        """
+        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):
+        """
+        Remove a feature flag from existing flag set
+
+        :param flag_set: set name
+        :type flag_set: str
+        :param feature_flag: feature flag name
+        :type feature_flag: str
+        """
+        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 feature flag storage."""
 

splitio/storage/inmemmory.py

@@ -7,7 +7,7 @@
 from splitio.models import splits, segments
 from splitio.models.impressions import Impression
 from splitio.models.telemetry import MethodExceptions, MethodLatencies, TelemetryConfig, MAX_TAGS, get_latency_bucket_index
-from splitio.models.flag_sets import FlagSetsFilter
+from splitio.storage import FlagSetsFilter
 from splitio.storage import SplitStorage, SegmentStorage, ImpressionStorage, EventStorage, TelemetryStorage
 from splitio.util.storage_helper import get_valid_flag_sets, combine_valid_flag_sets
 

splitio/storage/pluggable.py

@@ -6,7 +6,7 @@
 from splitio.models.impressions import Impression
 from splitio.models import splits, segments
 from splitio.models.telemetry import MethodExceptions, MethodLatencies, TelemetryConfig, get_latency_bucket_index
-from splitio.models.flag_sets import FlagSetsFilter
+from splitio.storage import FlagSetsFilter
 from splitio.storage import SplitStorage, SegmentStorage, ImpressionStorage, EventStorage, \
     ImpressionPipelinedStorage, TelemetryStorage
 from splitio.storage.adapters.redis import RedisAdapterException

splitio/storage/redis.py

@@ -0,0 +1,18 @@
+from splitio.storage import FlagSetsFilter
+
+class FlagSetsFilterTests(object):
+    """Flag sets filter storage tests."""
+
+    def test_flag_set_filter(self):
+        flag_set_filter = FlagSetsFilter()
+        assert flag_set_filter.flag_sets == set()
+        assert not flag_set_filter.should_filter
+
+        flag_set_filter = FlagSetsFilter(['set1', 'set2'])
+        assert flag_set_filter.flag_sets == set({'set1', 'set2'})
+        assert flag_set_filter.should_filter
+        assert flag_set_filter.intersect(set({'set1', 'set2'}))
+        assert flag_set_filter.intersect(set({'set1', 'set2', 'set5'}))
+        assert not flag_set_filter.intersect(set({'set4'}))
+        assert not flag_set_filter.set_exist('set4')
+        assert flag_set_filter.set_exist('set1')