wip: fix some server-side compile errors

cilki · cilki · commit 3b7fe7d1ee5f · 2025-07-05T22:35:47.000-05:00
diff --git a/sandpolis-database/src/lib.rs b/sandpolis-database/src/lib.rs
@@ -824,11 +824,14 @@ impl DataCondition {
         }
     }
 
-    fn equal(key: impl ToKeyDefinition<KeyOptions>, value: impl ToKey) -> Self {
+    pub fn equal(key: impl ToKeyDefinition<KeyOptions>, value: impl ToKey) -> Self {
         Self::Equal(key.key_definition(), value.to_key())
     }
 
-    fn range<R: RangeBounds<impl ToKey>>(key: impl ToKeyDefinition<KeyOptions>, value: R) -> Self {
+    pub fn range<R: RangeBounds<impl ToKey>>(
+        key: impl ToKeyDefinition<KeyOptions>,
+        value: R,
+    ) -> Self {
         Self::Range(key.key_definition(), KeyRange::new(value))
     }
 }
diff --git a/sandpolis-filesystem/Cargo.toml b/sandpolis-filesystem/Cargo.toml
@@ -19,7 +19,9 @@ sandpolis-core = { path = "../sandpolis-core", version = "0.0.1" }
 
 [features]
 agent = ["dep:notify"]
-client = ["dep:fuser"]
+client = [
+  #"dep:fuser"
+]
 client-gui = ["client"]
 client-tui = ["client"]
 server = []
diff --git a/sandpolis-realm/src/lib.rs b/sandpolis-realm/src/lib.rs
@@ -11,6 +11,7 @@ use native_model::Model;
 use pem::Pem;
 use pem::encode;
 use sandpolis_core::{RealmName, UserName};
+use sandpolis_database::RealmDatabase;
 use sandpolis_database::ResidentVec;
 use sandpolis_database::{DatabaseLayer, Resident};
 use sandpolis_instance::InstanceLayer;
@@ -35,8 +36,9 @@ pub struct RealmLayerData {
 
 #[derive(Clone)]
 pub struct RealmLayer {
+    database: DatabaseLayer,
     data: Resident<RealmLayerData>,
-    realms: ResidentVec<RealmData>,
+    pub realms: ResidentVec<RealmData>,
 }
 
 impl RealmLayer {
@@ -53,16 +55,15 @@ impl RealmLayer {
 
         #[cfg(feature = "server")]
         {
-            let cluster_cert = RealmClusterCert::new(
-                instance_layer.data.value().cluster_id,
-                RealmName::default(),
-            )?;
-            let server_cert = cluster_cert.server_cert(instance_layer.data.value().instance_id)?;
-
-            let rw = realm_db.rw_transaction()?;
-            rw.insert(cluster_cert)?;
-            rw.insert(server_cert)?;
-            rw.commit()?;
+            // let cluster_cert =
+            //     RealmClusterCert::new(instance.data.value().cluster_id,
+            // RealmName::default())?; let server_cert =
+            // cluster_cert.server_cert(instance.data.value().instance_id)?;
+
+            // let rw = realm_db.rw_transaction()?;
+            // rw.insert(cluster_cert)?;
+            // rw.insert(server_cert)?;
+            // rw.commit()?;
         }
 
         // Update client cert if possible
@@ -82,10 +83,21 @@ impl RealmLayer {
         // }
 
         Ok(Self {
+            database,
             data: default_realm.resident(())?,
             realms,
         })
     }
+
+    pub async fn realm(&self, name: RealmName) -> Result<RealmDatabase> {
+        // Don't allow this method to create realms that don't already exist
+        for realm in self.realms.iter().await {
+            if realm.read().await.name == name {
+                return Ok(self.database.realm(name).await?);
+            }
+        }
+        bail!("Realm does not exist");
+    }
 }
 
 /// A realm is a set of clients and agents that can interact. Each realm has a
@@ -110,7 +122,7 @@ pub struct RealmClusterCert {
 }
 
 /// Each server in the cluster gets its own server certificate.
-#[data]
+#[data(instance)]
 pub struct RealmServerCert {
     pub cert: Vec<u8>,
     pub key: Option<Vec<u8>>,
@@ -250,17 +262,17 @@ impl RealmClientCert {
 
 #[cfg(test)]
 mod test_client_cert {
-    use super::RealmClientCert;
+    use super::*;
 
     #[test]
     fn test_read_write() -> Result<()> {
         let mut temp_file = tempfile::NamedTempFile::new()?;
 
         let cert = RealmClientCert {
-            ca: "doesn't have to be a valid cert".bytes(),
-            cert: "doesn't have to be a valid cert".bytes(),
-            key: Some("doesn't have to be a valid key".bytes()),
-            _id: 0,
+            ca: "doesn't have to be a valid cert".as_bytes().to_vec(),
+            cert: "doesn't have to be a valid cert".as_bytes().to_vec(),
+            key: Some("doesn't have to be a valid key".as_bytes().to_vec()),
+            ..Default::default()
         };
 
         cert.write(temp_file.path())?;
diff --git a/sandpolis-realm/src/server.rs b/sandpolis-realm/src/server.rs
@@ -1,3 +1,6 @@
+use crate::RealmLayer;
+use crate::RealmServerCertKey;
+
 use super::RealmClientCert;
 use super::RealmClusterCert;
 use super::RealmData;
@@ -31,16 +34,18 @@ use rustls_pki_types::pem::PemObject;
 use sandpolis_core::ClusterId;
 use sandpolis_core::InstanceId;
 use sandpolis_core::InstanceType;
+use sandpolis_database::DataCondition;
+use sandpolis_database::Resident;
+use sandpolis_instance::InstanceLayer;
 use std::io;
 use std::sync::Arc;
-use tempfile::TempDir;
-use tempfile::tempdir;
 use time::Duration;
 use time::OffsetDateTime;
 use tokio::io::{AsyncRead, AsyncWrite};
 use tokio_rustls::server::TlsStream;
 use tower::Layer;
 use tracing::debug;
+use tracing::trace;
 use x509_parser::prelude::{FromDer, X509Certificate};
 
 impl super::RealmClusterCert {
@@ -225,44 +230,46 @@ pub struct TlsData {
 pub struct RealmAcceptor(RustlsAcceptor);
 
 impl RealmAcceptor {
-    pub fn new(realms: Vec<RealmData>) -> Result<Self> {
+    pub async fn new(instance_layer: InstanceLayer, realm_layer: RealmLayer) -> Result<Self> {
         let mut roots = RootCertStore::empty();
         let mut sni_resolver = ResolvesServerCertUsingSni::new();
 
         let config = ServerConfig::builder();
 
-        for realm in realms {
+        for realm in realm_layer.realms.iter().await {
+            let realm = realm.read().await;
+            let db = realm_layer.realm(realm.name.clone()).await?;
+            trace!(name = *realm.name, "Registering realm with server acceptor");
+
             // Add cluster cert as a CA cert to the root store
             {
-                let cluster_cert: &RealmClusterCert = realm
-                    .cluster_cert
-                    .as_ref()
-                    .ok_or_else(|| anyhow!("No cluster cert")?);
+                let cluster_cert: Resident<RealmClusterCert> = db.resident(())?;
 
-                roots.add(pem::parse(&cluster_cert.cert)?.into_contents().try_into()?)?;
+                roots.add(cluster_cert.read().await.cert.clone().try_into()?)?;
             }
 
             // Add server cert to the SNI resolver
             {
-                let server_cert: Document<RealmServerCert> = realm.get_document("server")?.unwrap();
+                let server_cert: Resident<RealmServerCert> = db.resident(DataCondition::equal(
+                    RealmServerCertKey::_instance_id,
+                    instance_layer.instance_id,
+                ))?;
+
                 let private_key = config.crypto_provider().key_provider.load_private_key(
-                    PrivateKeyDer::from_pem_slice(
-                        &server_cert
-                            .data
-                            .key
-                            .ok_or_else(|| anyhow!("No server key")?)
-                            .as_bytes(),
-                    )?,
+                    server_cert
+                        .read()
+                        .await
+                        .key
+                        .clone()
+                        .ok_or_else(|| anyhow!("No server key"))?
+                        .try_into()
+                        .map_err(|_| anyhow!("Failed to parse key"))?,
                 )?;
 
                 sni_resolver.add(
-                    &server_cert.data.subject_name()?,
+                    &server_cert.read().await.subject_name()?,
                     rustls::sign::CertifiedKey::new(
-                        vec![
-                            pem::parse(&server_cert.data.cert)?
-                                .into_contents()
-                                .try_into()?,
-                        ],
+                        vec![server_cert.read().await.cert.clone().try_into()?],
                         private_key,
                     ),
                 )?;
diff --git a/sandpolis-server/src/lib.rs b/sandpolis-server/src/lib.rs
@@ -1,8 +1,11 @@
 use anyhow::Result;
 use native_db::ToKey;
 use native_model::Model;
+#[cfg(feature = "server")]
+use sandpolis_core::RealmName;
 use sandpolis_core::{ClusterId, InstanceId};
 use sandpolis_database::DatabaseLayer;
+use sandpolis_database::Resident;
 use sandpolis_macros::data;
 use sandpolis_network::NetworkLayer;
 use serde::{Deserialize, Serialize};
@@ -28,18 +31,10 @@ pub struct ServerLayer {
 }
 
 impl ServerLayer {
-    pub fn new(database: DatabaseLayer, network: NetworkLayer) -> Result<Self> {
+    pub async fn new(database: DatabaseLayer, network: NetworkLayer) -> Result<Self> {
         Ok(Self {
             #[cfg(feature = "server")]
-            banner: if let Some(document) = data.get_document("/banner")? {
-                document
-            } else {
-                // Load banner from another server if there is one
-                // TODO
-
-                // Create a new banner
-                data.document("/banner")?
-            },
+            banner: database.realm(RealmName::default()).await?.resident(())?,
             network,
         })
     }
@@ -50,7 +45,7 @@ impl ServerLayer {
 }
 
 /// Contains information about the server useful for prospective logins
-#[derive(Serialize, Deserialize, Clone, Default)]
+#[data]
 pub struct ServerBannerData {
     pub cluster_id: ClusterId,
 
diff --git a/sandpolis-server/src/server/routes.rs b/sandpolis-server/src/server/routes.rs
@@ -1,12 +1,8 @@
+use crate::ServerLayer;
 use crate::messages::GetBannerRequest;
 use crate::messages::GetBannerResponse;
-use crate::ServerLayer;
 use axum::extract;
-use axum::{
-    extract::State,
-    routing::{get, post},
-    Json, Router,
-};
+use axum::{Json, Router, extract::State};
 use sandpolis_network::RequestResult;
 
 /// Return a "banner" containing server metadata.
@@ -15,5 +11,7 @@ pub async fn banner(
     state: State<ServerLayer>,
     extract::Json(_): extract::Json<GetBannerRequest>,
 ) -> RequestResult<GetBannerResponse> {
-    Ok(Json(GetBannerResponse::Ok(state.banner.data.clone())))
+    Ok(Json(GetBannerResponse::Ok(
+        state.banner.read().await.clone(),
+    )))
 }
diff --git a/sandpolis-user/src/lib.rs b/sandpolis-user/src/lib.rs
@@ -6,6 +6,7 @@ use anyhow::Result;
 use native_db::ToKey;
 use native_model::Model;
 use sandpolis_core::UserName;
+use sandpolis_database::ResidentVec;
 use sandpolis_database::{Data, DatabaseLayer};
 use sandpolis_macros::data;
 use serde::{Deserialize, Serialize};
@@ -27,14 +28,17 @@ pub struct UserLayerData {}
 pub struct UserLayer {
     pub database: DatabaseLayer,
     #[cfg(feature = "server")]
-    pub users: DataView<UserData>,
+    pub users: ResidentVec<UserData>,
 }
 
 impl UserLayer {
-    pub fn new(database: DatabaseLayer) -> Result<Self> {
+    pub async fn new(database: DatabaseLayer) -> Result<Self> {
         Ok(Self {
             #[cfg(feature = "server")]
-            users: data.collection("/users")?,
+            users: database
+                .realm(RealmName::default())
+                .await?
+                .resident_vec(())?,
             database,
         })
     }
diff --git a/sandpolis/examples/client_tui_server_list.rs b/sandpolis/examples/client_tui_server_list.rs
@@ -1,9 +1,9 @@
 use anyhow::Result;
 use sandpolis::{client::tui::server_list::ServerListWidget, server::test_server};
 use sandpolis_database::TemporaryDatabase;
-use sandpolis_realm::{RealmLayer, config::RealmConfig};
 use sandpolis_instance::{InstanceId, InstanceLayer};
 use sandpolis_network::{NetworkLayer, config::NetworkLayerConfig};
+use sandpolis_realm::{RealmLayer, config::RealmConfig};
 use sandpolis_server::ServerLayer;
 use std::sync::Arc;
 
@@ -12,25 +12,28 @@ async fn main() -> Result<()> {
     let test_server = test_server().await?;
 
     let temp_db = TemporaryDatabase::new()?;
-    let widget = ServerListWidget::new(ServerLayer::new(
-        temp_db.db.document("/server")?,
-        NetworkLayer::new(
-            NetworkLayerConfig {
-                servers: Some(vec![
-                    format!("127.0.0.1:{}", test_server.port).parse().unwrap(),
-                ]),
-                poll: None,
-            },
-            temp_db.db.document("/network")?,
-            RealmLayer::new(
-                RealmConfig {
-                    certificate: Some(test_server.endpoint_cert),
+    let widget = ServerListWidget::new(
+        ServerLayer::new(
+            temp_db.db.document("/server")?,
+            NetworkLayer::new(
+                NetworkLayerConfig {
+                    servers: Some(vec![
+                        format!("127.0.0.1:{}", test_server.port).parse().unwrap(),
+                    ]),
+                    poll: None,
                 },
-                temp_db.db.document("/realm")?,
-                InstanceLayer::new(temp_db.db.document("/instance")?)?,
+                temp_db.db.document("/network")?,
+                RealmLayer::new(
+                    RealmConfig {
+                        certificate: Some(test_server.endpoint_cert),
+                    },
+                    temp_db.db.document("/realm")?,
+                    InstanceLayer::new(temp_db.db.document("/instance")?)?,
+                )?,
             )?,
-        )?,
-    )?);
+        )
+        .await?,
+    );
     sandpolis_client::tui::test_widget(widget).await.unwrap();
     Ok(())
 }
diff --git a/sandpolis/src/lib.rs b/sandpolis/src/lib.rs
@@ -67,11 +67,11 @@ impl InstanceState {
             sandpolis_network::NetworkLayer::new(config.network, database.clone(), realm.clone())
                 .await?;
 
-        let user = sandpolis_user::UserLayer::new(database.clone())?;
+        let user = sandpolis_user::UserLayer::new(database.clone()).await?;
 
         let agent = sandpolis_agent::AgentLayer::new(database.clone()).await?;
 
-        let server = sandpolis_server::ServerLayer::new(database.clone(), network.clone())?;
+        let server = sandpolis_server::ServerLayer::new(database.clone(), network.clone()).await?;
 
         #[cfg(feature = "layer-package")]
         let package = sandpolis_package::PackageLayer::new().await?;
diff --git a/sandpolis/src/server/mod.rs b/sandpolis/src/server/mod.rs
@@ -40,7 +40,8 @@ pub async fn main(config: Configuration, state: InstanceState) -> Result<()> {
     info!(listener = ?config.server.listen, "Starting server listener");
     axum_server::bind(config.server.listen)
         .acceptor(sandpolis_realm::server::RealmAcceptor::new(
-            state.realm.realms.clone(),
+            state.instance.clone(),
+            state.realm.clone(),
         )?)
         .serve(app.with_state(state).into_make_service())
         .await

Original file line number	Diff line number	Diff line change
`@@ -824,11 +824,14 @@ impl DataCondition {`
`824`	`824`	`}`
`825`	`825`	`}`
`826`	`826`
`827`		`- fn equal(key: impl ToKeyDefinition<KeyOptions>, value: impl ToKey) -> Self {`
	`827`	`+ pub fn equal(key: impl ToKeyDefinition<KeyOptions>, value: impl ToKey) -> Self {`
`828`	`828`	`Self::Equal(key.key_definition(), value.to_key())`
`829`	`829`	`}`
`830`	`830`
`831`		`- fn range<R: RangeBounds<impl ToKey>>(key: impl ToKeyDefinition<KeyOptions>, value: R) -> Self {`
	`831`	`+ pub fn range<R: RangeBounds<impl ToKey>>(`
	`832`	`+ key: impl ToKeyDefinition<KeyOptions>,`
	`833`	`+ value: R,`
	`834`	`+ ) -> Self {`
`832`	`835`	`Self::Range(key.key_definition(), KeyRange::new(value))`
`833`	`836`	`}`
`834`	`837`	`}`