instanciate namesapces from configurators

Author: MarinPostma

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

@@ -8,14 +8,19 @@ use super::{NamespaceConfig, NamespaceName, NamespaceStore, ResetCb, ResolveName
 
 mod replica;
 mod primary;
+mod schema;
 
-type DynConfigurator = Box<dyn ConfigureNamespace + Send + Sync + 'static>;
+pub use replica::ReplicaConfigurator;
+pub use primary::PrimaryConfigurator;
+pub use schema::SchemaConfigurator;
+
+type DynConfigurator = dyn ConfigureNamespace + Send + Sync + 'static;
 
 #[derive(Default)]
 pub(crate) struct NamespaceConfigurators {
-    replica_configurator: Option<DynConfigurator>,
-    primary_configurator: Option<DynConfigurator>,
-    schema_configurator: Option<DynConfigurator>,
+    replica_configurator: Option<Box<DynConfigurator>>,
+    primary_configurator: Option<Box<DynConfigurator>>,
+    schema_configurator: Option<Box<DynConfigurator>>,
 }
 
 impl NamespaceConfigurators {
@@ -39,6 +44,18 @@ impl NamespaceConfigurators {
         self.schema_configurator = Some(Box::new(c));
         self
     }
+
+    pub fn configure_schema(&self) -> crate::Result<&DynConfigurator> {
+        self.schema_configurator.as_deref().ok_or_else(|| todo!())
+    }
+
+    pub fn configure_primary(&self) -> crate::Result<&DynConfigurator> {
+        self.primary_configurator.as_deref().ok_or_else(|| todo!())
+    }
+
+    pub fn configure_replica(&self) -> crate::Result<&DynConfigurator> {
+        self.replica_configurator.as_deref().ok_or_else(|| todo!())
+    }
 }
 
 pub trait ConfigureNamespace {

libsql-server/src/namespace/fork.rs

@@ -12,14 +12,12 @@ use tokio::io::{AsyncSeekExt, AsyncWriteExt};
 use tokio::time::Duration;
 use tokio_stream::StreamExt;
 
-use crate::namespace::ResolveNamespacePathFn;
 use crate::replication::primary::frame_stream::FrameStream;
 use crate::replication::{LogReadError, ReplicationLogger};
 use crate::{BLOCKING_RT, LIBSQL_PAGE_SIZE};
 
-use super::broadcasters::BroadcasterHandle;
 use super::meta_store::MetaStoreHandle;
-use super::{Namespace, NamespaceConfig, NamespaceName, NamespaceStore, RestoreOption};
+use super::{NamespaceName, NamespaceStore, RestoreOption};
 
 type Result<T> = crate::Result<T, ForkError>;
 
@@ -54,24 +52,21 @@ async fn write_frame(frame: &FrameBorrowed, temp_file: &mut tokio::fs::File) ->
     Ok(())
 }
 
-pub struct ForkTask<'a> {
+pub struct ForkTask {
     pub base_path: Arc<Path>,
     pub logger: Arc<ReplicationLogger>,
     pub to_namespace: NamespaceName,
     pub to_config: MetaStoreHandle,
     pub restore_to: Option<PointInTimeRestore>,
-    pub ns_config: &'a NamespaceConfig,
-    pub resolve_attach: ResolveNamespacePathFn,
     pub store: NamespaceStore,
-    pub broadcaster: BroadcasterHandle,
 }
 
 pub struct PointInTimeRestore {
     pub timestamp: NaiveDateTime,
     pub replicator_options: bottomless::replicator::Options,
 }
 
-impl<'a> ForkTask<'a> {
+impl ForkTask {
     pub async fn fork(self) -> Result<super::Namespace> {
         let base_path = self.base_path.clone();
         let dest_namespace = self.to_namespace.clone();
@@ -105,18 +100,9 @@ impl<'a> ForkTask<'a> {
         let dest_path = self.base_path.join("dbs").join(self.to_namespace.as_str());
         tokio::fs::rename(temp_dir.path(), dest_path).await?;
 
-        Namespace::from_config(
-            self.ns_config,
-            self.to_config.clone(),
-            RestoreOption::Latest,
-            &self.to_namespace,
-            Box::new(|_op| {}),
-            self.resolve_attach.clone(),
-            self.store.clone(),
-            self.broadcaster,
-        )
-        .await
-        .map_err(|e| ForkError::CreateNamespace(Box::new(e)))
+        self.store.make_namespace(&self.to_namespace, self.to_config, RestoreOption::Latest)
+            .await
+            .map_err(|e| ForkError::CreateNamespace(Box::new(e)))
     }
 
     /// Restores the database state from a local log file.