fix: Update DataSystemConfig to accept list of synchronizers

Author: keelerm84

.github/workflows/ci.yml

@@ -61,16 +61,16 @@ jobs:
         with:
           test_service_port: 9000
           token: ${{ secrets.GITHUB_TOKEN }}
-          stop_service: 'false'
-          enable_persistence_tests: 'true'
+          stop_service: "false"
+          enable_persistence_tests: "true"
 
       - name: Run contract tests v3
         uses: launchdarkly/gh-actions/actions/contract-tests@contract-tests-v1
         with:
           test_service_port: 9000
           token: ${{ secrets.GITHUB_TOKEN }}
-          version: v3.0.0-alpha.2
-          enable_persistence_tests: 'true'
+          version: v3.0.0-alpha.3
+          enable_persistence_tests: "true"
 
   windows:
     runs-on: windows-latest

contract-tests/client_entity.py

@@ -58,50 +58,32 @@ def __init__(self, tag, config):
                         initializers.append(polling_builder)
 
                 datasystem.initializers(initializers)
-            sync_config = datasystem_config.get('synchronizers')
-            if sync_config is not None:
-                primary = sync_config.get('primary')
-                secondary = sync_config.get('secondary')
-
-                primary_builder = None
-                secondary_builder = None
+            sync_configs = datasystem_config.get('synchronizers')
+            if sync_configs is not None:
+                sync_builders = []
                 fallback_builder = None
 
-                if primary is not None:
-                    streaming = primary.get('streaming')
+                for sync_config in sync_configs:
+                    streaming = sync_config.get('streaming')
                     if streaming is not None:
-                        primary_builder = streaming_ds_builder()
-                        _set_optional_value(streaming, "baseUri", primary_builder.base_uri)
-                        _set_optional_time(streaming, "initialRetryDelayMs", primary_builder.initial_reconnect_delay)
-                    elif primary.get('polling') is not None:
-                        polling = primary.get('polling')
-
-                        primary_builder = polling_ds_builder()
-                        _set_optional_value(polling, "baseUri", primary_builder.base_uri)
-                        _set_optional_time(polling, "pollIntervalMs", primary_builder.poll_interval)
+                        builder = streaming_ds_builder()
+                        _set_optional_value(streaming, "baseUri", builder.base_uri)
+                        _set_optional_time(streaming, "initialRetryDelayMs", builder.initial_reconnect_delay)
+                        sync_builders.append(builder)
+                    elif sync_config.get('polling') is not None:
+                        polling = sync_config.get('polling')
+
+                        builder = polling_ds_builder()
+                        _set_optional_value(polling, "baseUri", builder.base_uri)
+                        _set_optional_time(polling, "pollIntervalMs", builder.poll_interval)
+                        sync_builders.append(builder)
 
                         fallback_builder = fdv1_fallback_ds_builder()
                         _set_optional_value(polling, "baseUri", fallback_builder.base_uri)
                         _set_optional_time(polling, "pollIntervalMs", fallback_builder.poll_interval)
 
-                if secondary is not None:
-                    streaming = secondary.get('streaming')
-                    if streaming is not None:
-                        secondary_builder = streaming_ds_builder()
-                        _set_optional_value(streaming, "baseUri", secondary_builder.base_uri)
-                        _set_optional_time(streaming, "initialRetryDelayMs", secondary_builder.initial_reconnect_delay)
-                    elif secondary.get('polling') is not None:
-                        polling = secondary.get('polling')
-
-                        secondary_builder = polling_ds_builder()
-                        _set_optional_value(polling, "baseUri", secondary_builder.base_uri)
-                        _set_optional_time(polling, "pollIntervalMs", secondary_builder.poll_interval)
-                        fallback_builder = fdv1_fallback_ds_builder()
-                        _set_optional_value(polling, "baseUri", fallback_builder.base_uri)
-                        _set_optional_time(polling, "pollIntervalMs", fallback_builder.poll_interval)
-
-                if primary_builder is not None:
-                    datasystem.synchronizers(primary_builder, secondary_builder)
+                if sync_builders:
+                    datasystem.synchronizers(*sync_builders)
                 if fallback_builder is not None:
                     datasystem.fdv1_compatible_synchronizer(fallback_builder)
 

