chore: new crate axum-dpc-static-asset

Author: dpc

Cargo.lock

@@ -11,6 +11,7 @@ members = [
   "crates/rostra-util-error",
   "crates/rostra-util-fmt",
   "crates/rostra-web-ui",
+  "crates/axum-dpc-static-assets",
 ]
 resolver = "2"
 
@@ -34,6 +35,7 @@ license = "MIT"
 async-stream = "0.3.6"
 anyhow = "1.0.95"
 axum = { version = "0.8.1", features = ["macros"] }
+axum-dpc-static-assets = { path = "crates/axum-dpc-static-assets" }
 axum-extra = { version = "0.10.0" }
 backon = "1.3.0"
 bao-tree = "0.13"

Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "axum-dpc-static-assets"
+
+description = "dpc's static asset handler for axum"
+edition = "2024"
+license = "MIT OR APACHE-2.0 OR MPL-2.0"
+version = "0.1.0"
+
+[lints]
+workspace = true
+
+[dependencies]
+async-stream = { workspace = true }
+axum = { workspace = true, features = ["ws", "multipart"] }
+bytes = { workspace = true }
+brotli = { workspace = true }
+futures = { workspace = true }
+snafu = { workspace = true }
+tokio = { workspace = true }
+tokio-stream = { workspace = true, features = ["fs"] }
+tower-service = { workspace = true }
+tracing = { workspace = true }

crates/axum-dpc-static-assets/Cargo.toml

@@ -5,16 +5,66 @@ use std::hash::{Hash, Hasher};
 use std::io::{self, Write as _};
 use std::path::{self, PathBuf};
 use std::string::String;
-use std::sync::LazyLock;
+use std::sync::{Arc, LazyLock};
+use std::task::{Context, Poll};
 
+use axum::body::Body;
+use axum::http::header::{ACCEPT_ENCODING, CONTENT_ENCODING, CONTENT_TYPE};
+use axum::http::{HeaderMap, HeaderValue, Request, Response, StatusCode};
+use axum::response::IntoResponse;
 use bytes::Bytes;
+use futures::future::BoxFuture;
 use futures::stream::{BoxStream, StreamExt};
-use rostra_util_error::WhateverResult;
-use snafu::{OptionExt as _, ResultExt as _};
+use snafu::{OptionExt as _, ResultExt as _, Snafu};
 use tokio_stream::wrappers::ReadDirStream;
+use tower_service::Service;
 use tracing::{debug, info};
 
-use crate::LOG_TARGET;
+const LOG_TARGET: &str = "axum::dpc";
+
+pub type BoxedError = Box<dyn std::error::Error + Send + Sync + 'static>;
+pub type BoxedErrorResult<T> = std::result::Result<T, BoxedError>;
+
+/// Handles ETag-based conditional requests
+///
+/// Takes the request headers, the ETag value, and response headers to modify.
+/// If the client already has the current version (based on If-None-Match
+/// header), returns a 304 Not Modified response.
+///
+/// Returns:
+/// - Some(Response) if a 304 Not Modified should be returned
+/// - None if processing should continue normally
+pub fn handle_etag(
+    req_headers: &axum::http::HeaderMap,
+    etag: &str,
+    resp_headers: &mut axum::http::HeaderMap,
+) -> Option<axum::response::Response> {
+    use axum::http::StatusCode;
+    use axum::http::header::{ETAG, IF_NONE_MATCH};
+    use axum::response::IntoResponse;
+
+    // Add ETag header to response
+    if let Ok(etag_value) = axum::http::HeaderValue::from_str(etag) {
+        resp_headers.insert(ETAG, etag_value);
+    }
+
+    // Check if client already has this version
+    if let Some(if_none_match) = req_headers.get(IF_NONE_MATCH) {
+        if if_none_match.as_bytes() == etag.as_bytes() {
+            return Some((StatusCode::NOT_MODIFIED, resp_headers.clone()).into_response());
+        }
+    }
+
+    None
+}
+
+#[derive(Debug, Snafu)]
+pub enum LoadError {
+    #[snafu(display("IO error for {}", path.display()))]
+    IO { source: io::Error, path: PathBuf },
+    #[snafu(display("Invalid path: {}", path.display()))]
+    InvalidPath { path: PathBuf },
+}
 
 /// Pre-loaded and pre-compressed static assets. This
 /// is used to serve static assets from the build directory without reading from
