Add asset local server service

src/main.rs

@@ -17,6 +17,7 @@ use clap::Parser;
 use std::fs;
 use std::sync::Mutex;
 use std::time::Duration;
+use actix_web::dev::{Server, ServerHandle};
 use lazy_static::lazy_static;
 
 #[get("/index.css")]
@@ -38,9 +39,18 @@ pub struct Args {
     #[arg(short, long, default_value_t = 8080, help = "Port to listen on")]
     port: u16,
 
+    #[arg(short, long, default_value_t = 8000, help = "Assets port to listen on")]
+    asset_port: u16,
+
     #[arg(long, default_value = "./", help = "Path to store database files")]
     path: String,
 
+    #[arg(long, default_value = "./asset/", help = "Path to store database files")]
+    asset_path: String,
+
+    #[arg(long, default_value_t = false, help = "Enable assets server")]
+    enable_asset_server: bool,
+
     #[arg(long, default_value_t = false, help = "Serve gree headers with https. WILL NOT ACCEPT HTTPS REQUESTS")]
     https: bool,
 
@@ -96,6 +106,8 @@ pub struct Args {
 async fn run_server(in_thread: bool) -> std::io::Result<()> {
     let args = get_args();
     let port = args.port;
+    let enable_asset_server = args.enable_asset_server;
+    let asset_port = args.asset_port;
 
     if args.purge {
         println!("Purging accounts...");
@@ -103,9 +115,9 @@ async fn run_server(in_thread: bool) -> std::io::Result<()> {
         println!("Purged {} accounts", ct);
     }
 
-    let rv = HttpServer::new(|| App::new()
+    let webui_server = HttpServer::new(|| App::new()
     .wrap_fn(|req, srv| {
-        println!("Request: {}", req.path());
+        println!("WebUI Request: {}", req.path());
         srv.call(req)
     })
     .app_data(web::PayloadConfig::default().limit(1024 * 1024 * 25))
@@ -114,26 +126,56 @@ async fn run_server(in_thread: bool) -> std::io::Result<()> {
     .default_service(web::route().to(router::request))
     ).bind(("0.0.0.0", port))?.run();
 
-    println!("Server started: http://0.0.0.0:{}", port);
-    println!("Data path is set to {}", args.path);
+    println!("WebUI Server started: http://0.0.0.0:{}", port);
+    println!("Database path is set to {}", args.path);
     println!("Sif1 transfer requests will attempt to contact NPPS4 at {}", args.npps4);
 
+    let mut asset_server: Option<Server> = None;
+    if enable_asset_server {
+        asset_server = Some(HttpServer::new(|| App::new()
+            .wrap_fn(|req, srv| {
+                println!("Assets Request: {}", req.path());
+                srv.call(req)
+            })
+            .app_data(web::PayloadConfig::default().limit(1024 * 1024 * 1024))
+            .default_service(web::route().to(router::asset_request))
+        ).bind(("0.0.0.0", asset_port))?.run());
+
+        println!("Assets Server started: http://0.0.0.0:{}", asset_port);
+        println!("Assets path is set to {}", args.asset_path);
+    }
+
     if args.https {
         println!("Note: gree is set to https mode. http requests will fail on jp clients.");
     }
 
     if in_thread {
         set_running(true).await;
-        let handle = rv.handle();
-        rt::spawn(rv);
+        let handle = webui_server.handle();
+        rt::spawn(webui_server);
+        let mut handle2: Option<ServerHandle> = None;
+        if asset_server.is_some() {
+            let server = asset_server.unwrap();
+            handle2 = Some(server.handle());
+            rt::spawn(server);
+        }
+
         while get_running().await {
             actix_web::rt::time::sleep(Duration::from_millis(100)).await;
         }
         handle.stop(false).await;
+        if handle2.is_some() {
+            handle2.unwrap().stop(false).await;
+        }
         println!("Stopped");
         return Ok(());
     }
-    rv.await
+    if asset_server.is_some() {
+        let _ = futures::join!(webui_server, asset_server.unwrap());
+    } else {
+        webui_server.await?
+    }
+    Ok(())
 }
 
 #[actix_web::main]

src/router.rs

@@ -28,12 +28,7 @@ pub mod databases;
 pub mod location;
 pub mod event_ranking;
 
-use actix_web::{
-    HttpResponse,
-    HttpRequest,
-    http::header::HeaderValue,
-    http::header::HeaderMap
-};
+use actix_web::{HttpResponse, HttpRequest, http::header::HeaderValue, http::header::HeaderMap, Responder};
 use json::{JsonValue, object};
 use crate::encryption;
 
@@ -167,6 +162,10 @@ async fn api_req(req: HttpRequest, body: String) -> HttpResponse {
     }
 }
 
+pub async fn asset_request(req: HttpRequest) -> impl Responder {
+    webui::asset(req).await
+}
+
 pub async fn request(req: HttpRequest, body: String) -> HttpResponse {
     let args = crate::get_args();
     let headers = req.headers();

src/router/webui.rs

@@ -1,9 +1,6 @@
-use actix_web::{
-    HttpResponse,
-    HttpRequest,
-    http::header::HeaderValue,
-    http::header::ContentType
-};
+use actix_web::{HttpResponse, HttpRequest, http::header::HeaderValue, http::header::ContentType, Responder};
+use actix_files::NamedFile;
+use std::path::PathBuf;
 use json::{JsonValue, object};
 
 use crate::include_file;
@@ -163,6 +160,28 @@ pub fn main(req: HttpRequest) -> HttpResponse {
         .body(include_file!("webui/dist/index.html"))
 }
 
+pub async fn asset(req: HttpRequest) -> impl Responder {
+    let args = crate::get_args();
+
+    if req.path() == "/" {
+        return HttpResponse::Ok()
+            .insert_header(ContentType::html())
+            .body(include_file!("webui/dist/asset_index.html"));
+    }
+
+    let path = req.path();
+    let mut modified_path = format!("{}{}", args.asset_path, path);
+
+    modified_path = modified_path.trim_end_matches('/').to_string();
+
+    let filename: PathBuf = modified_path.trim_start_matches('/').into();
+
+    match NamedFile::open(&filename) {
+        Ok(file) => file.into_response(&req),
+        Err(_) => HttpResponse::NotFound().body("File not found"),
+    }
+}
+
 pub fn export(req: HttpRequest) -> HttpResponse {
     if !get_config()["export"].as_bool().unwrap() {
         return error("Exporting accounts is disabled on this server.");