Added hostinfo route and route utils

src/album.rs

@@ -6,7 +6,7 @@ use super::{Artist, Metadata, add_vec, remove_vec};
 /// Album
 /// 
 /// A struct representing an album of the Cyrkensia repository.
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Album {
     /// Name
     /// 

src/artist.rs

@@ -7,7 +7,7 @@ use super::{Owner, add_vec, remove_vec};
 /// Artist
 /// 
 /// A struct representing an author or artist of a song.
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Artist {
     pub name: String,
 

src/config.rs

@@ -59,9 +59,9 @@ pub struct Config {
 
     /// Maximum Age
     /// 
-    /// The maximum age of the [Hostinfo] in milliseconds as a [u32]. If [None], the Hostinfo will always be regenerated when its route is accessed.
+    /// The maximum age of the [Hostinfo] in milliseconds as a [u64]. If [None], the Hostinfo will always be regenerated when its route is accessed.
     /// This basically activates caching.
-    pub max_age: Option<u32>
+    pub max_age: Option<u64>
 }
 
 impl Config {

src/hostinfo.rs

@@ -10,7 +10,7 @@ use super::{Owner, Album, Config, Metadata};
 /// Hostinfo
 /// 
 /// A struct representing the metadata or hostinfo and index of a Cyrkensia repository.
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Hostinfo {
     /// Name
     /// 
@@ -80,13 +80,13 @@ impl Hostinfo {
     /// Generate Hostinfo
     /// 
     /// Generates a Hostinfo based on a [Config].
-    pub fn generate(cfg: Config) -> io::Result<Hostinfo> {
+    pub fn generate(cfg: &Config) -> io::Result<Hostinfo> {
         let mut albums: Vec<Album> = Vec::new();
         for rootpath in &cfg.root {
             let album_slice = Hostinfo::read_albums(rootpath)?;
             albums.extend(album_slice);
         }
-        let mut hostinfo = Hostinfo::from(cfg);
+        let mut hostinfo = Hostinfo::from(cfg.clone());
         hostinfo.size = albums.iter().map(|x| x.size).sum();
         hostinfo.albums = albums;
         Ok(hostinfo)

src/server/mod.rs

@@ -1,4 +1,6 @@
+use actix_web::http::Uri;
 use crate::{Hostinfo, Config};
+use std::fmt::Write;
 use std::sync::Mutex;
 use std::time::Instant;
 use std::io;
@@ -19,6 +21,11 @@ pub mod redirect;
 /// Submodule containing Cyrkensia routes.
 pub mod routes;
 
+/// Responses
+/// 
+/// Submodue containing Cyrkensia responses.
+pub mod responses;
+
 /// Cyrkensia State
 /// 
 /// State for the Actix-Web server. Used in [routes].
@@ -32,36 +39,56 @@ pub struct CyrkensiaState {
     /// 
     /// The latest generated [Hostinfo].
     /// Only used if caching is activated.
-    pub hostinfo: Mutex<Option<Hostinfo>>,
+    pub hostinfo: Mutex<Hostinfo>,
 
     /// Last Hostinfo Update
     /// 
     /// The [timestamp](Instant) when the [hostinfo] was last updated.
     /// `.elapsed().as_secs()` will be used to compare it with the `max_age` in the [Config].
     /// Only used if caching is activated.
-    pub last_updated: Mutex<Option<Instant>>
+    pub last_updated: Mutex<Instant>
 }
 
 impl CyrkensiaState {
     /// Constructur
     /// 
     /// Creates a new [CyrkensiaState] with given [Config].
     pub fn new(cfg: Config) -> io::Result<CyrkensiaState> {
+        // State with caching
         if cfg.max_age.is_some() {
-            // State with caching
-            let hostinfo = Hostinfo::generate(cfg.clone())?;
+            let hostinfo = Hostinfo::generate(&cfg)?;
             return Ok(CyrkensiaState {
-                last_updated: Mutex::new(Some(Instant::now())),
-                hostinfo: Mutex::new(Some(hostinfo)),
+                last_updated: Mutex::new(Instant::now()),
+                hostinfo: Mutex::new(hostinfo),
                 config: cfg
             });
         }
 
         // State without caching
         Ok(CyrkensiaState {
-            hostinfo: Mutex::new(None),
-            last_updated: Mutex::new(None),
+            hostinfo: Mutex::new(Hostinfo::empty()),
+            last_updated: Mutex::new(Instant::now()),
             config: cfg,
         })
     }
+}
+
+/// Uri Display without Query
+/// 
+/// Displays a Uri without the query parameters
+pub fn uri_noquery(uri: &Uri) -> String {
+    let mut f = String::new();
+
+    // Protocol
+    if let Some(scheme) = uri.scheme() {
+        let _ = write!(&mut f, "{}://", scheme);
+    }
+    // Server
+    if let Some(authority) = uri.authority() {
+        let _ = write!(&mut f, "{}", authority);
+    }
+    // Path
+    let _ = write!(&mut f, "{}", uri.path());
+
+    f
 }

src/server/responses.rs

@@ -0,0 +1,41 @@
+use std::io;
+use actix_web::{HttpResponse, body::MessageBody};
+use actix_web::http::header::{ContentType, CONTENT_LENGTH};
+use crate::{Config, Hostinfo};
+
+/// Hostinfo from Config
+/// 
+/// Attempts to create a [HttpResponse] from a generated [Hostinfo] by a [Config].
+pub fn hostinfo_json(cfg: &Config) -> io::Result<HttpResponse> {
+    // Generate Hostinfo
+    let hostinfo = Hostinfo::generate(cfg)?;
+    hostinfo_data(&hostinfo)
+}
+
+/// Hostinfo from Data
+/// 
+/// Attempts to create a [HttpResponse] from a [Hostinfo] struct.
+pub fn hostinfo_data(hstinfo: &Hostinfo) -> io::Result<HttpResponse> {
+    // Convert to String
+    let raw_json = serde_json::to_string(hstinfo)?;
+
+    // Return HttpReponse
+    Ok(HttpResponse::Ok()
+    .content_type(ContentType::json())
+    .append_header(
+        (CONTENT_LENGTH, raw_json.len())
+    )
+    .body(raw_json))
+}
+
+/// HTTP Status 500
+/// 
+/// Returns a 500 Error with an optional body message
+pub fn server_500(msg: Option<impl MessageBody + 'static>) -> HttpResponse {
+    if let Some(message) = msg {
+        return HttpResponse::InternalServerError()
+        .body(message)
+    }
+    HttpResponse::InternalServerError()
+    .finish()
+}

src/server/routes.rs

@@ -0,0 +1,47 @@
+use std::time::Instant;
+use actix_web::{web, Responder, HttpRequest};
+use super::{CyrkensiaState, responses, uri_noquery};
+use crate::Hostinfo;
+
+/// Hostinfo Route
+/// 
+/// Route for serving a [Hostinfo]. Server needs [CyrkensiaState] in `.app_data()` for this.
+pub async fn hostinfo(req: HttpRequest, data: web::Data<CyrkensiaState>) -> impl Responder {
+    // Get config
+    let Some(delay) = data.config.max_age else {
+        // Ad hoch Hostinfo
+        let Ok(resp) = responses::hostinfo_json(&data.config) else {
+            return responses::server_500(Some("Failed to generate hostinfo"));
+        };
+        return resp;
+    };
+
+    // Get last update timestamp and cached hostinfo
+    let Ok(mut last_updated) = data.last_updated.lock() else {
+        return responses::server_500(None::<String>);
+    };
+    let Ok(mut hostinfo) = data.hostinfo.lock() else {
+        return responses::server_500(None::<String>);
+    };
+
+    if last_updated.elapsed().as_secs() >= delay {
+        // Generate new Hostinfo if expired
+        let Ok(new_hostinfo) = Hostinfo::generate(&data.config) else {
+            return responses::server_500(Some("Failed to update hostinfo"));
+        };
+
+        // Update Hostinfo and Timestamp
+        *hostinfo = new_hostinfo;
+        *last_updated = Instant::now();
+    }
+
+    // Set Origin URL
+    let mut final_hostinfo = hostinfo.clone();
+    final_hostinfo.set_origin(uri_noquery(req.uri()));
+
+    // Return final result
+    let Ok(finalres) = responses::hostinfo_data(&final_hostinfo) else {
+        return responses::server_500(Some("Failed to generate hostinfo"));
+    };
+    finalres
+}