ldclient/config.py

@@ -181,11 +181,12 @@ class DataSystemConfig:
     initializers: Optional[List[DataSourceBuilder[Initializer]]]
     """The initializers for the data system."""
 
-    primary_synchronizer: Optional[DataSourceBuilder[Synchronizer]]
-    """The primary synchronizer for the data system."""
-
-    secondary_synchronizer: Optional[DataSourceBuilder[Synchronizer]] = None
-    """The secondary synchronizers for the data system."""
+    synchronizers: Optional[List[DataSourceBuilder[Synchronizer]]]
+    """
+    The synchronizers for the data system, ordered by preference.
+    The first synchronizer is the most preferred, with subsequent synchronizers
+    serving as fallbacks in order of decreasing preference.
+    """
 
     data_store_mode: DataStoreMode = DataStoreMode.READ_WRITE
     """The data store mode specifies the mode in which the persistent store will operate, if present."""

ldclient/datasystem.py

@@ -29,8 +29,7 @@ class ConfigBuilder:  # pylint: disable=too-few-public-methods
 
     def __init__(self) -> None:
         self._initializers: Optional[List[DataSourceBuilder[Initializer]]] = None
-        self._primary_synchronizer: Optional[DataSourceBuilder[Synchronizer]] = None
-        self._secondary_synchronizer: Optional[DataSourceBuilder[Synchronizer]] = None
+        self._synchronizers: List[DataSourceBuilder[Synchronizer]] = []
         self._fdv1_fallback_synchronizer: Optional[DataSourceBuilder[Synchronizer]] = None
         self._store_mode: DataStoreMode = DataStoreMode.READ_ONLY
         self._data_store: Optional[FeatureStore] = None
@@ -44,14 +43,23 @@ def initializers(self, initializers: Optional[List[DataSourceBuilder[Initializer
 
     def synchronizers(
         self,
-        primary: DataSourceBuilder[Synchronizer],
-        secondary: Optional[DataSourceBuilder[Synchronizer]] = None,
+        *sync_builders: DataSourceBuilder[Synchronizer]
     ) -> "ConfigBuilder":
         """
         Sets the synchronizers for the data system.
+
+        Accepts one or more synchronizer builders, ordered by preference.
+        The first synchronizer is the most preferred, with subsequent
+        synchronizers serving as fallbacks in order of decreasing preference.
+
+        Examples:
+            builder.synchronizers(streaming_builder)
+            builder.synchronizers(streaming_builder, polling_builder)
+            builder.synchronizers(sync1, sync2, sync3)
         """
-        self._primary_synchronizer = primary
-        self._secondary_synchronizer = secondary
+        if len(sync_builders) == 0:
+            raise ValueError("At least one synchronizer must be provided")
+        self._synchronizers = list(sync_builders)
         return self
 
     def fdv1_compatible_synchronizer(
@@ -77,13 +85,9 @@ def build(self) -> DataSystemConfig:
         """
         Builds the data system configuration.
         """
-        if self._secondary_synchronizer is not None and self._primary_synchronizer is None:
-            raise ValueError("Primary synchronizer must be set if secondary is set")
-
         return DataSystemConfig(
             initializers=self._initializers,
-            primary_synchronizer=self._primary_synchronizer,
-            secondary_synchronizer=self._secondary_synchronizer,
+            synchronizers=self._synchronizers if len(self._synchronizers) > 0 else None,
             fdv1_fallback_synchronizer=self._fdv1_fallback_synchronizer,
             data_store_mode=self._store_mode,
             data_store=self._data_store,