pass configurators to NamespaceStore::new

Author: MarinPostma

libsql-server/src/lib.rs

@@ -60,6 +60,7 @@ use utils::services::idle_shutdown::IdleShutdownKicker;
 
 use self::config::MetaStoreConfig;
 use self::connection::connection_manager::InnerWalManager;
+use self::namespace::configurator::NamespaceConfigurators;
 use self::namespace::NamespaceStore;
 use self::net::AddrIncoming;
 use self::replication::script_backup_manager::{CommandHandler, ScriptBackupManager};
@@ -488,12 +489,16 @@ where
             meta_store_wal_manager,
         )
         .await?;
+
+        let configurators = NamespaceConfigurators::default();
+
         let namespace_store: NamespaceStore = NamespaceStore::new(
             db_kind.is_replica(),
             self.db_config.snapshot_at_shutdown,
             self.max_active_namespaces,
             ns_config,
             meta_store,
+            configurators,
         )
         .await?;
 

libsql-server/src/namespace/configurator/mod.rs

@@ -4,43 +4,55 @@ use futures::Future;
 
 use super::broadcasters::BroadcasterHandle;
 use super::meta_store::MetaStoreHandle;
-use super::{NamespaceConfig, NamespaceName, NamespaceStore, ResetCb, ResolveNamespacePathFn, RestoreOption};
+use super::{
+    NamespaceConfig, NamespaceName, NamespaceStore, ResetCb, ResolveNamespacePathFn, RestoreOption,
+};
 
-mod replica;
 mod primary;
+mod replica;
 mod schema;
 
-pub use replica::ReplicaConfigurator;
 pub use primary::PrimaryConfigurator;
+pub use replica::ReplicaConfigurator;
 pub use schema::SchemaConfigurator;
 
 type DynConfigurator = dyn ConfigureNamespace + Send + Sync + 'static;
 
-#[derive(Default)]
 pub(crate) struct NamespaceConfigurators {
     replica_configurator: Option<Box<DynConfigurator>>,
     primary_configurator: Option<Box<DynConfigurator>>,
     schema_configurator: Option<Box<DynConfigurator>>,
 }
 
