Merge branch 'unstable' into stable

Author: markcda

.depl/config.yaml

@@ -245,6 +245,66 @@ pipelines:
                 to: cc-static-server
               - from: cc-static-server/static-server.yaml
                 to: static-server.yaml
+  - title: build-static-server-debug
+    desc: Build `cc-static-server` (debug) and update content storage
+    info: cc-services-static-server-debug@0.1.0
+    tags:
+      - cargo
+      - clippy
+      - lint
+    default: true
+    artifacts:
+      - from: target/x86_64-unknown-linux-gnu/debug/cc-static-server
+        to: static-server/cc-static-server-debug
+      - from: cc-static-server/static-server.yaml
+        to: static-server/static-server.yaml
+    actions:
+      - title: Sync script to know Rust package version
+        info: sync-rust-crate-ver@0.1.0
+        tags: []
+        exec_in_project_dir: false
+        action:
+          type: use_from_storage
+          content_info: get-know-rust-package-version@latest
+      - title: Cargo Build (Debug)
+        info: cargo-debug@0.1.0
+        tags:
+          - rust
+          - cargo
+        requirements:
+          - type: exists
+            path: /bin/cargo
+        action:
+          type: build
+          supported_langs:
+            - rust
+          commands:
+            - bash_c: cargo build --package cc-static-server --target x86_64-unknown-linux-gnu
+              ignore_fails: false
+              show_success_output: false
+              show_bash_c: true
+      - title: Auto-upload CC Static Server to Deployer's Storage
+        info: auto-upload-static-server@0.1.0
+        tags: []
+        exec_in_project_dir: false
+        action:
+          type: add_to_storage
+          short_name: static-server-debug
+          auto_version_rule:
+            type: cmd_stdout
+            cmd:
+              bash_c: python .depl/rust-crate-ver.py
+              ignore_fails: true
+              show_success_output: true
+              show_bash_c: false
+              only_when_fresh: false
+          content:
+            type: fixed_files
+            placements:
+              - from: target/x86_64-unknown-linux-gnu/debug/cc-static-server
+                to: cc-static-server
+              - from: cc-static-server/static-server.yaml
+                to: static-server.yaml
   - title: build-error-pages
     desc: Build `cc-error-pages`
     info: cc-ui-kit-frontend-app-build@0.1.0

Cargo.toml

@@ -10,7 +10,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "0.11.0-1"
+version = "0.11.1"
 edition = "2024"
 license = "MIT"
 authors = ["Klimenty Titov <aclo.create@gmail.com>"]
@@ -27,11 +27,11 @@ bytes = "1"
 clap = { version = "4", features = ["derive"] }
 console_error_panic_hook = "0.1.7"
 console_log = "1"
-dashmap = "6.1"
 encoding_rs = "0.8"
 flate2 = { version = "1", default-features = false }
 fs-change-notifier = "0.1.3"
 headers = "0.4"
+http = "1"
 http-body-util = "0.1"
 icondata = { version = "0.5", default-features = false }
 leptos = { version = "0.7", default-features = false }
@@ -65,7 +65,7 @@ zstd = { version = "0.13", default-features = false }
 web-sys = { version = "0.3", default-features = false }
 
 [profile.release]
-opt-level = "z"
+opt-level = 3
 debug = false
 lto = true
 codegen-units = 1

cc-static-server/Cargo.toml

@@ -8,10 +8,9 @@ authors = { workspace = true }
 
 [dependencies]
 cc-server-kit = { workspace = true, features = ["http3", "cors", "acme", "oapi", "otel", "force-https"] }
-dashmap = { workspace = true }
 fs-change-notifier = { workspace = true }
 headers = { workspace = true }
 mime = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
-tokio = { workspace = true, features = ["macros"] }
+tokio = { workspace = true, features = ["macros", "sync"] }
 tracing = { workspace = true }

cc-static-server/src/caching.rs

