wip: continue client login impl

Author: cilki

Cargo.lock

@@ -45,6 +45,7 @@ colored = "3.0.0"
 cron = { version = "0.15.0", features = ["serde"] }
 futures = "0.3.30"
 futures-util = "0.3.31"
+headers = "0.4.1"
 image = "0.25.5"
 native_db = { git = "https://github.com/vincent-herlemont/native_db", features = [
   "tokio",

Cargo.toml

@@ -4,15 +4,18 @@ use ratatui::{
     prelude::*,
     style::{Style, Stylize},
     text::Line,
-    widgets::{Block, Borders, Paragraph, WidgetRef},
+    widgets::{Block, Borders, Paragraph, Widget, WidgetRef},
 };
+use std::time::{Duration, Instant};
 use tui_popup::SizedWidgetRef;
 
 #[derive(Debug, Clone)]
 pub struct LoadingWidget {
     message: String,
     spinner_chars: Vec<char>,
     current_frame: usize,
+    last_update: Instant,
+    frame_duration: Duration,
 }
 
 impl LoadingWidget {
@@ -21,15 +24,29 @@ impl LoadingWidget {
             message: message.to_string(),
             spinner_chars: vec!['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
             current_frame: 0,
+            last_update: Instant::now(),
+            frame_duration: Duration::from_millis(100), // 10 FPS animation
         }
     }
 
     pub fn next_frame(&mut self) {
         self.current_frame = (self.current_frame + 1) % self.spinner_chars.len();
+        self.last_update = Instant::now();
+    }
+
+    pub fn update_animation(&mut self) {
+        let now = Instant::now();
+        if now.duration_since(self.last_update) >= self.frame_duration {
+            self.next_frame();
+        }
     }
 
     fn get_spinner_char(&self) -> char {
-        self.spinner_chars[self.current_frame]
+        // Calculate current frame based on elapsed time for automatic animation
+        let elapsed = Instant::now().duration_since(self.last_update);
+        let additional_frames = (elapsed.as_millis() / self.frame_duration.as_millis()) as usize;
+        let current_frame = (self.current_frame + additional_frames) % self.spinner_chars.len();
+        self.spinner_chars[current_frame]
     }
 }
 

sandpolis-client/src/tui/loading.rs

@@ -10,6 +10,7 @@ anyhow = { workspace = true }
 bevy = { workspace = true, optional = true }
 clap = { workspace = true, optional = true }
 colored = { workspace = true, optional = true }
+headers = { workspace = true, optional = true }
 native_db = { workspace = true }
 native_model = { workspace = true }
 regex = { workspace = true }
@@ -20,7 +21,7 @@ validator = { workspace = true }
 
 [features]
 default = ["dep:clap", "dep:colored"]
-server = []
+server = ["dep:headers"]
 bootagent = []
 agent = []
 client = []

sandpolis-core/Cargo.toml

@@ -1,4 +1,6 @@
 use anyhow::Result;
+#[cfg(feature = "server")]
+use headers::{Header, HeaderName, HeaderValue};
 use native_db::ToKey;
 use regex::Regex;
 use serde::{Deserialize, Serialize, de::DeserializeOwned};
@@ -421,6 +423,36 @@ impl ToKey for RealmName {
     }
 }
 
+#[cfg(feature = "server")]
+impl Header for RealmName {
+    fn name() -> &'static HeaderName {
+        static NAME: HeaderName = HeaderName::from_static("x-realm");
+        &NAME
+    }
+
+    fn decode<'i, I>(values: &mut I) -> Result<Self, headers::Error>
+    where
+        I: Iterator<Item = &'i HeaderValue>,
+    {
+        Ok(values
+            .next()
+            .ok_or_else(headers::Error::invalid)?
+            .to_str()
+            .map_err(|_| headers::Error::invalid())?
+            .parse()
+            .map_err(|_| headers::Error::invalid())?)
+    }
+
+    fn encode<E>(&self, values: &mut E)
+    where
+        E: Extend<HeaderValue>,
+    {
+        values.extend(std::iter::once(
+            HeaderValue::from_str(&self.to_string()).expect("Realm names only allow ascii 32-127"),
+        ));
+    }
+}
+
 #[cfg(test)]
 mod test_realm_name {
     use super::*;

sandpolis-core/src/lib.rs

@@ -5,6 +5,7 @@ use anyhow::Context;
 use anyhow::Result;
 use anyhow::anyhow;
 use anyhow::bail;
+use axum::http::HeaderValue;
 use chrono::{DateTime, Utc};
 use config::NetworkLayerConfig;
 use cron::Schedule;
@@ -15,6 +16,7 @@ use native_db::ToKey;
 use native_model::Model;
 use reqwest::ClientBuilder;
 use reqwest::Method;
+use reqwest::header::CONTENT_TYPE;
 use reqwest_websocket::RequestBuilderExt;
 use sandpolis_core::ClusterId;
 use sandpolis_core::{InstanceId, RealmName};
@@ -174,9 +176,9 @@ impl NetworkLayer {
 
                                 },
                                 Err(e) => {
-                                    debug!(error = %e, "Poll request failed");
                                     // Wait before retrying
                                     let timeout = {connection.retry.write().unwrap().next().unwrap()};
+                                    debug!(error = %e, waiting = ?timeout, "Poll request failed");
                                     sleep(timeout).await;
                                 },
                             }
