polish

Author: chillaq

splitio/client/factory.py

@@ -693,7 +693,7 @@ async def _build_in_memory_factory_async(api_key, cfg, sdk_url=None, events_url=
 
     synchronizers = SplitSynchronizers(
         SplitSynchronizerAsync(apis['splits'], storages['splits'], storages['rule_based_segments']),
-        SegmentSynchronizerAsync(apis['segments'], storages['splits'], storages['segments']),
+        SegmentSynchronizerAsync(apis['segments'], storages['splits'], storages['segments'], storages['rule_based_segments']),
         ImpressionSynchronizerAsync(apis['impressions'], storages['impressions'],
                                cfg['impressionsBulkSize']),
         EventSynchronizerAsync(apis['events'], storages['events'], cfg['eventsBulkSize']),

splitio/models/rule_based_segments.py

@@ -152,6 +152,14 @@ def get_excluded_segments(self):
         """Return excluded segments"""
         return self._segments
 
+    def get_excluded_standard_segments(self):
+        """Return excluded segments"""
+        to_return = []
+        for segment in self._segments:
+            if segment.type == SegmentType.STANDARD:
+                to_return.append(segment.name)
+        return to_return
+
     def to_json(self):
         """Return a JSON representation of this object."""
         return {

splitio/sync/segment.py

@@ -10,7 +10,7 @@
 from splitio.util.backoff import Backoff
 from splitio.optional.loaders import asyncio, aiofiles
 from splitio.sync import util
-from splitio.util.storage_helper import get_standard_segment_names_in_rbs_storage
+from splitio.util.storage_helper import get_standard_segment_names_in_rbs_storage, get_standard_segment_names_in_rbs_storage_async
 from splitio.optional.loaders import asyncio
 
 _LOGGER = logging.getLogger(__name__)
@@ -183,7 +183,7 @@ def synchronize_segments(self, segment_names = None, dont_wait = False):
         :rtype: bool
         """
         if segment_names is None:
-            segment_names = self._feature_flag_storage.get_segment_names()
+            segment_names = set(self._feature_flag_storage.get_segment_names())
             segment_names.update(get_standard_segment_names_in_rbs_storage(self._rule_based_segment_storage))
 
         for segment_name in segment_names:
@@ -209,7 +209,7 @@ def segment_exist_in_storage(self, segment_name):
 
 
 class SegmentSynchronizerAsync(object):
-    def __init__(self, segment_api, feature_flag_storage, segment_storage):
+    def __init__(self, segment_api, feature_flag_storage, segment_storage, rule_based_segment_storage):
         """
         Class constructor.
 
@@ -226,6 +226,7 @@ def __init__(self, segment_api, feature_flag_storage, segment_storage):
         self._api = segment_api
         self._feature_flag_storage = feature_flag_storage
         self._segment_storage = segment_storage
+        self._rule_based_segment_storage = rule_based_segment_storage
         self._worker_pool = workerpool.WorkerPoolAsync(_MAX_WORKERS, self.synchronize_segment)
         self._worker_pool.start()
         self._backoff = Backoff(
@@ -369,7 +370,8 @@ async def synchronize_segments(self, segment_names = None, dont_wait = False):
         :rtype: bool
         """
         if segment_names is None:
-            segment_names = await self._feature_flag_storage.get_segment_names()
+            segment_names = set(await self._feature_flag_storage.get_segment_names())
+            segment_names.update(await get_standard_segment_names_in_rbs_storage_async(self._rule_based_segment_storage))
 
         self._jobs = await self._worker_pool.submit_work(segment_names)
         if (dont_wait):

splitio/util/storage_helper.py

@@ -1,6 +1,7 @@
 """Storage Helper."""
 import logging
 from splitio.models import splits
+from splitio.models import rule_based_segments
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -58,17 +59,14 @@ def update_rule_based_segment_storage(rule_based_segment_storage, rule_based_seg
     for rule_based_segment in rule_based_segments:
         if rule_based_segment.status == splits.Status.ACTIVE:
             to_add.append(rule_based_segment)
-            segment_list.update(set(_get_segment_names(rule_based_segment.excluded.get_excluded_segments())))
+            segment_list.update(set(rule_based_segment.excluded.get_excluded_standard_segments()))
             segment_list.update(rule_based_segment.get_condition_segment_names())
         else:
             if rule_based_segment_storage.get(rule_based_segment.name) is not None:
                 to_delete.append(rule_based_segment.name)
 
     rule_based_segment_storage.update(to_add, to_delete, change_number)
     return segment_list
-
-def _get_segment_names(excluded_segments):
-    return [excluded_segment.name for excluded_segment in excluded_segments]
 
 def get_standard_segment_names_in_rbs_storage(rule_based_segment_storage):
     """
@@ -80,7 +78,7 @@ def get_standard_segment_names_in_rbs_storage(rule_based_segment_storage):
     segment_list = set()
     for rb_segment in rule_based_segment_storage.get_segment_names():
         rb_segment_obj = rule_based_segment_storage.get(rb_segment)
-        segment_list.update(set(_get_segment_names(rb_segment_obj.excluded.get_excluded_segments())))
+        segment_list.update(set(rb_segment_obj.excluded.get_excluded_standard_segments()))
         segment_list.update(rb_segment_obj.get_condition_segment_names())
 
     return segment_list
@@ -139,7 +137,7 @@ async def update_rule_based_segment_storage_async(rule_based_segment_storage, ru
     for rule_based_segment in rule_based_segments:
         if rule_based_segment.status == splits.Status.ACTIVE:
             to_add.append(rule_based_segment)
-            segment_list.update(set(_get_segment_names(rule_based_segment.excluded.get_excluded_segments())))
+            segment_list.update(set(rule_based_segment.excluded.get_excluded_standard_segments()))
             segment_list.update(rule_based_segment.get_condition_segment_names())
         else:
             if await rule_based_segment_storage.get(rule_based_segment.name) is not None:
@@ -148,6 +146,22 @@ async def update_rule_based_segment_storage_async(rule_based_segment_storage, ru
     await rule_based_segment_storage.update(to_add, to_delete, change_number)
     return segment_list
 
+async def get_standard_segment_names_in_rbs_storage_async(rule_based_segment_storage):
+    """
+    Retrieve a list of all standard segments names.
+
+    :return: Set of segment names.
+    :rtype: Set(str)
+    """
+    segment_list = set()
+    segment_names = await rule_based_segment_storage.get_segment_names()
+    for rb_segment in segment_names:
+        rb_segment_obj = await rule_based_segment_storage.get(rb_segment)
+        segment_list.update(set(rb_segment_obj.excluded.get_excluded_standard_segments()))
+        segment_list.update(rb_segment_obj.get_condition_segment_names())
+        
+    return segment_list
+
 def get_valid_flag_sets(flag_sets, flag_set_filter):
     """
     Check each flag set in given array, return it if exist in a given config flag set array, if config array is empty return all