feat: add static file middleware

Author: benajaero

crates/raw/Cargo.toml

@@ -10,7 +10,7 @@ license = "CC-BY-NC-ND-4.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-tokio = { version = "1", features = ["rt-multi-thread", "macros"] }
+tokio = { version = "1", features = ["rt-multi-thread", "macros", "fs"] }
 hyper = { version = "0.14", features = ["client", "server", "http1", "tcp"] }
 http = "0.2"
 serde = { version = "1", features = ["derive"] }

crates/raw/src/app.rs

@@ -60,6 +60,10 @@ impl App {
         self.middleware.push(middleware(middleware_fn));
     }
 
+    pub fn add_layer(&mut self, layer: Middleware) {
+        self.middleware.push(layer);
+    }
+
     pub async fn listen(self, addr: &str) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         let listener = TcpListener::bind(addr).map_err(|err| {
             eprintln!("Failed to bind {}: {}", addr, err);
@@ -97,18 +101,25 @@ impl App {
         let method = req.method().clone();
         let path = req.uri().path().to_string();
 
-        let response = if let Some(route_match) = self.router.find(&method, &path) {
-            let request = Request::new(req, route_match.params);
-            let handler = route_match.handler;
-            let middleware = Arc::new(self.middleware.clone());
-            let next = Next::new(middleware, handler);
-            next.run(request).await
-        } else if self.router.allows_path(&path) {
-            RawError::MethodNotAllowed.into_response()
+        let (handler, params) = if let Some(route_match) = self.router.find(&method, &path) {
+            (route_match.handler, route_match.params)
         } else {
-            RawError::NotFound.into_response()
+            let method_not_allowed = self.router.allows_path(&path);
+            let fallback = handler(move |_req| async move {
+                if method_not_allowed {
+                    RawError::MethodNotAllowed.into_response()
+                } else {
+                    RawError::NotFound.into_response()
+                }
+            });
+            (fallback, std::collections::HashMap::new())
         };
 
+        let request = Request::new(req, params);
+        let middleware = Arc::new(self.middleware.clone());
+        let next = Next::new(middleware, handler);
+        let response = next.run(request).await;
+
         Ok(response.into_inner())
     }
 }

crates/raw/src/lib.rs

@@ -7,9 +7,11 @@ pub mod middleware;
 pub mod request;
 pub mod response;
 pub mod router;
+pub mod static_files;
 
 pub use app::App;
 pub use config::RawConfig;
 pub use error::RawError;
 pub use request::Request;
 pub use response::{Html, Json, Response, StatusCode, Text};
+pub use static_files::static_files;

crates/raw/src/static_files.rs

@@ -0,0 +1,84 @@
+// Credit: Ben Ajaero
+
+use std::path::{Path, PathBuf};
+
+use http::Method;
+
+use crate::middleware::{middleware, Middleware, Next};
+use crate::request::Request;
+use crate::response::{Response, StatusCode};
+
+pub fn static_files(root: impl Into<PathBuf>) -> Middleware {
+    let root = root.into();
+    middleware(move |req: Request, next: Next| {
+        let root = root.clone();
+        async move {
+            if req.method() != Method::GET {
+                return next.run(req).await;
+            }
+
+            let path = match sanitize_path(req.path()) {
+                Some(path) => path,
+                None => {
+                    return Response::new(StatusCode::BAD_REQUEST, "Bad Request", "text/plain");
+                }
+            };
+
+            let candidate = root.join(path);
+            match tokio::fs::read(&candidate).await {
+                Ok(contents) => Response::new(StatusCode::OK, contents, content_type_for_path(&candidate)),
+                Err(_) => next.run(req).await,
+            }
+        }
+    })
+}
+
+fn sanitize_path(path: &str) -> Option<PathBuf> {
+    let trimmed = path.trim_start_matches('/');
+    if trimmed.contains("..") {
+        return None;
+    }
+
+    let normalized = if trimmed.is_empty() {
+        PathBuf::from("index.html")
+    } else {
+        PathBuf::from(trimmed)
+    };
+
+    Some(normalized)
+}
+
+fn content_type_for_path(path: &Path) -> &'static str {
+    match path.extension().and_then(|ext| ext.to_str()).unwrap_or("") {
+        "html" | "htm" => "text/html; charset=utf-8",
+        "css" => "text/css; charset=utf-8",
+        "js" => "application/javascript",
+        "json" => "application/json",
+        "png" => "image/png",
+        "jpg" | "jpeg" => "image/jpeg",
+        "txt" => "text/plain; charset=utf-8",
+        _ => "application/octet-stream",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{content_type_for_path, sanitize_path};
+    use std::path::Path;
+
+    #[test]
+    fn sanitize_rejects_parent() {
+        assert!(sanitize_path("/../secret").is_none());
+    }
+
+    #[test]
+    fn sanitize_defaults_index() {
+        let path = sanitize_path("/").expect("path");
+        assert_eq!(path.to_string_lossy(), "index.html");
+    }
+
+    #[test]
+    fn content_type_defaults_binary() {
+        assert_eq!(content_type_for_path(Path::new("/tmp/file.bin")), "application/octet-stream");
+    }
+}

crates/raw/tests/static_files.rs

@@ -0,0 +1,38 @@
+// Credit: Ben Ajaero
+
+use std::fs;
+use std::net::TcpListener;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use raw::{static_files, App, Response, StatusCode, Text};
+
+#[tokio::test]
+async fn serves_static_file_before_routes() {
+    let timestamp = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .expect("timestamp")
+        .as_millis();
+    let root = std::env::temp_dir().join(format!("raw-static-{}", timestamp));
+    fs::create_dir_all(&root).expect("create dir");
+    fs::write(root.join("index.html"), "static-content").expect("write file");
+
+    let listener = TcpListener::bind("127.0.0.1:0").expect("bind listener");
+    let addr = listener.local_addr().expect("local addr");
+
+    let mut app = App::new();
+    app.add_layer(static_files(&root));
+    app.get("/", |_req| async { Response::from(Text::new("dynamic")) });
+
+    let server = tokio::spawn(app.serve(listener));
+
+    let client = hyper::Client::new();
+    let uri = format!("http://{}/", addr).parse().expect("uri");
+    let res = client.get(uri).await.expect("response");
+    assert_eq!(res.status(), StatusCode::OK);
+
+    let body = hyper::body::to_bytes(res).await.expect("body bytes");
+    assert_eq!(body, "static-content");
+
+    server.abort();
+    let _ = fs::remove_dir_all(&root);
+}