wip: fix some server-side compile errors

Author: cilki

sandpolis-mobile/src/main.rs

@@ -1,2 +1,2 @@
 //! The entry point for iOS applications.
-use bevy_mobile_example::main;
+use sandpolis_mobile::main;

sandpolis-user/src/lib.rs

@@ -5,6 +5,7 @@
 // }
 
 use anyhow::Result;
+use anyhow::bail;
 use native_db::ToKey;
 use native_model::Model;
 use sandpolis_core::RealmName;
@@ -45,6 +46,17 @@ impl UserLayer {
             database,
         })
     }
+
+    // TODO better users.find
+    pub async fn user(&self, username: &UserName) -> Result<UserData> {
+        let user = for user in self.users.iter().await {
+            if user.read().await.username == *username {
+                return Ok(user.read().await.clone());
+            }
+        };
+
+        bail!("User not found");
+    }
 }
 
 #[derive(Validate)]

sandpolis-user/src/server/routes.rs

@@ -33,13 +33,7 @@ pub async fn login(
         .validate()
         .map_err(|_| Json(LoginResponse::Invalid))?;
 
-    let Some(user) = state
-        .users
-        .stream()
-        .await
-        .find(async |user| user.read().await.username == request.username)
-        .await
-    else {
+    let Ok(user) = state.user(&request.username).await else {
         debug!(username = %request.username, "User does not exist");
         return Err(Json(LoginResponse::Denied));
     };
@@ -78,12 +72,12 @@ pub async fn login(
     }
 
     let claims = Claims {
-        sub: user.read().await.username.to_string(),
+        sub: user.username.to_string(),
         exp: (SystemTime::now() + Duration::from_secs(3600))
             .duration_since(SystemTime::UNIX_EPOCH)
             .unwrap()
             .as_secs() as usize,
-        admin: user.read().await.admin,
+        admin: user.admin,
     };
 
     info!(claims = ?claims, "Login succeeded");

sandpolis/src/cli.rs

@@ -1,10 +1,13 @@
+use crate::config::Configuration;
 use anyhow::Result;
+use anyhow::bail;
 use clap::Parser;
 use clap::Subcommand;
 use colored::Colorize;
+use sandpolis_core::RealmName;
+use std::path::PathBuf;
 use std::process::ExitCode;
-
-use crate::config::Configuration;
+use tracing::info;
 
 #[derive(Parser, Debug, Clone)]
 #[clap(author, version, about = "Test")]
@@ -72,23 +75,32 @@ pub enum Commands {
 }
 
 impl Commands {
-    pub fn dispatch(&self, config: &Configuration) -> Result<ExitCode> {
+    pub async fn dispatch(self, config: &Configuration) -> Result<ExitCode> {
         match self {
             #[cfg(feature = "server")]
             Commands::NewClientCert { realm, output } => {
-                let db = Database::new(&config.database.storage)?;
+                use sandpolis_realm::RealmClusterCert;
+
+                let database = sandpolis_database::DatabaseLayer::new(
+                    config.database.clone(),
+                    &crate::MODELS,
+                )?;
+
+                let db = database.realm(realm.parse()?).await?;
+                let r = db.r_transaction()?;
+
+                let cluster_certs: Vec<RealmClusterCert> =
+                    r.scan().primary()?.all()?.try_collect()?;
 
-                let realms: Collection<RealmData> = db
-                    .document::<RealmLayerData>("/realm")?
-                    .collection("/realms")?;
-                let g = realms.get_document(realm)?.expect("the realm exists");
-                let ca: Document<RealmClusterCert> = g.get_document("ca")?.expect("the CA exists");
+                let Some(cluster_cert) = cluster_certs.first() else {
+                    bail!("No cluster cert found");
+                };
 
-                let cert = ca.data.client_cert()?;
+                let client_cert = cluster_cert.client_cert()?;
 
                 if let Some(path) = output {
                     info!(path = %path.display(), "Writing endpoint certificate");
-                    std::fs::write(path, &serde_json::to_vec(&cert)?)?;
+                    std::fs::write(path, &serde_json::to_vec(&client_cert)?)?;
                 } else {
                     todo!()
                 }

sandpolis/src/lib.rs

@@ -1,3 +1,5 @@
+#![feature(iterator_try_collect)]
+
 use anyhow::Result;
 use axum_macros::FromRef;
 use config::Configuration;
@@ -254,7 +256,7 @@ pub static MODELS: LazyLock<Models> = LazyLock::new(|| {
         m.define::<sandpolis_user::UserLayerData>().unwrap();
         m.define::<sandpolis_user::UserData>().unwrap();
         #[cfg(feature = "server")]
-        m.define::<sandpolis_user::PasswordData>().unwrap();
+        m.define::<sandpolis_user::server::PasswordData>().unwrap();
     }
 
     // Server layer

sandpolis/src/main.rs

@@ -80,7 +80,7 @@ async fn main() -> Result<ExitCode> {
         #[cfg(any(feature = "agent", feature = "client"))]
         Some(Commands::Server) => run_instances = vec!["server"],
 
-        Some(command) => return Ok(command.dispatch(&config)?),
+        Some(command) => return Ok(command.dispatch(&config).await?),
         None => (),
     }
 

sandpolis/src/server/mod.rs

@@ -5,8 +5,7 @@ use axum::{
     routing::{get, post},
 };
 use rand::Rng;
-use sandpolis_database::Database;
-use sandpolis_instance::{ClusterId, InstanceId};
+use sandpolis_core::{ClusterId, InstanceId};
 use sandpolis_realm::RealmClusterCert;
 use std::path::PathBuf;
 use tempfile::TempDir;
@@ -39,10 +38,13 @@ 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.instance.clone(),
-            state.realm.clone(),
-        )?)
+        .acceptor(
+            sandpolis_realm::server::RealmAcceptor::new(
+                state.instance.clone(),
+                state.realm.clone(),
+            )
+            .await?,
+        )
         .serve(app.with_state(state).into_make_service())
         .await
         .context("binding socket")?;
@@ -55,7 +57,6 @@ pub struct TestServer {
     pub port: u16,
     pub endpoint_cert: PathBuf,
     certs: TempDir,
-    db: Database,
 }
 
 /// Run a standalone server instance for testing.
@@ -71,7 +72,7 @@ pub async fn test_server() -> Result<TestServer> {
     let mut config = Configuration::default();
 
     // Create temporary database
-    let db = Database::new_ephemeral()?;
+    let database = sandpolis_database::DatabaseLayer::new(config.database.clone(), &crate::MODELS)?;
 
     // Generate temporary certs
     let certs = tempdir()?;
@@ -84,7 +85,7 @@ pub async fn test_server() -> Result<TestServer> {
     let port: u16 = rand::rng().random_range(9000..9999);
     config.server.listen = format!("127.0.0.1:{port}",).parse()?;
 
-    let state = InstanceState::new(config.clone(), db.clone()).await?;
+    let state = InstanceState::new(config.clone(), database).await?;
 
     // Spawn the server
     tokio::spawn(async move { main(config, state).await });
@@ -93,6 +94,5 @@ pub async fn test_server() -> Result<TestServer> {
         port,
         endpoint_cert: certs.path().join("client.cert"),
         certs,
-        db,
     })
 }