in memory fe serving cache

Author: phantie

Cargo.lock

@@ -25,5 +25,6 @@ axum = { version = "0.6.20", features = ["headers", "ws"] }
 derive_more = { version = "0.99.17", default-features = false, features = ["display"] }
 serde_json = "1.0.113"
 strum = { version = "0.26.1", features = ["derive"] }
+derived-deref = "2.1.0"
 reqwest = { version = "0.11.14", default-features = false, features = ["cookies"] }
 envtestkit = { version = "1.1.2", default-features = false, features = ["lock"] }

Cargo.toml

@@ -30,14 +30,13 @@ serde_json.workspace = true
 axum.workspace = true
 derive_more.workspace = true
 strum.workspace = true
-
+derived-deref.workspace = true
 
 thiserror = "1.0.39"
 futures-util = "0.3.28"
 anyhow = "1.0.71"
 axum-macros = "0.3.8"
 url = "2.4.1"
-derived-deref = "2.1.0"
 bidirectional-map = "0.1.4"
 rand = "0.8.5"
 

backend/Cargo.toml

@@ -19,6 +19,7 @@ serde.workspace = true
 serde_json.workspace = true
 axum.workspace = true
 derive_more.workspace = true
+derived-deref.workspace = true
 
 bytes = "1.5.0"
 httpdate = "1.0.3"

fe_server/Cargo.toml

@@ -5,21 +5,69 @@ pub struct ServedFile<'a> {
     pub size: &'a str,
 }
 
