wip: allow CLI overrides for database layer

Author: cilki

Cargo.lock

@@ -4,11 +4,11 @@ use clap::Parser;
 pub struct ClientCommandLine {
     /// Run client graphical UI (even if invoked from a terminal)
     #[cfg(all(feature = "client-gui", feature = "client-tui"))]
-    #[clap(long, conflicts_with = "tui")]
+    #[clap(long, num_args = 0, conflicts_with = "tui")]
     pub gui: bool,
 
     /// Run client terminal UI
     #[cfg(all(feature = "client-gui", feature = "client-tui"))]
-    #[clap(long, conflicts_with = "gui")]
+    #[clap(long, num_args = 0, conflicts_with = "gui")]
     pub tui: bool,
 }

sandpolis-client/src/cli.rs

@@ -7,6 +7,8 @@ version = "0.0.1"
 
 [dependencies]
 anyhow = { workspace = true }
+bevy = { workspace = true, optional = true }
+clap = { workspace = true }
 colored = { workspace = true }
 native_db = { workspace = true }
 native_model = { workspace = true }
@@ -15,7 +17,6 @@ serde = { workspace = true }
 strum = { workspace = true }
 uuid = { workspace = true }
 validator = { workspace = true }
-bevy = { workspace = true, optional = true }
 
 [features]
 server = []

sandpolis-core/Cargo.toml

@@ -1,8 +1,9 @@
 use anyhow::Result;
+use clap::Parser;
 use colored::Color;
 use native_db::ToKey;
 use regex::Regex;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize, de::DeserializeOwned};
 use std::fmt::{Display, Write};
 use std::ops::Deref;
 use std::str::FromStr;
@@ -350,3 +351,21 @@ impl ToKey for UserName {
         vec!["UserName".to_string()]
     }
 }
+
+/// A config fragment that can take overrides from the command line or from
+/// the process environment.
+pub trait LayerConfig<C>
+where
+    C: Parser,
+    Self: Serialize + DeserializeOwned,
+{
+    /// Override the config with values from the command line
+    fn override_cli(&mut self, args: &C) {
+        // Default no-op
+    }
+
+    /// Override the config with values from the environment
+    fn override_env(&mut self) {
+        // Default no-op
+    }
+}

sandpolis-core/src/lib.rs

@@ -0,0 +1,8 @@
+use clap::Parser;
+
+#[derive(Parser, Debug, Clone, Default)]
+pub struct DatabaseCommandLine {
+    /// Don't persist any data
+    #[clap(long, num_args = 0)]
+    pub ephemeral: bool,
+}

sandpolis-database/src/cli.rs

@@ -1,8 +1,12 @@
 use anyhow::{Result, bail};
+use sandpolis_core::LayerConfig;
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
+use tracing::trace;
 use validator::Validate;
 
+use crate::cli::DatabaseCommandLine;
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct DatabaseConfig {
     /// Override default storage directory
@@ -32,6 +36,16 @@ impl Default for DatabaseConfig {
     }
 }
 
