wip: add initial DatabaseBuilder

Author: cilki

Cargo.lock

@@ -46,8 +46,8 @@ colored = "3.0.0"
 futures = "0.3.30"
 futures-util = "0.3.31"
 image = "0.25.5"
-native_db = "0.8.1"
-native_model = "0.4.20"
+native_db = { git = "https://github.com/cilki/native_db" }
+native_model = "0.6.1"
 os_info = "3.8.2"
 pem = "3.0.4"
 rand = "0.9.0"

Cargo.toml

@@ -1,5 +1,5 @@
 use crate::oid::Oid;
-use anyhow::{Result, anyhow};
+use anyhow::{Result, anyhow, bail};
 use chrono::{DateTime, Utc};
 use native_db::{Models, ToKey};
 use serde::de::DeserializeOwned;
@@ -8,245 +8,76 @@ use sled::transaction::ConflictableTransactionError::Abort;
 use std::ops::Range;
 use std::path::Path;
 use std::{marker::PhantomData, sync::Arc};
-use tempfile::{TempDir, tempdir};
 use tracing::{debug, trace};
 
 pub mod config;
 pub mod oid;
 
-#[derive(Clone)]
-pub struct Database(pub Arc<native_db::Database<'static>>);
-
-impl Database {
-    /// Initialize a new memory-only database.
-    pub fn new_ephemeral(models: &'static Models) -> Result<Self> {
-        debug!("Initializing ephemeral database");
-        Ok(Self(Arc::new(
-            native_db::Builder::new().create_in_memory(models)?,
-        )))
-    }
-
-    /// Initialize a new persistent database from the given directory.
-    pub fn new<P>(models: &'static Models, path: P) -> Result<Self>
-    where
-        P: AsRef<Path>,
-    {
-        let path = path.as_ref();
-
-        debug!(path = %path.display(), "Initializing persistent database");
-        Ok(Self(Arc::new(
-            native_db::Builder::new().create(models, path)?,
-        )))
-    }
-}
-
-#[derive(Clone)]
-pub struct Collection<T>
-where
-    T: Serialize + DeserializeOwned,
-{
-    db: sled::Tree,
-    oid: Oid,
-    data: PhantomData<T>,
-}
-
-impl<T: Serialize + DeserializeOwned + std::fmt::Debug> Collection<T> {
-    pub fn get_document(&self, oid: impl TryInto<Oid>) -> Result<Option<Document<T>>> {
-        let oid = self.oid.extend(oid)?;
-
-        Ok(if let Some(data) = self.db.get(&oid)? {
-            Some(Document {
-                db: self.db.clone(),
-                data: serde_cbor::from_slice::<T>(&data)?,
-                oid,
-            })
-        } else {
-            None
-        })
-    }
-
-    pub fn documents(&self) -> impl Iterator<Item = Result<Document<T>>> + use<'_, T> {
-        trace!(oid = %self.oid, "Querying collection");
-        let mut start = self.oid.0.clone();
-        start.push('/' as u8);
-        let mut end = start.clone();
-        end.push(0xff);
-
-        self.db
-            .range::<&[u8], Range<&[u8]>>(&start..&end)
-            .map(|r| match r {
-                Ok((key, value)) => match (key.try_into(), serde_cbor::from_slice::<T>(&value)) {
-                    (Ok(oid), Ok(data)) => {
-                        trace!(oid = %oid, "Yielding document");
-                        Ok(Document {
-                            db: self.db.clone(),
-                            oid,
-                            data,
-                        })
-                    }
-                    (Ok(_), Err(_)) => todo!(),
-                    (Err(_), Ok(_)) => todo!(),
-                    (Err(_), Err(_)) => todo!(),
-                },
-                Err(_) => todo!(),
-            })
-    }
-
-    pub fn collection<U>(&self, oid: impl TryInto<Oid>) -> Result<Collection<U>>
-    where
-        U: Serialize + DeserializeOwned,
-    {
-        Ok(Collection {
-            db: self.db.clone(),
-            oid: self.oid.extend(oid)?,
-            data: PhantomData {},
-        })
-    }
-
-    pub fn insert_document(&self, oid: impl TryInto<Oid>, data: T) -> Result<Document<T>> {
-        let oid = self.oid.extend(oid)?;
-        let d = serde_cbor::to_vec(&data)?;
-
-        trace!(oid = %oid, data = ?data, "Inserting new document");
-        self.db
-            .transaction(|tx_db| {
-                if tx_db.get(&oid)?.is_some() {
-                    return Err(Abort(anyhow::anyhow!("Already exists")));
-                }
-
-                tx_db.insert(oid.clone(), d.clone())?;
-                Ok(())
-            })
-            .map_err(|_| anyhow::anyhow!(""))?;
-
-        Ok(Document {
-            oid,
-            data,
-            db: self.db.clone(),
-        })
-    }
+pub struct DatabaseBuilder {
+    models: &'static Models,
+    groups: Vec<(String, native_db::Database<'static>)>,
 }
 
-impl<T: Serialize + DeserializeOwned + Default> Collection<T> {
-    pub fn document(&self, oid: impl TryInto<Oid>) -> Result<Document<T>> {
-        let oid = self.oid.extend(oid)?;
-
-        Ok(Document {
-            db: self.db.clone(),
-            data: if let Some(data) = self.db.get(&oid)? {
-                serde_cbor::from_slice::<T>(&data)?
-            } else {
-                // TODO insert
-                T::default()
-            },
-            oid,
-        })
+impl DatabaseBuilder {
+    pub fn new(models: &'static Models) -> Self {
+        Self {
+            models,
+            // Don't bother with a map because groups are few
+            groups: Vec::with_capacity(1),
+        }
     }
-}
 
-#[derive(Clone)]
-pub struct Document<T>
-where
-    T: Serialize + DeserializeOwned,
-{
-    pub db: sled::Tree,
-    pub oid: Oid,
-    pub data: T, // TODO impl AsRef?
-}
+    /// Create a new ephemeral database for the given group name.
+    pub fn add_ephemeral(mut self, group: impl ToString) -> Result<Self> {
+        let name = group.to_string();
 
-impl<T: Serialize + DeserializeOwned> Document<T> {
-    // pub fn update<U>(&mut self, update: )
-
-    pub fn get_document<U>(&self, oid: impl TryInto<Oid>) -> Result<Option<Document<U>>>
-    where
-        U: Serialize + DeserializeOwned,
-    {
-        let oid = self.oid.extend(oid)?;
-
-        Ok(if let Some(data) = self.db.get(&oid)? {
-            Some(Document {
-                db: self.db.clone(),
-                data: serde_cbor::from_slice::<U>(&data)?,
-                oid,
-            })
-        } else {
-            None
-        })
-    }
+        // Check for duplicates
+        for (n, _) in self.groups.iter() {
+            if name == *n {
+                bail!("Duplicate group");
+            }
+        }
 
-    pub fn document<U>(&self, oid: impl TryInto<Oid>) -> Result<Document<U>>
-    where
-        U: Serialize + DeserializeOwned + Default,
-    {
-        let oid = self.oid.extend(oid)?;
+        debug!(group = name, "Initializing ephemeral database");
+        self.groups.push((
+            name,
+            native_db::Builder::new().create_in_memory(self.models)?,
+        ));
 
-        Ok(Document {
-            db: self.db.clone(),
-            data: if let Some(data) = self.db.get(&oid)? {
-                trace!(oid = %oid, "Loading document");
-                serde_cbor::from_slice::<U>(&data)?
-            } else {
-                trace!(oid = %oid, "Creating new document");
-                // TODO insert
-                U::default()
-            },
-            oid,
-        })
+        Ok(self)
     }
 
-    pub fn insert_document<U>(&self, oid: impl TryInto<Oid>, data: U) -> Result<Document<U>>
+    /// Load or create a new persistent database for the given group name.
+    pub fn add_persistent<P>(mut self, group: impl ToString, path: P) -> Result<Self>
     where
-        U: Serialize + DeserializeOwned + std::fmt::Debug,
+        P: AsRef<Path>,
     {
-        let oid = self.oid.extend(oid)?;
-        let d = serde_cbor::to_vec(&data)?;
+        let name = group.to_string();
+        let path = path.as_ref();
 
-        trace!(oid = %oid, data = ?data, "Inserting new document");
-        self.db
-            .transaction(|tx_db| {
-                if tx_db.get(&oid)?.is_some() {
-                    return Err(Abort(anyhow::anyhow!("Already exists")));
-                }
+        // Check for duplicates
+        for (n, _) in self.groups.iter() {
+            if name == *n {
+                bail!("Duplicate group");
+            }
+        }
 
-                tx_db.insert(oid.clone(), d.clone())?;
-                Ok(())
-            })
-            .map_err(|_| anyhow::anyhow!(""))?;
+        debug!(group = name, path = %path.display(), "Initializing persistent database");
+        self.groups
+            .push((name, native_db::Builder::new().create(self.models, path)?));
 
-        Ok(Document {
-            oid,
-            data,
-            db: self.db.clone(),
-        })
+        Ok(self)
     }
 
-    pub fn collection<U>(&self, oid: impl TryInto<Oid>) -> Result<Collection<U>>
-    where
-        U: Serialize + DeserializeOwned,
-    {
-        Ok(Collection {
-            db: self.db.clone(),
-            oid: self.oid.extend(oid)?,
-            data: PhantomData {},
-        })
+    pub fn build(self) -> Database {
+        Database(Arc::new(self.groups))
     }
 }
 
-impl<T: Serialize + DeserializeOwned + Clone> Document<T> {
-    pub fn mutate<F>(&mut self, mutator: F) -> Result<()>
-    where
-        F: Fn(&mut T) -> Result<()>,
-    {
-        // Create a copy so we can tell what changed
-        let mut object = self.data.clone();
-        mutator(&mut object)?;
-
-        // TODO detect changes and update history as part of a transaction
+#[derive(Clone)]
+pub struct Database(Arc<Vec<(String, native_db::Database<'static>)>>);
 
-        self.db.insert(&self.oid, serde_cbor::to_vec(&object)?)?;
-        Ok(())
-    }
-}
+impl Database {}
 
 // TODO Eq based only on inner?
 #[derive(Serialize, Deserialize, Eq, PartialEq, Debug, Clone, Hash)]

sandpolis-database/src/lib.rs

@@ -20,6 +20,7 @@ clap = { workspace = true }
 colored = { workspace = true }
 fossable = "0.1.2"
 futures = { workspace = true }
+native_db = { workspace = true }
 rand = { workspace = true }
 rustls = { workspace = true }
 sandpolis-agent = { path = "../sandpolis-agent", version = "0.0.1" }