-pub fn file_response(
-    contents: impl Into<axum::body::Full<bytes::Bytes>>,
-    path: impl AsRef<std::path::Path>,
-    modified: std::time::SystemTime,
-) -> axum::response::Response {
+pub fn file_response(file: &File) -> axum::response::Response {
     use axum::response::IntoResponse;
-    let last_modified = httpdate::fmt_http_date(modified);
-    let mime_type = mime_guess::from_path(path).first_or_text_plain();
+    let last_modified = httpdate::fmt_http_date(file.modified);
+    let mime_type = mime_guess::from_path(&file.path.as_ref()).first_or_text_plain();
+    // tracing::warn!("mime type {mime_type} derived from {:?}", &file.path);
+
     axum::http::Response::builder()
         .status(axum::http::StatusCode::OK)
         .header(
             axum::http::header::CONTENT_TYPE,
             axum::http::HeaderValue::from_str(mime_type.as_ref()).unwrap(),
         )
         .header(axum::http::header::LAST_MODIFIED, last_modified)
-        .body(axum::body::boxed(contents.into()))
+        .body(axum::body::boxed(axum::body::Full::<bytes::Bytes>::from(
+            file.contents.clone(),
+        )))
         .unwrap_or_else(|_| axum::http::StatusCode::INTERNAL_SERVER_ERROR.into_response())
 }
+
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+
+#[derive(Debug)]
+pub struct File {
+    pub contents: Vec<u8>,
+    pub request_path: String,
+    pub path: Box<std::path::PathBuf>,
+    pub modified: std::time::SystemTime,
+}
+
+#[derive(Default, Debug, Clone, derived_deref::Deref)]
+pub struct Cache {
+    #[target]
+    request_path_to_file: Arc<RwLock<HashMap<String, Arc<File>>>>,
+    disk_path_to_file: Arc<RwLock<HashMap<Box<std::path::PathBuf>, Arc<File>>>>,
+}
+
+impl Cache {
+    pub async fn get_request_path(&self, path: &str) -> Option<Arc<File>> {
+        self.request_path_to_file
+            .read()
+            .await
+            .get(path)
+            .map(Clone::clone)
+    }
+
+    pub async fn get_disk_path(&self, path: &std::path::PathBuf) -> Option<Arc<File>> {
+        self.disk_path_to_file
+            .read()
+            .await
+            .get(path)
+            .map(Clone::clone)
+    }
+
+    pub async fn insert(&self, path: String, file: Arc<File>) {
+        self.request_path_to_file
+            .write()
+            .await
+            .insert(path, file.clone());
+        self.disk_path_to_file
+            .write()
+            .await
+            .insert(file.path.clone(), file);
+    }
+}

fe_server/src/serve_files.rs

@@ -62,30 +62,36 @@ mod routing {
     use super::*;
     use axum::routing::get;
     use axum::routing::Router;
+    use tower_http::add_extension::AddExtensionLayer;
 
     mod routes {
         pub mod fallback {
             use std::io::Read;
 
-            use axum::response::IntoResponse;
+            use axum::{body::HttpBody, response::IntoResponse, Extension};
 
             use crate::serve_files::*;
 
-            pub async fn fallback(uri: axum::http::Uri) -> axum::response::Response {
-                let relative_file_path = {
-                    let relative_file_path = uri.to_string();
-                    relative_file_path
-                        .trim_start_matches('/')
-                        .trim()
-                        .to_string()
+            pub async fn fallback(
+                uri: axum::http::Uri,
+                Extension(cache): Extension<crate::serve_files::Cache>,
+            ) -> axum::response::Response {
+                let request_path = {
+                    let request_path = uri.to_string();
+                    request_path.trim_start_matches('/').trim().to_string()
                 };
 
                 use crate::conf;
 
                 let conf = conf::EnvConf::current();
 
+                if let Some(file) = cache.get_request_path(&request_path).await {
+                    tracing::info!("cache hit for request path: {request_path:?}");
+                    return file_response(&file);
+                }
+
                 let dir = std::path::Path::new(&conf.dir);
-                let file_path = dir.join(relative_file_path);
+                let file_path = dir.join(request_path.clone());
 
                 let (file_path) = if file_path.is_file() {
                     file_path
@@ -104,15 +110,43 @@ mod routing {
                     }
                 };
 
-                let mut file = std::fs::File::open(&file_path).expect("opens when exists");
-
-                // tracing::info!("sending file {:?}", file_path);
+                let file = cache.get_disk_path(&file_path).await;
 
-                let modified = file.metadata().unwrap().modified().unwrap();
-                let mut contents = vec![];
-                file.read_to_end(&mut contents);
+                #[allow(unused)]
+                let display_cache_keys = async {
+                    tracing::warn!("cache keys: {:?}", cache.read().await.keys());
+                };
 
-                file_response(contents, file_path, modified)
+                match file {
+                    None => {
+                        tracing::warn!("cache miss on file path: {file_path:?}");
+                        let process_file = |mut file: std::fs::File| {
+                            let modified = file.metadata().unwrap().modified().unwrap();
+                            let mut contents = vec![];
+                            file.read_to_end(&mut contents);
+                            File {
+                                contents,
+                                path: Box::new(file_path.clone()),
+                                request_path: request_path.clone(),
+                                modified,
+                            }
+                        };
+
+                        let mut file = std::fs::File::open(&file_path).expect("opens when exists");
+                        let file = process_file(file);
+                        let response = file_response(&file);
+                        cache.insert(request_path, std::sync::Arc::new(file)).await;
+                        // display_cache_keys.await;
+                        response
+                    }
+                    Some(cached) => {
+                        tracing::info!("cache hit on file path: {file_path:?}");
+                        // do not go to disk, reuse cached value
+                        cache.insert(request_path, cached.clone()).await;
+                        // display_cache_keys.await;
+                        file_response(&cached)
+                    }
+                }
             }
         }
 
@@ -128,6 +162,7 @@ mod routing {
         Router::new()
             .nest("/api", api_router)
             .fallback(routes::fallback::fallback)
+            .layer(AddExtensionLayer::new(crate::serve_files::Cache::default()))
             .layer(crate::trace::request_trace_layer())
     }
 }

fe_server/src/server.rs

@@ -11,6 +11,7 @@ static_routes = { path = "../common/static_routes" }
 
 serde.workspace = true
 serde_json.workspace = true
+derived-deref.workspace = true
 
 # Must match version in flake.nix
 wasm-bindgen = "=0.2.89"
@@ -32,7 +33,6 @@ js-sys = "0.3.64"
 wasm-bindgen-futures = "0.4.37"
 derivative = "2.2.0"
 tokio = { version = "1.35.1", default-features = false, features = ["sync"] }
-derived-deref = "2.1.0"
 
 [dependencies.web-sys]
 version = "0.3.61"