Added old spec for Localhost

Author: chillaq

splitio/api/splits.py

@@ -9,6 +9,7 @@
 from splitio.models.telemetry import HTTPExceptionsAndLatencies
 from splitio.util.time import utctime_ms
 from splitio.spec import SPEC_VERSION
+from splitio.sync import util
 
 _LOGGER = logging.getLogger(__name__)
 _SPEC_1_1 = "1.1"
@@ -37,10 +38,6 @@ def __init__(self, client, sdk_key, sdk_metadata, telemetry_runtime_producer):
         self._last_proxy_check_timestamp = 0
         self.clear_storage = False
 
-    def _convert_to_new_spec(self, body):
-        return {"ff": {"d": body["splits"], "s": body["since"], "t": body["till"]}, 
-                "rbs": {"d": [], "s": -1, "t": -1}}
-
     def _check_last_proxy_check_timestamp(self):
         if self._spec_version == _SPEC_1_1 and ((utctime_ms() - self._last_proxy_check_timestamp) >= _PROXY_CHECK_INTERVAL_MILLISECONDS_SS):
             _LOGGER.info("Switching to new Feature flag spec (%s) and fetching.", SPEC_VERSION);
@@ -91,7 +88,7 @@ def fetch_splits(self, change_number, rbs_change_number, fetch_options):
             )
             if 200 <= response.status_code < 300:
                 if self._spec_version == _SPEC_1_1:
-                    return self._convert_to_new_spec(json.loads(response.body))
+                    return util.convert_to_new_spec(json.loads(response.body))
 
                 self.clear_storage = self._last_proxy_check_timestamp != 0
                 self._last_proxy_check_timestamp = 0
@@ -159,7 +156,7 @@ async def fetch_splits(self, change_number, rbs_change_number, fetch_options):
             )
             if 200 <= response.status_code < 300:
                 if self._spec_version == _SPEC_1_1:
-                    return self._convert_to_new_spec(json.loads(response.body))
+                    return util.convert_to_new_spec(json.loads(response.body))
 
                 self.clear_storage = self._last_proxy_check_timestamp != 0
                 self._last_proxy_check_timestamp = 0

splitio/engine/evaluator.py

@@ -6,11 +6,12 @@
 from splitio.models.grammar.condition import ConditionType
 from splitio.models.grammar.matchers.misc import DependencyMatcher
 from splitio.models.grammar.matchers.keys import UserDefinedSegmentMatcher
-from splitio.models.grammar.matchers.rule_based_segment import RuleBasedSegmentMatcher
+from splitio.models.grammar.matchers import RuleBasedSegmentMatcher
+from splitio.models.rule_based_segments import SegmentType
 from splitio.optional.loaders import asyncio
 
 CONTROL = 'control'
-EvaluationContext = namedtuple('EvaluationContext', ['flags', 'segment_memberships', 'segment_rbs_memberships', 'segment_rbs_conditions'])
+EvaluationContext = namedtuple('EvaluationContext', ['flags', 'segment_memberships', 'segment_rbs_memberships', 'segment_rbs_conditions', 'excluded_rbs_segments'])
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -130,6 +131,7 @@ def context_for(self, key, feature_names):
 
         rbs_segment_memberships = {}
         rbs_segment_conditions = {}
+        excluded_rbs_segments = {}
         key_membership = False
         segment_memberhsip = False
         for rbs_segment in pending_rbs_memberships:
@@ -138,10 +140,14 @@ def context_for(self, key, feature_names):
 
             key_membership = key in rbs_segment_obj.excluded.get_excluded_keys()
             segment_memberhsip = False
-            for segment_name in rbs_segment_obj.excluded.get_excluded_segments():
-                if self._segment_storage.segment_contains(segment_name, key):
+            for excluded_segment in rbs_segment_obj.excluded.get_excluded_segments():
+                if excluded_segment.type == SegmentType.STANDARD and self._segment_storage.segment_contains(excluded_segment.name, key):
                     segment_memberhsip = True
-                    break
+
+                if excluded_segment.type == SegmentType.RULE_BASED:
+                    rbs_segment = self._rbs_segment_storage.get(excluded_segment.name)
+                    if rbs_segment is not None:
+                        excluded_rbs_segments.update()
 
             rbs_segment_memberships.update({rbs_segment: segment_memberhsip or key_membership})
             if not (segment_memberhsip or key_membership):
@@ -153,7 +159,8 @@ def context_for(self, key, feature_names):
                 for segment in pending_memberships
             },
             rbs_segment_memberships,
-            rbs_segment_conditions        
+            rbs_segment_conditions,
+            excluded_rbs_segments        
         )
 
 class AsyncEvaluationDataFactory:
@@ -189,6 +196,7 @@ async def context_for(self, key, feature_names):
 
         rbs_segment_memberships = {}
         rbs_segment_conditions = {}
