wip: continue db refactor

Author: cilki

Cargo.lock

@@ -218,7 +218,7 @@ mod test_instance_id {
 
 /// Groups have unique names and are shared across the entire cluster. Group
 /// names cannot be changed after they are created.
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash)]
 pub struct GroupName(String);
 
 impl Display for GroupName {

sandpolis-core/src/lib.rs

@@ -7,13 +7,14 @@ version = "0.0.1"
 
 [dependencies]
 anyhow = { workspace = true }
-clap = { workspace = true }
 chrono = { workspace = true }
-serde_cbor = { workspace = true }
-serde = { workspace = true }
-tracing = { workspace = true }
-tempfile = { workspace = true }
+clap = { workspace = true }
 native_db = { workspace = true }
 native_model = { workspace = true }
 sandpolis-core = { path = "../sandpolis-core", version = "0.0.1" }
 sandpolis-macros = { path = "../sandpolis-macros", version = "0.0.1" }
+serde_cbor = { workspace = true }
+serde = { workspace = true }
+tempfile = { workspace = true }
+tracing = { workspace = true }
+validator = { workspace = true }

sandpolis-database/Cargo.toml

@@ -1,30 +1,59 @@
-use anyhow::{bail, Result};
+use anyhow::{Result, bail};
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
+use validator::Validate;
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct DatabaseConfig {
-    /// Storage directory
-    pub storage: PathBuf,
+    /// Override default storage directory
+    pub storage: Option<PathBuf>,
+
+    /// Don't persist any data
+    pub ephemeral: bool,
+}
+
+impl Validate for DatabaseConfig {
+    fn validate(&self) -> std::result::Result<(), validator::ValidationErrors> {
+        if self.ephemeral && self.storage.is_some() {
+            // TODO don't allow
+        }
+
+        Ok(())
+    }
 }
 
 impl Default for DatabaseConfig {
     fn default() -> Self {
         Self {
-            storage: "/tmp".into(),
+            // TODO platform specific
+            storage: Some("/tmp".into()),
+            ephemeral: false,
         }
     }
 }
 
 impl DatabaseConfig {
     /// Create the storage directory if needed.
-    pub fn create_storage_dir(&self) -> Result<()> {
-        if !std::fs::exists(&self.storage)? {
-            std::fs::create_dir_all(&self.storage)?;
+    pub fn get_storage_dir(&self) -> Result<Option<PathBuf>> {
+        if let Some(path) = self.storage.clone() {
+            if !std::fs::exists(&path)? {
+                std::fs::create_dir_all(&path)?;
+            } else if !std::fs::metadata(&path)?.is_dir() {
+                bail!("Storage directory must be a directory");
+            }
+            Ok(Some(path))
+        } else {
+            if self.ephemeral {
+                Ok(None)
+            } else {
+                let path = Self::default().storage.unwrap();
+                if !std::fs::exists(&path)? {
+                    std::fs::create_dir_all(&path)?;
+                } else if !std::fs::metadata(&path)?.is_dir() {
+                    bail!("Storage directory must be a directory");
+                }
+                Ok(Some(path))
+            }
         }
-        if !std::fs::metadata(&self.storage)?.is_dir() {
-            bail!("Storage directory must be a directory");
-        }
-        Ok(())
     }
 }