wip: rename group -> realm

Author: cilki

Cargo.lock

@@ -15,7 +15,7 @@ members = [
   "sandpolis-deploy",
   "sandpolis-desktop",
   "sandpolis-filesystem",
-  "sandpolis-group",
+  "sandpolis-realm",
   "sandpolis-instance",
   "sandpolis-location",
   "sandpolis-macros",

Cargo.toml

@@ -148,7 +148,7 @@ use tracing::info;
 
 use crate::core::database::{Database, Document};
 use crate::core::layer::network::{ConnectionCooldown, ServerConnection};
-use crate::core::layer::server::group::GroupClientCert;
+use crate::core::layer::server::realm::RealmClientCert;
 use crate::core::layer::server::ServerAddress;
 use crate::CommandLine;
 
@@ -195,9 +195,9 @@ pub async fn main(args: CommandLine) -> Result<()> {
     };
 
     // Import certificate if it's newer than the one in the database
-    let cert_db: Option<Document<GroupClientCert>> = state.agent.data.get_document("/cert")?;
+    let cert_db: Option<Document<RealmClientCert>> = state.agent.data.get_document("/cert")?;
     let cert = if let Some(path) = args.certificate {
-        let cert_fs = GroupClientCert::read(path)?;
+        let cert_fs = RealmClientCert::read(path)?;
 
         match cert_db {
             Some(cert_db) => {

sandpolis-agent/src/agent/main.rs

@@ -216,42 +216,42 @@ mod test_instance_id {
     }
 }
 
-/// Groups have unique names and are shared across the entire cluster. Group
+/// Realms have unique names and are shared across the entire cluster. Realm
 /// names cannot be changed after they are created.
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash)]
-pub struct GroupName(String);
+pub struct RealmName(String);
 
-impl Default for GroupName {
+impl Default for RealmName {
     fn default() -> Self {
         Self("default".into())
     }
 }
 
-impl Display for GroupName {
+impl Display for RealmName {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str(&self.0)
     }
 }
 
-impl Deref for GroupName {
+impl Deref for RealmName {
     type Target = String;
 
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
-impl FromStr for GroupName {
+impl FromStr for RealmName {
     type Err = anyhow::Error;
 
     fn from_str(s: &str) -> Result<Self> {
-        let name = GroupName(s.to_string());
+        let name = RealmName(s.to_string());
         name.validate()?;
         Ok(name)
     }
 }
 
-impl Validate for GroupName {
+impl Validate for RealmName {
     fn validate(&self) -> Result<(), ValidationErrors> {
         if Regex::new("^[a-z0-9]{4,32}$").unwrap().is_match(&self.0) {
             Ok(())
@@ -261,36 +261,36 @@ impl Validate for GroupName {
     }
 }
 
-impl ToKey for GroupName {
+impl ToKey for RealmName {
     fn to_key(&self) -> native_db::Key {
         native_db::Key::new(self.0.as_bytes().to_vec())
     }
 
     fn key_names() -> Vec<String> {
-        vec!["GroupName".to_string()]
+        vec!["RealmName".to_string()]
     }
 }
 
 #[cfg(test)]
-mod test_group_name {
+mod test_realm_name {
     use super::*;
 
     #[test]
     fn test_valid() {
-        assert!("test".parse::<GroupName>().is_ok());
-        assert!("1default".parse::<GroupName>().is_ok());
-        assert!("default".parse::<GroupName>().is_ok());
-        assert!("default99".parse::<GroupName>().is_ok());
+        assert!("test".parse::<RealmName>().is_ok());
+        assert!("1default".parse::<RealmName>().is_ok());
+        assert!("default".parse::<RealmName>().is_ok());
+        assert!("default99".parse::<RealmName>().is_ok());
     }
 
     #[test]
     fn test_invalid() {
-        assert!("t".parse::<GroupName>().is_err());
-        assert!("".parse::<GroupName>().is_err());
-        assert!("test*".parse::<GroupName>().is_err());
+        assert!("t".parse::<RealmName>().is_err());
+        assert!("".parse::<RealmName>().is_err());
+        assert!("test*".parse::<RealmName>().is_err());
         assert!(
             "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-                .parse::<GroupName>()
+                .parse::<RealmName>()
                 .is_err()
         );
     }

sandpolis-core/src/lib.rs

@@ -9,7 +9,7 @@ use native_db::transaction::RTransaction;
 use native_db::transaction::query::SecondaryScanIterator;
 use native_db::watch::Event;
 use native_db::{Key, Models, ToInput, ToKey};
-use sandpolis_core::{GroupName, InstanceId};
+use sandpolis_core::{RealmName, InstanceId};
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, HashMap};
 use std::ops::Range;
@@ -27,7 +27,7 @@ pub mod config;
 pub struct DatabaseLayer {
     config: DatabaseConfig,
     models: &'static Models,
-    inner: Arc<RwLock<HashMap<Option<GroupName>, Arc<native_db::Database<'static>>>>>,
+    inner: Arc<RwLock<HashMap<Option<RealmName>, Arc<native_db::Database<'static>>>>>,
 }
 
 impl DatabaseLayer {
@@ -49,37 +49,37 @@ impl DatabaseLayer {
         })
     }
 
-    /// Load or create a new database for the given group.
-    pub async fn add_group(
+    /// Load or create a new database for the given realm.
+    pub async fn add_realm(
         &mut self,
-        name: GroupName,
+        name: RealmName,
     ) -> Result<Arc<native_db::Database<'static>>> {
         // Check for duplicates
         let mut inner = self.inner.write().await;
         if inner.contains_key(&Some(name.clone())) {
-            bail!("Duplicate group");
+            bail!("Duplicate realm");
         }
 
         let db = if let Some(path) = self.config.get_storage_dir()? {
             let path = path.join(format!("{name}.db"));
 
-            debug!(group = %name, path = %path.display(), "Initializing persistent group database");
+            debug!(realm = %name, path = %path.display(), "Initializing persistent realm database");
             Arc::new(native_db::Builder::new().create(self.models, path)?)
         } else {
-            debug!(group = %name, "Initializing ephemeral group database");
+            debug!(realm = %name, "Initializing ephemeral realm database");
             Arc::new(native_db::Builder::new().create_in_memory(self.models)?)
         };
         inner.insert(Some(name), db.clone());
 
         Ok(db)
     }
 
-    pub async fn get(&self, name: Option<GroupName>) -> Result<Arc<native_db::Database<'static>>> {
+    pub async fn get(&self, name: Option<RealmName>) -> Result<Arc<native_db::Database<'static>>> {
         let inner = self.inner.read().await;
         if let Some(db) = inner.get(&name) {
             return Ok(db.clone());
         }
-        bail!("Group not found");
+        bail!("Realm not found");
     }
 }
 
@@ -330,7 +330,7 @@ mod test_database {
             },
             models,
         )?;
-        database.add_group("default".parse()?).await?;
+        database.add_realm("default".parse()?).await?;
 
         let db = database.get(Some("default".parse()?)).await?;
         let watch: Watch<TestData> = Watch::singleton(db.clone())?;

sandpolis-database/src/lib.rs

@@ -11,7 +11,7 @@ tracing = { workspace = true }
 os_info = { workspace = true }
 russh = { workspace = true, optional = true }
 sandpolis-core = { path = "../sandpolis-core", version = "0.0.1" }
-sandpolis-group = { path = "../sandpolis-group", version = "0.0.1" }
+sandpolis-realm = { path = "../sandpolis-realm", version = "0.0.1" }
 sandpolis-macros = { path = "../sandpolis-macros", version = "0.0.1" }
 
 [features]

sandpolis-deploy/Cargo.toml

@@ -2,10 +2,10 @@
 //! install themselves on first execution. If an agent is already installed,
 //! the deployer overwrites the existing instance.
 //!
-//! Group certificates and configuration are embedded into the application for a
+//! Realm certificates and configuration are embedded into the application for a
 //! seamless install.
 
-use sandpolis_core::GroupName;
+use sandpolis_core::RealmName;
 
 pub enum SshCredentials {
     Password(String),
@@ -19,7 +19,7 @@ pub enum DeployTarget {
 }
 
 pub struct DeployConfig {
-    group: GroupName,
+    realm: RealmName,
     // message LoopConfig {
 
     //     // One or more network targets
@@ -60,7 +60,7 @@ pub struct DeployConfig {
     // bool memory = 14;
 }
 
-// Request to build an agent for the given group.
+// Request to build an agent for the given realm.
 pub struct BuildAgentRequest(DeployConfig);
 
 enum BuildDeployerResponse {

sandpolis-deploy/src/lib.rs

@@ -1,5 +1,5 @@
 pub struct CreateDeployerRequest {
     pub target: String,
     pub features: Vec<String>,
-    pub group: GroupName,
+    pub realm: RealmName,
 }

sandpolis-deploy/src/messages.rs

@@ -14,7 +14,7 @@ fuser = { version = "0.15.1", optional = true, features = ["serializable"] }
 notify = { version = "8.0.0", optional = true }
 tracing = { workspace = true }
 sandpolis-network = { path = "../sandpolis-network", version = "0.0.1" }
-sandpolis-group = { path = "../sandpolis-group", version = "0.0.1" }
+sandpolis-realm = { path = "../sandpolis-realm", version = "0.0.1" }
 sandpolis-core = { path = "../sandpolis-core", version = "0.0.1" }
 
 [features]