@@ -284,6 +286,8 @@ impl OutboundConnection {
                         method,
                         format!("https://{}.{}/{endpoint}", self.cluster_id, self.realm),
                     )
+                    .header(CONTENT_TYPE, HeaderValue::from_static("application/json"))
+                    .header("x-realm", self.realm.to_string())
                     .body(body)
                     .send()
                     .await?

sandpolis-network/src/lib.rs

@@ -428,7 +428,7 @@ impl RealmClientCert {
 
     #[cfg(feature = "client")]
     pub fn ca(&self) -> Result<reqwest::Certificate> {
-        Ok(reqwest::Certificate::from_pem(&self.ca)?)
+        Ok(reqwest::Certificate::from_der(&self.ca)?)
     }
 
     #[cfg(feature = "client")]

sandpolis-realm/src/lib.rs

@@ -14,7 +14,6 @@ use axum::{
 use axum_server::tls_rustls::RustlsConfig;
 use axum_server::{accept::Accept, tls_rustls::RustlsAcceptor};
 use futures_util::future::BoxFuture;
-use headers::{self, Header, HeaderName, HeaderValue};
 use rcgen::BasicConstraints;
 use rcgen::Certificate;
 use rcgen::CertificateParams;

sandpolis-realm/src/server.rs

@@ -28,8 +28,8 @@ tracing = { workspace = true }
 validator = { workspace = true }
 
 [features]
-server = []
-client = []
-agent = []
+server = ["sandpolis-network/server"]
+client = ["sandpolis-network/client"]
+agent = ["sandpolis-network/agent"]
 client-tui = ["client"]
 client-gui = ["client"]

sandpolis-server/Cargo.toml

@@ -17,7 +17,7 @@ use serde::{Deserialize, Serialize};
 use serde_with::DeserializeFromStr;
 use std::sync::Arc;
 use std::time::Duration;
-use tracing::debug;
+use tracing::{debug, info};
 use validator::Validate;
 
 #[cfg(feature = "client")]
@@ -59,13 +59,16 @@ impl ServerLayer {
         connections
     }
 
+    #[cfg(any(feature = "agent", feature = "client"))] // Temporary
     pub async fn connect(&self, url: ServerUrl) -> Result<ServerConnection> {
         let inner = self.network.connect_server(url)?;
 
+        debug!("Fetching server banner");
+
         // Fetch banner before we return a complete connection
         let response: GetBannerResponse = inner
             .get(
-                "/server/banner",
+                "server/banner",
                 GetBannerRequest {
                     #[cfg(feature = "client-gui")]
                     include_image: true,
@@ -85,7 +88,7 @@ impl ServerLayer {
 }
 
 /// Contains information about the server useful for prospective logins
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
 pub struct ServerBanner {
     /// Indicates that only admin users will be allowed to login
     pub maintenance: bool,
@@ -125,7 +128,17 @@ pub struct ServerConnection {
 
 impl ServerConnection {
     pub async fn login(&self, request: LoginRequest) -> Result<LoginResponse> {
-        Ok(self.inner.post("/login", request).await?)
+        // TODO span username
+        debug!(username = %request.username, "Attempting login");
+
+        let result = self.inner.post("user/login", request).await;
+        match result {
+            Ok(LoginResponse::Ok(_)) => {
+                info!("Login succeeded");
+            }
+            _ => {}
+        }
+        result
     }
 }