Improve etag caching

Author: Kioubit

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "registry_wizard"
-version = "0.4.18"
+version = "0.4.19"
 edition = "2024"
 
 [dependencies]
@@ -18,6 +18,7 @@ tokio = { version = "1.50.0", features = ["rt-multi-thread", "signal"], optional
 axum = { version = "0.8.8", optional = true }
 rust-embed = { version = "8.11.0", optional = true }
 mime_guess = { version = "2.0.5", optional = true }
+tower-http = { version = "0.6.8", features = ["compression-br", "compression-gzip"], optional = true }
 
 rpki = {version = "0.19.2", features = ["rtr", "crypto"], optional = true}
 tokio-stream = { version = "0.1.18" , features = ["net"], optional = true}
@@ -29,7 +30,8 @@ explorer = [
     "tokio",
     "axum",
     "rust-embed",
-    "mime_guess"
+    "mime_guess",
+    "tower-http"
 ]
 rtr-server = [
     "tokio",

registry_wizard/Cargo.toml

@@ -1,16 +1,16 @@
 use std::collections::HashMap;
 use std::sync::{Arc, RwLock};
 use axum::extract::{Query, State};
-use axum::http::{HeaderMap, HeaderValue, StatusCode, Uri};
+use axum::http::{header, HeaderMap, HeaderValue, StatusCode, Uri};
 use axum::response::IntoResponse;
 use crate::modules::explorer::{static_files, AppState};
 
-pub(super) async fn root_handler(uri: Uri) -> impl IntoResponse {
+pub(super) async fn root_handler(request_headers: HeaderMap, uri: Uri) -> impl IntoResponse {
     let mut path = uri.path().trim_start_matches('/').to_owned();
     if path.is_empty() {
         path = String::from("index.html");
     }
-    static_files::StaticFile(path)
+    static_files::StaticFile { path, if_none_match: request_headers.get(header::IF_NONE_MATCH).cloned()}
 }
 
 pub(super) async fn index_handler(request_headers: HeaderMap, State(u): State<Arc<RwLock<AppState>>>) -> impl IntoResponse {

registry_wizard/src/modules/explorer/handlers.rs

@@ -6,6 +6,7 @@ use std::path::{Path, PathBuf};
 use std::sync::{Arc, RwLock};
 use tokio::sync::broadcast;
 use tokio::sync::broadcast::channel;
+use tower_http::compression::CompressionLayer;
 use crate::modules::explorer::state::AppState;
 use crate::modules::util::os_signals::{signal_listener, CustomSignal};
 
@@ -79,10 +80,10 @@ async fn start_server(app_state: Arc<RwLock<AppState>>, port: u16, mut sig_chan_
     }
 
     let app = Router::new()
-        .route("/", get(handlers::root_handler))
-        .route("/{*path}", get(handlers::root_handler))
-        .route("/api/index/", get(handlers::index_handler))
-        .route("/api/object/", get(handlers::get_object))
+        .route("/", get(handlers::root_handler).layer(CompressionLayer::new()))
+        .route("/{*path}", get(handlers::root_handler).layer(CompressionLayer::new()))
+        .route("/api/index/", get(handlers::index_handler).layer(CompressionLayer::new()))
+        .route("/api/object/", get(handlers::get_object).layer(CompressionLayer::new()))
         .route("/api/roa/v4/", get(handlers::roa_handler_v4))
         .route("/api/roa/v6/", get(handlers::roa_handler_v6))
         .route("/api/roa/json/", get(handlers::roa_handler_json))

registry_wizard/src/modules/explorer/mod.rs

@@ -1,26 +1,40 @@
 use axum::body::Body;
-use axum::http::{header, StatusCode};
+use axum::http::{header, HeaderValue, StatusCode};
 use axum::response::{IntoResponse, Response};
 use rust_embed::RustEmbed;
 
 #[derive(RustEmbed)]
 #[folder = "src/modules/explorer/static/"]
 struct StaticFiles;
 
-pub(super) struct StaticFile<T>(pub T);
+pub(super) struct StaticFile<T> {
+    pub path: T,
+    pub if_none_match : Option<HeaderValue>,
+}
 impl<T> IntoResponse for StaticFile<T>
 where
     T: Into<String>,
 {
     fn into_response(self) -> Response {
-        let path = self.0.into();
+        let path = self.path.into();
 
         match StaticFiles::get(path.as_str()) {
             Some(content) => {
                 let body = Body::from(content.data);
+                let hash = content.metadata.sha256_hash()
+                    .iter()
+                    .map(|b| format!("{:02x}", b))
+                    .collect::<String>();
+                let etag = format!(r#""{}""#, hash);
+
+                if self.if_none_match.as_ref().and_then(|h| h.to_str().ok()) == Some(&etag) {
+                    return StatusCode::NOT_MODIFIED.into_response();
+                }
+
                 let mime = mime_guess::from_path(path).first_or_octet_stream();
                 Response::builder()
                     .header(header::CONTENT_TYPE, mime.as_ref())
+                    .header(header::ETAG, etag)
                     .header(header::CACHE_CONTROL, "max-age=3600, public, stale-if-error=86400")
                     .body(body)
                     .unwrap()