+impl LayerConfig<DatabaseCommandLine> for DatabaseConfig {
+    fn override_cli(&mut self, args: &DatabaseCommandLine) {
+        if args.ephemeral {
+            trace!("Overriding ephemeral flag from CLI");
+            self.ephemeral = true;
+            self.storage = None;
+        }
+    }
+}
+
 impl DatabaseConfig {
     /// Create the storage directory if needed.
     pub fn get_storage_dir(&self) -> Result<Option<PathBuf>> {

sandpolis-database/src/config.rs

@@ -20,6 +20,7 @@ use std::sync::{RwLock, RwLockReadGuard};
 use tokio_util::sync::CancellationToken;
 use tracing::{debug, trace, warn};
 
+pub mod cli;
 pub mod config;
 
 /// This layer manages separate databases for each realm.
@@ -37,6 +38,8 @@ pub struct DatabaseLayer {
 impl DatabaseLayer {
     /// Create a new `DatabaseLayer` initialized with the default realm.
     pub fn new(config: DatabaseConfig, models: &'static Models) -> Result<Self> {
+        debug!("Initializing database layer");
+
         let default = if let Some(path) = config.get_storage_dir()? {
             let path = path.join("default.db");
 
@@ -149,11 +152,10 @@ impl RealmDatabase {
         } else {
             // Otherwise, watch the upper half of the primary ID which is the same for all
             // revisions
-            self.0
-                .watch()
-                .scan()
-                .primary()
-                .range::<T, _>(item.id() & 0x0000_0000..=item.id() | 0xFFFF_FFFF)?
+            self.0.watch().scan().primary().range::<T, _>(
+                DataIdentifier((item.id().revision_id() as u64) << 32)
+                    ..=DataIdentifier(((item.id().revision_id() as u64) << 32) | 0xFFFF_FFFF),
+            )?
         };
 
         // Safe to end the transaction once the watcher is registered
@@ -410,7 +412,36 @@ impl ToKey for DataRevision {
 
 /// Uniquely identifies a record in the database. All revisions of the same
 /// `Data` share the upper 4 bytes of this value.
-pub type DataIdentifier = u64; // TODO tuple struct
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Copy, Clone, PartialOrd, Ord)]
+pub struct DataIdentifier(u64);
+
+impl Default for DataIdentifier {
+    fn default() -> Self {
+        Self(rand::rng().next_u64())
+    }
+}
+
+impl ToKey for DataIdentifier {
+    fn to_key(&self) -> native_db::Key {
+        self.0.to_key()
+    }
+
+    fn key_names() -> Vec<String> {
+        vec!["DataIdentifier".to_string()]
+    }
+}
+
+impl DataIdentifier {
+    /// Create a new `DataIdentifier` for a revision based on this one.
+    fn new_revision(&self) -> Self {
+        Self((self.0 & 0x0000_0000) | (0xFFFF_FFFF & rand::rng().next_u64()))
+    }
+
+    /// Get the portion of the `DataIdentifier` shared across all revisions
+    fn revision_id(&self) -> u32 {
+        ((self.0 >> 32) & 0xFFFF_FFFF) as u32
+    }
+}
 
 /// When some `Data` will expire and no longer be returnable by queries.
 /// Eventually it will be removed from the database altogether.
@@ -534,9 +565,7 @@ impl<T: Data> Resident<T> {
 
         if previous.expiration().is_some() {
             // Derive new id from the previous
-            next.set_id(
-                (previous.id() & 0x0000_0000) | (0xFFFF_FFFF & rand::rng().random::<u64>()),
-            );
+            next.set_id(previous.id().new_revision());
 
             rw.insert(next.clone())?;
             rw.upsert(previous.clone())?;
@@ -551,7 +580,7 @@ impl<T: Data> Resident<T> {
     }
 
     pub fn history(&self, range: impl RangeBounds<DataCreation>) -> Result<Vec<T>> {
-        let revision_id = self.read().id() & 0x0000_0000;
+        let revision_id = self.read().id().revision_id();
 
         let r = self.db.r_transaction()?;
 
@@ -566,7 +595,7 @@ impl<T: Data> Resident<T> {
 
         Ok(items
             .into_iter()
-            .filter(|item| (item.id() & 0x0000_0000) == revision_id)
+            .filter(|item| item.id().revision_id() == revision_id)
             .collect())
     }
 }
@@ -601,16 +630,15 @@ mod test_resident {
     async fn test_data() -> Result<()> {
         let database = test_db!(TestData);
 
-        let db = database.realm(RealmName::default()).await?;
+        let db = database.realm(RealmName::default())?;
         let res: Resident<TestData> = db.resident(DataCondition::equal(TestDataKey::a, "A"))?;
 
         // Update data a bunch of times
         for i in 1..10 {
             res.update(|data| {
                 data.a = format!("test {i}");
                 Ok(())
-            })
-            .await?;
+            })?;
         }
 
         // Resident should reflect "test 9"
@@ -649,16 +677,15 @@ mod test_resident {
     async fn test_temporal_data() -> Result<()> {
         let database = test_db!(TestHistoryData);
 
-        let db = database.realm(RealmName::default()).await?;
+        let db = database.realm(RealmName::default())?;
         let res: Resident<TestHistoryData> = db.resident(())?;
 
         // Update data a bunch of times
         for i in 1..10 {
             res.update(|data| {
                 data.b = format!("test {i}");
                 Ok(())
-            })
-            .await?;
+            })?;
         }
 
         // Database should have 10 items
@@ -670,7 +697,7 @@ mod test_resident {
 
         // Check history
         {
-            assert_eq!(res.history(DataCreation::all()).await?.len(), 10);
+            assert_eq!(res.history(DataCreation::all())?.len(), 10);
         }
 
         Ok(())
@@ -707,8 +734,8 @@ impl<T: Data> ResidentVec<T> {
                     assert!(
                         self.conditions
                             .first()
-                            .expect("There must be at least one condition")
-                            .check(&d)
+                            .map(|condition| condition.check(&d))
+                            .unwrap_or(true)
                     );
 
                     // Make sure the remaining conditions are satisfied
@@ -920,30 +947,27 @@ mod test_resident_vec {
     async fn test_nonhistorical() -> Result<()> {
         let database = test_db!(TestData);
 
-        let db = database.realm(RealmName::default()).await?;
+        let db = database.realm(RealmName::default())?;
         let test_data: ResidentVec<TestData> =
             db.resident_vec(DataCondition::equal(TestDataKey::b, "B"))?;
 
-        assert_eq!(test_data.len().await, 0);
+        assert_eq!(test_data.len(), 0);
 
         // Add item
-        let data: Resident<TestData> = test_data
-            .push(TestData {
-                a: "A".to_string(),
-                b: "B".to_string(),
-                ..Default::default()
-            })
-            .await?;
+        let data: Resident<TestData> = test_data.push(TestData {
+            a: "A".to_string(),
+            b: "B".to_string(),
+            ..Default::default()
+        })?;
 
-        assert_eq!(test_data.len().await, 1);
+        assert_eq!(test_data.len(), 1);
 
         // Update a bunch of times
         for i in 1..10 {
             data.update(|d| {
                 d.a = format!("test {i}");
                 Ok(())
-            })
-            .await?;
+            })?;
         }
 
         // Database should reflect "test 9"

sandpolis-database/src/lib.rs

@@ -1,5 +1,4 @@
 use anyhow::Result;
-use clap::Parser;
 use native_db::ToKey;
 use native_model::Model;
 use sandpolis_core::{ClusterId, InstanceId, RealmName};
@@ -74,21 +73,3 @@ impl PartialOrd for LayerVersion {
         }
     }
 }
-
-/// A config fragment that can take overrides from the command line or from
-/// the process environment.
-pub trait OverridableConfig<C>
-where
-    C: Parser,
-    Self: Serialize + DeserializeOwned,
-{
-    /// Override the config with values from the command line
-    fn override_cli(&mut self, args: &C) {
-        // Default no-op
-    }
-
-    /// Override the config with values from the environment
-    fn override_env(&mut self) {
-        // Default no-op
-    }
-}

sandpolis-instance/src/lib.rs

@@ -42,12 +42,12 @@ private void startForeground() {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
                 type = ServiceInfo.FOREGROUND_SERVICE_TYPE_CAMERA;
             }
-            ServiceCompat.startForeground(
-                    /* service = */ this,
-                    /* id = */ 100, // Cannot be 0
-                    /* notification = */ notification,
-                    /* foregroundServiceType = */ type
-            );
+            // ServiceCompat.startForeground(
+            //         /* service = */ this,
+            //         /* id = */ 100, // Cannot be 0
+            //         /* notification = */ notification,
+            //         /* foregroundServiceType = */ type
+            // );
         } catch (Exception e) {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S &&
                     e instanceof ForegroundServiceStartNotAllowedException

sandpolis-mobile/android/app/src/main/java/org/sandpolis/mobile/AgentService.java

@@ -1,5 +1,5 @@
 use crate::{ServerAddress, cli::NetworkCommandLine};
-use sandpolis_instance::OverridableConfig;
+use sandpolis_core::LayerConfig;
 use serde::{Deserialize, Serialize};
 use tracing::debug;
 
@@ -17,7 +17,7 @@ pub struct NetworkLayerConfig {
     pub poll: Option<String>,
 }
 
-impl OverridableConfig<NetworkCommandLine> for NetworkLayerConfig {
+impl LayerConfig<NetworkCommandLine> for NetworkLayerConfig {
     fn override_env(&mut self) {
         match std::env::var("S7S_SERVER") {
             Ok(server) => {