chore: Add persistence store support for FDv2 (#357)

Author: keelerm84

ldclient/config.py

@@ -19,6 +19,7 @@
 from ldclient.interfaces import (
     BigSegmentStore,
     DataSourceUpdateSink,
+    DataStoreMode,
     EventProcessor,
     FeatureStore,
     UpdateProcessor
@@ -161,19 +162,23 @@ def disable_ssl_verification(self) -> bool:
 
 @dataclass(frozen=True)
 class DataSystemConfig:
-    """
-    Configuration for LaunchDarkly's data acquisition strategy.
-    """
+    """Configuration for LaunchDarkly's data acquisition strategy."""
 
     initializers: Optional[List[Builder[Initializer]]]
     """The initializers for the data system."""
 
-    primary_synchronizer: Builder[Synchronizer]
+    primary_synchronizer: Optional[Builder[Synchronizer]]
     """The primary synchronizer for the data system."""
 
     secondary_synchronizer: Optional[Builder[Synchronizer]] = None
     """The secondary synchronizers for the data system."""
 
+    data_store_mode: DataStoreMode = DataStoreMode.READ_WRITE
+    """The data store mode specifies the mode in which the persistent store will operate, if present."""
+
+    data_store: Optional[FeatureStore] = None
+    """The (optional) persistent data store instance."""
+
     # TODO(fdv2): Implement this synchronizer up and hook it up everywhere.
     # TODO(fdv2): Remove this when FDv2 is fully launched
     fdv1_fallback_synchronizer: Optional[Builder[Synchronizer]] = None

ldclient/impl/datasourcev2/status.py

@@ -1,13 +1,18 @@
 import time
+from copy import copy
 from typing import Callable, Optional
 
+from ldclient.impl.datasystem.store import Store
 from ldclient.impl.listeners import Listeners
 from ldclient.impl.rwlock import ReadWriteLock
 from ldclient.interfaces import (
     DataSourceErrorInfo,
     DataSourceState,
     DataSourceStatus,
-    DataSourceStatusProvider
+    DataSourceStatusProvider,
+    DataStoreStatus,
+    DataStoreStatusProvider,
+    FeatureStore
 )
 
 
@@ -55,3 +60,50 @@ def add_listener(self, listener: Callable[[DataSourceStatus], None]):
 
     def remove_listener(self, listener: Callable[[DataSourceStatus], None]):
         self.__listeners.remove(listener)
+
+
+class DataStoreStatusProviderImpl(DataStoreStatusProvider):
+    def __init__(self, store: Optional[FeatureStore], listeners: Listeners):
+        self.__store = store
+        self.__listeners = listeners
+
+        self.__lock = ReadWriteLock()
+        self.__status = DataStoreStatus(True, False)
+
+    def update_status(self, status: DataStoreStatus):
+        """
+        update_status is called from the data store to push a status update.
+        """
+        self.__lock.lock()
+        modified = False
+
+        if self.__status != status:
+            self.__status = status
+            modified = True
+
+        self.__lock.unlock()
+
+        if modified:
+            self.__listeners.notify(status)
+
+    @property
+    def status(self) -> DataStoreStatus:
+        self.__lock.rlock()
+        status = copy(self.__status)
+        self.__lock.runlock()
+
+        return status
+
+    def is_monitoring_enabled(self) -> bool:
+        if self.__store is None:
+            return False
+        if hasattr(self.__store, "is_monitoring_enabled") is False:
+            return False
+
+        return self.__store.is_monitoring_enabled()  # type: ignore
+
+    def add_listener(self, listener: Callable[[DataStoreStatus], None]):
+        self.__listeners.add(listener)
+
+    def remove_listener(self, listener: Callable[[DataStoreStatus], None]):
+        self.__listeners.remove(listener)

ldclient/impl/datasystem/config.py

@@ -16,6 +16,7 @@
     StreamingDataSourceBuilder
 )
 from ldclient.impl.datasystem import Initializer, Synchronizer
+from ldclient.interfaces import DataStoreMode, FeatureStore
 
 T = TypeVar("T")
 
@@ -30,6 +31,8 @@ class ConfigBuilder:  # pylint: disable=too-few-public-methods
     _initializers: Optional[List[Builder[Initializer]]] = None
     _primary_synchronizer: Optional[Builder[Synchronizer]] = None
     _secondary_synchronizer: Optional[Builder[Synchronizer]] = None
+    _store_mode: DataStoreMode = DataStoreMode.READ_ONLY
+    _data_store: Optional[FeatureStore] = None
 
     def initializers(self, initializers: Optional[List[Builder[Initializer]]]) -> "ConfigBuilder":
         """
@@ -50,17 +53,27 @@ def synchronizers(
         self._secondary_synchronizer = secondary
         return self
 
+    def data_store(self, data_store: FeatureStore, store_mode: DataStoreMode) -> "ConfigBuilder":
+        """
+        Sets the data store configuration for the data system.
+        """
+        self._data_store = data_store
+        self._store_mode = store_mode
+        return self
+
     def build(self) -> DataSystemConfig:
         """
         Builds the data system configuration.
         """
-        if self._primary_synchronizer is None:
-            raise ValueError("Primary synchronizer must be set")
+        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,
+            data_store_mode=self._store_mode,
+            data_store=self._data_store,
         )
 
 
@@ -147,18 +160,29 @@ def custom() -> ConfigBuilder:
     return ConfigBuilder()
 
 
-# TODO(fdv2): Implement these methods
-#
-# Daemon configures the SDK to read from a persistent store integration
-# that is populated by Relay Proxy or other SDKs. The SDK will not connect
-# to LaunchDarkly. In this mode, the SDK never writes to the data store.
+# TODO(fdv2): Need to update these so they don't rely on the LDConfig
+def daemon(config: LDConfig, store: FeatureStore) -> ConfigBuilder:
+    """
+    Daemon configures the SDK to read from a persistent store integration
+    that is populated by Relay Proxy or other SDKs. The SDK will not connect
+    to LaunchDarkly. In this mode, the SDK never writes to the data store.
+    """
+    return default(config).data_store(store, DataStoreMode.READ_ONLY)
+
 
-# PersistentStore is similar to Default, with the addition of a persistent
-# store integration. Before data has arrived from LaunchDarkly, the SDK is
-# able to evaluate flags using data from the persistent store. Once fresh
-# data is available, the SDK will no longer read from the persistent store,
-# although it will keep it up-to-date.
+def persistent_store(config: LDConfig, store: FeatureStore) -> ConfigBuilder:
+    """
+    PersistentStore is similar to Default, with the addition of a persistent
+    store integration. Before data has arrived from LaunchDarkly, the SDK is
+    able to evaluate flags using data from the persistent store. Once fresh
+    data is available, the SDK will no longer read from the persistent store,
+    although it will keep it up-to-date.
+    """
+    return default(config).data_store(store, DataStoreMode.READ_WRITE)
 
+
+# TODO(fdv2): Implement these methods
+#
 # WithEndpoints configures the data system with custom endpoints for
 # LaunchDarkly's streaming and polling synchronizers. This method is not
 # necessary for most use-cases, but can be useful for testing or custom