+impl Default for NamespaceConfigurators {
+    fn default() -> Self {
+        Self::empty()
+            .with_primary(PrimaryConfigurator)
+            .with_replica(ReplicaConfigurator)
+            .with_schema(SchemaConfigurator)
+    }
+}
+
 impl NamespaceConfigurators {
-    pub fn with_primary(
-        &mut self,
-        c: impl ConfigureNamespace + Send + Sync + 'static,
-    ) -> &mut Self {
+    pub fn empty() -> Self {
+        Self {
+            replica_configurator: None,
+            primary_configurator: None,
+            schema_configurator: None,
+        }
+    }
+
+    pub fn with_primary(mut self, c: impl ConfigureNamespace + Send + Sync + 'static) -> Self {
         self.primary_configurator = Some(Box::new(c));
         self
     }
 
-    pub fn with_replica(
-        &mut self,
-        c: impl ConfigureNamespace + Send + Sync + 'static,
-    ) -> &mut Self {
+    pub fn with_replica(mut self, c: impl ConfigureNamespace + Send + Sync + 'static) -> Self {
         self.replica_configurator = Some(Box::new(c));
         self
     }
 
-    pub fn with_schema(&mut self, c: impl ConfigureNamespace + Send + Sync + 'static) -> &mut Self {
+    pub fn with_schema(mut self, c: impl ConfigureNamespace + Send + Sync + 'static) -> Self {
         self.schema_configurator = Some(Box::new(c));
         self
     }

libsql-server/src/namespace/mod.rs

@@ -52,7 +52,7 @@ mod name;
 pub mod replication_wal;
 mod schema_lock;
 mod store;
-mod configurator;
+pub(crate) mod configurator;
 
 pub type ResetCb = Box<dyn Fn(ResetOp) + Send + Sync + 'static>;
 pub type ResolveNamespacePathFn =

libsql-server/src/namespace/store.rs

@@ -16,7 +16,6 @@ use crate::connection::config::DatabaseConfig;
 use crate::database::DatabaseKind;
 use crate::error::Error;
 use crate::metrics::NAMESPACE_LOAD_LATENCY;
-use crate::namespace::configurator::{PrimaryConfigurator, ReplicaConfigurator, SchemaConfigurator};
 use crate::namespace::{NamespaceBottomlessDbId, NamespaceBottomlessDbIdInit, NamespaceName};
 use crate::stats::Stats;
 
@@ -54,12 +53,13 @@ pub struct NamespaceStoreInner {
 }
 
 impl NamespaceStore {
-    pub async fn new(
+    pub(crate) async fn new(
         allow_lazy_creation: bool,
         snapshot_at_shutdown: bool,
         max_active_namespaces: usize,
         config: NamespaceConfig,
         metadata: MetaStore,
+        configurators: NamespaceConfigurators,
     ) -> crate::Result<Self> {
         tracing::trace!("Max active namespaces: {max_active_namespaces}");
         let store = Cache::<NamespaceName, NamespaceEntry>::builder()
@@ -84,12 +84,6 @@ impl NamespaceStore {
             .time_to_idle(Duration::from_secs(86400))
             .build();
 
-        let mut configurators = NamespaceConfigurators::default();
-        configurators
-            .with_primary(PrimaryConfigurator)
-            .with_replica(ReplicaConfigurator)
-            .with_schema(SchemaConfigurator);
-
         Ok(Self {
             inner: Arc::new(NamespaceStoreInner {
                 store,

libsql-server/src/schema/scheduler.rs

@@ -808,6 +808,9 @@ mod test {
 
     use crate::connection::config::DatabaseConfig;
     use crate::database::DatabaseKind;
+    use crate::namespace::configurator::{
+        NamespaceConfigurators, PrimaryConfigurator, SchemaConfigurator,
+    };
     use crate::namespace::meta_store::{metastore_connection_maker, MetaStore};
     use crate::namespace::{NamespaceConfig, RestoreOption};
     use crate::schema::SchedulerHandle;
@@ -826,9 +829,16 @@ mod test {
             .unwrap();
         let (sender, mut receiver) = mpsc::channel(100);
         let config = make_config(sender.clone().into(), tmp.path());
-        let store = NamespaceStore::new(false, false, 10, config, meta_store)
-            .await
-            .unwrap();
+        let store = NamespaceStore::new(
+            false,
+            false,
+            10,
+            config,
+            meta_store,
+            NamespaceConfigurators::default(),
+        )
+        .await
+        .unwrap();
         let mut scheduler = Scheduler::new(store.clone(), maker().unwrap())
             .await
             .unwrap();
@@ -936,9 +946,16 @@ mod test {
                 .unwrap();
             let (sender, mut receiver) = mpsc::channel(100);
             let config = make_config(sender.clone().into(), tmp.path());
-            let store = NamespaceStore::new(false, false, 10, config, meta_store)
-                .await
-                .unwrap();
+            let store = NamespaceStore::new(
+                false,
+                false,
+                10,
+                config,
+                meta_store,
+                NamespaceConfigurators::default(),
+            )
+            .await
+            .unwrap();
             let mut scheduler = Scheduler::new(store.clone(), maker().unwrap())
                 .await
                 .unwrap();
@@ -1012,7 +1029,7 @@ mod test {
             .unwrap();
         let (sender, _receiver) = mpsc::channel(100);
         let config = make_config(sender.clone().into(), tmp.path());
-        let store = NamespaceStore::new(false, false, 10, config, meta_store)
+        let store = NamespaceStore::new(false, false, 10, config, meta_store, NamespaceConfigurators::default())
             .await
             .unwrap();
 
@@ -1039,7 +1056,10 @@ mod test {
             .unwrap();
         let (sender, mut receiver) = mpsc::channel(100);
         let config = make_config(sender.clone().into(), tmp.path());
-        let store = NamespaceStore::new(false, false, 10, config, meta_store)
+        let configurators = NamespaceConfigurators::default()
+            .with_schema(SchemaConfigurator)
+            .with_primary(PrimaryConfigurator);
+        let store = NamespaceStore::new(false, false, 10, config, meta_store, configurators)
             .await
             .unwrap();
         let mut scheduler = Scheduler::new(store.clone(), maker().unwrap())
@@ -1112,7 +1132,7 @@ mod test {
             .unwrap();
         let (sender, _receiver) = mpsc::channel(100);
         let config = make_config(sender.clone().into(), tmp.path());
-        let store = NamespaceStore::new(false, false, 10, config, meta_store)
+        let store = NamespaceStore::new(false, false, 10, config, meta_store, NamespaceConfigurators::default())
             .await
             .unwrap();
         let scheduler = Scheduler::new(store.clone(), maker().unwrap())