@@ -1,6 +1,5 @@
 use cc_server_kit::prelude::*;
 use cc_server_kit::salvo::http::HttpRange;
-use dashmap::DashMap;
 use fs_change_notifier::*;
 use headers::{
   AcceptRanges, ContentLength, ContentRange, ContentType, ETag, HeaderMapExt, IfMatch, IfModifiedSince, IfNoneMatch,
@@ -10,8 +9,10 @@ use salvo::fs::NamedFile;
 use salvo::http::header::{CONTENT_DISPOSITION, CONTENT_ENCODING, CONTENT_TYPE, IF_NONE_MATCH, RANGE};
 use salvo::http::{HeaderMap, HeaderValue};
 use std::cmp;
+use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
+use tokio::sync::Mutex;
 
 const CHUNK_SIZE: u64 = 1024 * 1024;
 
@@ -196,22 +197,113 @@ impl CachedFile {
   }
 }
 
+/// Request given file either from in-memory cacher or from disk.
+pub async fn send_file(
+  cacher: &Option<Arc<Mutex<CacheMap>>>,
+  req: &mut Request,
+  depot: &mut Depot,
+  res: &mut Response,
+  filename: &str,
+  path: &Path,
+) -> MResult<()> {
+  use salvo::Writer;
+
+  if let Some(cacher) = cacher.as_ref() {
+    {
+      let guard = cacher.lock().await;
+      if let Ok(Some(cached)) = guard.fetch(path) {
+        cached.send(req.headers(), res).await;
+        return Ok(());
+      }
+    }
+    let length = tokio::fs::metadata(path)
+      .await
+      .map_err(|e| ServerError::from_private(e).with_404())?
+      .len();
+    if length > 16 * 1024 * 1024 {
+      file_upload!(path.to_path_buf(), filename.to_string())
+        .write(req, depot, res)
+        .await;
+    } else {
+      let cached = CachedFile::construct_from(filename, path, length).await?;
+      {
+        let mut guard = cacher.lock().await;
+        guard.upsert(path, cached.clone())?;
+      }
+      cached.send(req.headers(), res).await;
+    }
+  } else {
+    file_upload!(path.to_path_buf(), filename.to_string())
+      .write(req, depot, res)
+      .await;
+  }
+  Ok(())
+}
+
+/// Request given HTML page either from in-memory cacher or from disk.
+pub async fn send_html(
+  cacher: &Option<Arc<Mutex<CacheMap>>>,
+  req: &mut Request,
+  depot: &mut Depot,
+  res: &mut Response,
+  filename: &str,
+  path: &Path,
+) -> MResult<()> {
+  use salvo::Writer;
+
+  if let Some(cacher) = cacher.as_ref() {
+    let cached = {
+      let guard = cacher.lock().await;
+      guard.fetch(path)
+    };
+    if let Ok(Some(cached)) = cached {
+      let site = String::from_utf8_lossy_owned(cached.bytes);
+      html!(site).unwrap().write(req, depot, res).await;
+      return Ok(());
+    }
+    let length = tokio::fs::metadata(path)
+      .await
+      .map_err(|e| ServerError::from_private(e).with_404())?
+      .len();
+    if length > 16 * 1024 * 1024 {
+      let site = tokio::fs::read_to_string(path)
+        .await
+        .map_err(|e| ServerError::from_private(e).with_404())?;
+      html!(site).unwrap().write(req, depot, res).await;
+    } else {
+      let cached = CachedFile::construct_from(filename, path, length).await?;
+      {
+        let mut guard = cacher.lock().await;
+        guard.upsert(path, cached.clone())?;
+      }
+      let site = String::from_utf8_lossy_owned(cached.bytes);
+      html!(site).unwrap().write(req, depot, res).await;
+    }
+  } else {
+    let site = tokio::fs::read_to_string(path)
+      .await
+      .map_err(|e| ServerError::from_private(e).with_404())?;
+    html!(site).unwrap().write(req, depot, res).await;
+  }
+  Ok(())
+}
+
 /// In-memory cache implementation for files based on `DashMap`.