+        excluded_rbs_segments = {}
         key_membership = False
         segment_memberhsip = False
         for rbs_segment in pending_rbs_memberships:
@@ -197,11 +205,15 @@ async def context_for(self, key, feature_names):
 
             key_membership = key in rbs_segment_obj.excluded.get_excluded_keys()
             segment_memberhsip = False
-            for segment_name in rbs_segment_obj.excluded.get_excluded_segments():
-                if await self._segment_storage.segment_contains(segment_name, key):
+            for excluded_segment in rbs_segment_obj.excluded.get_excluded_segments():
+                if excluded_segment.type == SegmentType.STANDARD and await self._segment_storage.segment_contains(excluded_segment.name, key):
                     segment_memberhsip = True
-                    break
-                
+
+                if excluded_segment.type == SegmentType.RULE_BASED:
+                    rbs_segment = await self._rbs_segment_storage.get(excluded_segment.name)
+                    if rbs_segment is not None:
+                        excluded_rbs_segments.update()
+                            
             rbs_segment_memberships.update({rbs_segment: segment_memberhsip or key_membership})
             if not (segment_memberhsip or key_membership):
                 rbs_segment_conditions.update({rbs_segment: [condition for condition in rbs_segment_obj.conditions]})
@@ -215,7 +227,8 @@ async def context_for(self, key, feature_names):
             splits, 
             dict(zip(segment_names, segment_memberships)),
             rbs_segment_memberships,
-            rbs_segment_conditions                
+            rbs_segment_conditions,
+            excluded_rbs_segments        
         )
 
 

splitio/models/grammar/matchers/rule_based_segment.py

@@ -32,11 +32,14 @@ def _match(self, key, attributes=None, context=None):
         # Check if rbs segment has exclusions
         if context['ec'].segment_rbs_memberships.get(self._rbs_segment_name):
             return False
-                
-        for parsed_condition in context['ec'].segment_rbs_conditions.get(self._rbs_segment_name):
-            if parsed_condition.matches(key, attributes, context):
+        
+        for rbs_segment in context['ec'].excluded_rbs_segments:
+            if self._match_conditions(rbs_segment, key, attributes, context):
                 return True
-                
+        
+        if self._match_conditions(context['ec'].segment_rbs_conditions.get(self._rbs_segment_name), key, attributes, context):
+            return True
+                                
         return False
 
     def _add_matcher_specific_properties_to_json(self):
@@ -45,4 +48,9 @@ def _add_matcher_specific_properties_to_json(self):
             'userDefinedSegmentMatcherData': {
                 'segmentName': self._rbs_segment_name
             }
-        }
+        }
+        
+    def _match_conditions(self, rbs_segment, key, attributes, context):
+        for parsed_condition in rbs_segment:
+            if parsed_condition.matches(key, attributes, context):
+                return True

splitio/models/rule_based_segments.py

@@ -1,5 +1,6 @@
 """RuleBasedSegment module."""
 
+from enum import Enum
 import logging
 
 from splitio.models import MatcherNotFoundException
@@ -9,6 +10,12 @@
 
 _LOGGER = logging.getLogger(__name__)
 
+class SegmentType(Enum):
+    """Segment type."""
+    
+    STANDARD = "standard"
+    RULE_BASED = "rule-based"
+
 class RuleBasedSegment(object):
     """RuleBasedSegment object class."""
 
@@ -125,7 +132,7 @@ def __init__(self, keys, segments):
         :type segments: List
         """
         self._keys = keys
-        self._segments = segments
+        self._segments = [ExcludedSegment(segment['name'], segment['type']) for segment in segments]
 
     def get_excluded_keys(self):
         """Return excluded keys."""        
@@ -141,3 +148,30 @@ def to_json(self):
             'keys': self._keys,
             'segments': self._segments
         }
+
+class ExcludedSegment(object):
+    
+    def __init__(self, name, type):
+        """
+        Class constructor.
+
+        :param name: rule based segment name
+        :type name: str
+        :param type: segment type 
+        :type type: str
+        """
+        self._name = name
+        try:
+            self._type = SegmentType(type)
+        except ValueError:
+            self._type = SegmentType.STANDARD
+
+    @property
+    def name(self):
+        """Return name."""
+        return self._name
+
+    @property
+    def type(self):
+        """Return type."""
+        return self._type

splitio/storage/inmemmory.py

@@ -243,7 +243,7 @@ async def clear(self):
         """
         Clear storage
         """
-        with self._lock:
+        async with self._lock:
             self._rule_based_segments = {}
             self._change_number = -1
 
@@ -702,7 +702,7 @@ async def clear(self):
         """
         Clear storage
         """
-        with self._lock:
+        async with self._lock:
             self._feature_flags = {}
             self._change_number = -1
             self._traffic_types = Counter()