@@ -23,17 +73,15 @@ use crate::LOG_TARGET;
 pub struct StaticAssets(HashMap<String, StaticAsset>);
 
 impl StaticAssets {
-    pub async fn load(root_dir: &path::Path) -> WhateverResult<Self> {
+    pub async fn load(root_dir: &path::Path) -> Result<Self, LoadError> {
         info!(target: LOG_TARGET, dir=%root_dir.display(), "Loading assets");
         let mut cache = HashMap::default();
 
-        let assets: Vec<WhateverResult<(String, StaticAsset)>> =
+        let assets: Vec<Result<(String, StaticAsset), LoadError>> =
             read_dir_stream(root_dir.to_owned())
                 .map(|file| async move {
-                    let path = file.whatever_context("Failed to read file metadata")?;
-                    // let filename = path.file_name().and_then(|n| n.to_str());
+                    let path = file.with_context(|_e| IOSnafu {  path: root_dir.to_owned() })?;
                     let filename = path.strip_prefix(root_dir).expect("Can't fail").to_str();
-                    // .and_then(|n| n.to_str());
                     let ext = path.extension().and_then(|p| p.to_str());
 
                     let (filename, ext) = match (filename, ext) {
@@ -46,12 +94,12 @@ impl StaticAssets {
                         .into_os_string()
                         .into_string()
                         .ok()
-                        .whatever_context("Invalid path")?;
+                        .with_context(|| InvalidPathSnafu { path: path.to_owned() })?;
                     tracing::debug!(path = %stored_path, "Loading asset");
 
                     let raw = tokio::fs::read(&path)
                         .await
-                        .whatever_context("Could not read file")?;
+                        .with_context(|_e| IOSnafu { path: path.to_owned()})?;
 
                     let compressed = match ext {
                         "css" | "js" | "svg" | "json" => Some(compress_data(&raw)),
@@ -87,7 +135,7 @@ impl StaticAssets {
                 })
                 .buffered(32)
                 .filter_map(
-                    |res_opt: WhateverResult<std::option::Option<(String, StaticAsset)>>| {
+                    |res_opt: Result<std::option::Option<(String, StaticAsset)>, LoadError>| {
                         ready(res_opt.transpose())
                     },
                 )
@@ -102,7 +150,7 @@ impl StaticAssets {
         for (key, asset) in &cache {
             tracing::debug!(%key, path = %asset.path, "Asset loaded");
         }
-        tracing::debug!(len = cache.len(), "Loaded assets");
+        tracing::debug!(target: LOG_TARGET, len = cache.len(), "Loaded assets");
 
         Ok(Self(cache))
     }
@@ -203,3 +251,86 @@ fn read_dir_stream(dir: PathBuf) -> BoxStream<'static, io::Result<PathBuf>> {
     }
     .boxed()
 }
+
+#[derive(Clone)]
+pub struct StaticAssetService {
+    assets: Arc<StaticAssets>,
+}
+
+impl StaticAssetService {
+    pub fn new(assets: Arc<StaticAssets>) -> Self {
+        Self { assets }
+    }
+
+    fn handle_request(&self, req: Request<Body>) -> Response<Body> {
+        let path = req.uri().path().trim_start_matches('/');
+        let Some(asset) = self.assets.get(path) else {
+            dbg!("NOT FOUND", path);
+            return (StatusCode::NOT_FOUND, Body::empty()).into_response();
+        };
+
+        let req_headers = req.headers();
+        let mut resp_headers = HeaderMap::new();
+
+        // Set content type
+        resp_headers.insert(
+            CONTENT_TYPE,
+            HeaderValue::from_static(asset.content_type().unwrap_or("application/octet-stream")),
+        );
+
+        // Handle ETag and conditional request
+        let etag = asset.etag.clone();
+        if let Some(response) = crate::handle_etag(req_headers, &etag, &mut resp_headers) {
+            return response;
+        }
+
+        let accepts_brotli = req_headers
+            .get_all(ACCEPT_ENCODING)
+            .into_iter()
+            .any(|encodings| {
+                let Ok(str) = encodings.to_str() else {
+                    return false;
+                };
+
+                str.split(',').any(|s| s.trim() == "br")
+            });
+
+        let content = match (accepts_brotli, asset.compressed.as_ref()) {
+            (true, Some(compressed)) => {
+                resp_headers.insert(CONTENT_ENCODING, HeaderValue::from_static("br"));
+                compressed.clone()
+            }
+            _ => asset.raw.clone(),
+        };
+
+        (resp_headers, content).into_response()
+    }
+}
+
+impl<B> Service<Request<B>> for StaticAssetService
+where
+    B: Send + 'static,
+{
+    type Response = Response<Body>;
+    type Error = std::convert::Infallible;
+    type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
+
+    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), std::convert::Infallible>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(
+        &mut self,
+        req: Request<B>,
+    ) -> BoxFuture<'static, Result<Response<Body>, std::convert::Infallible>> {
+        let service = self.clone();
+        let uri = req.uri().clone();
+
+        Box::pin(async move {
+            // Convert to a Request<Body> by extracting just the URI
+            let new_req = Request::builder().uri(uri).body(Body::empty()).unwrap();
+
+            Ok(service.handle_request(new_req))
+        })
+    }
+}

crates/rostra-web-ui/src/asset_cache.rs crates/axum-dpc-static-assets/src/lib.rscrates/rostra-web-ui/src/asset_cache.rs renamed to crates/axum-dpc-static-assets/src/lib.rs

@@ -13,6 +13,7 @@ workspace = true
 async-stream = { workspace = true }
 axum = { workspace = true, features = ["ws", "multipart"] }
 axum-extra = { workspace = true, features = ["form"] }
+axum-dpc-static-assets = { workspace = true }
 bon = { workspace = true }
 bytes = { workspace = true }
 brotli = { workspace = true }