-pub struct CacheMap(DashMap<PathBuf, CachedFile>);
+pub struct CacheMap(HashMap<PathBuf, CachedFile>);
 
 impl CacheMap {
   /// Create in-memory cache.
-  pub fn new() -> Arc<Self> {
-    Arc::new(Self(DashMap::new()))
+  pub fn new() -> Arc<Mutex<Self>> {
+    Arc::new(Mutex::new(Self(HashMap::new())))
   }
 
   /// Clear cache.
-  pub fn clear(&self) {
+  pub fn clear(&mut self) {
     self.0.clear();
   }
 
   /// Insert or update content by its path.
-  pub fn upsert(&self, path: impl AsRef<Path>, content: CachedFile) -> MResult<()> {
+  pub fn upsert(&mut self, path: impl AsRef<Path>, content: CachedFile) -> MResult<()> {
     let path = std::fs::canonicalize(path.as_ref()).map_err(ServerError::from_private)?;
     self.0.insert(path, content);
     Ok(())
@@ -220,19 +312,19 @@ impl CacheMap {
   /// Fetch content.
   pub fn fetch(&self, path: impl AsRef<Path>) -> MResult<Option<CachedFile>> {
     let path = std::fs::canonicalize(path.as_ref()).map_err(ServerError::from_private)?;
-    Ok(self.0.get(&path).map(|r#ref| r#ref.value().clone()))
+    Ok(self.0.get(&path).cloned())
   }
 
   /// Remove content due to invalidation.
-  pub fn invalidate(&self, path: impl AsRef<Path>) -> MResult<()> {
+  pub fn invalidate(&mut self, path: impl AsRef<Path>) -> MResult<()> {
     let path = std::fs::canonicalize(path.as_ref()).map_err(ServerError::from_private)?;
     self.0.remove(&path);
     Ok(())
   }
 }
 
 /// Cache invalidator runner.
-pub async fn cache_runner(path: impl AsRef<Path>, cache_map: Arc<CacheMap>) -> MResult<()> {
+pub async fn cache_runner(path: impl AsRef<Path>, cache_map: Arc<Mutex<CacheMap>>) -> MResult<()> {
   let empty = std::collections::HashSet::new();
   loop {
     let (mut wr, rx) = create_watcher(|e| tracing::error!("{e:?}")).map_err(|e| {
@@ -244,8 +336,11 @@ pub async fn cache_runner(path: impl AsRef<Path>, cache_map: Arc<CacheMap>) -> M
       .map_err(ServerError::from_private)?;
 
     let files = fetch_changed(path.as_ref(), rx, &empty).await;
-    for file in files {
-      cache_map.invalidate(file)?;
+    {
+      let mut guard = cache_map.lock().await;
+      for file in files {
+        guard.invalidate(file)?;
+      }
     }
   }
 }

cc-static-server/src/lib.rs

@@ -11,4 +11,6 @@ mod caching;
 mod static_routes;
 
 pub use caching::CacheMap;
-pub use static_routes::{CustomStaticRouter, frontend_router, frontend_router_from_given_dist};
+pub use static_routes::{
+  NoRedirectStaticRouter, ProvidedRoutesStaticRouter, StaticRouter, frontend_router, frontend_router_from_given_dist,
+};

cc-static-server/src/main.rs

@@ -23,6 +23,9 @@ impl GenericSetup for Setup {
 async fn main() {
   let setup = load_generic_config::<Setup>("static-server").await.unwrap();
   let state = load_generic_state(&setup, true).await.unwrap();
+
+  tracing::info!("Static Server (v{})", env!("CARGO_PKG_VERSION"));
+
   let router = get_root_router(&state).push(frontend_router().unwrap());
   let (server, _handler) = start(state, &setup, router).await.unwrap();
   server.await