itsi-server 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28ba76ce129635022bb442e61f18dac9c6d29d7552b7b2e006ec16b8c5ef975a
-  data.tar.gz: 944d5bfee24014c8aab5bffede13f73d6316023dcda9df7cbaf7e6fb442f8d9d
+  metadata.gz: '09f3db1a1f234effca0f069532c406269afd5d97fd94f2bd84e0897794111c94'
+  data.tar.gz: 9b58b1c27aa1be97ffbcda9f58d7d10773c34ec17ed2f8266f7b4515a1916866
 SHA512:
-  metadata.gz: 658829fb38833abdd60bbb175f552faddfa26692598626a25a546845bcbe4f1b6478f268b2917c6ef08b5ebf86e93c3bace063ba0594e2a774dca3810d616ce4
-  data.tar.gz: 9089b2a6067e148a8893f8e12e07e9e7fa1e3625b6a8940d3bf4fbae3aa81d3b10ab538250c8a15bdca084d0a603480554bb1663b73deccfc68c6deaba560205
+  metadata.gz: 4b0adee39683e6aa6d8fde02c7caeb448924090c85db779cd210ddc01a6b1ded6944604e16b17a9e18cf8833a8565c6473d3761c0015ab13af56570f0b769850
+  data.tar.gz: 2733bfcbb217c88fb2c49f577eb764952551c2c0f6f0be6435505eb55334276367d3ef854bb3aed054f33c192c4c7b5ee02a2ca90d0abf2249b991b1d9a531fd

data/Cargo.lock

@@ -1644,7 +1644,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "itsi-server"
-version = "0.2.3"
+version = "0.2.4"
 dependencies = [
  "argon2",
  "async-channel",

data/ext/itsi_scheduler/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "itsi-scheduler"
-version = "0.2.3"
+version = "0.2.4"
 edition = "2021"
 authors = ["Wouter Coppieters <wc@pico.net.nz>"]
 license = "MIT"

data/ext/itsi_server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "itsi-server"
-version = "0.2.3"
+version = "0.2.4"
 edition = "2021"
 authors = ["Wouter Coppieters <wc@pico.net.nz>"]
 license = "MIT"

data/ext/itsi_server/src/server/middleware_stack/middlewares/compression.rs

@@ -1,5 +1,6 @@
 use crate::{
-    server::http_message_types::HttpResponse, services::itsi_http_service::HttpRequestContext,
+    server::http_message_types::{HttpRequest, HttpResponse},
+    services::itsi_http_service::HttpRequestContext,
 };
 
 use super::{
@@ -13,6 +14,7 @@ use async_compression::{
 };
 use async_trait::async_trait;
 use bytes::{Bytes, BytesMut};
+use either::Either;
 use futures::TryStreamExt;
 use http::{
     header::{GetAll, CONTENT_ENCODING, CONTENT_LENGTH, CONTENT_TYPE},
@@ -20,6 +22,7 @@ use http::{
 };
 use http_body_util::{combinators::BoxBody, BodyExt, Full, StreamBody};
 use hyper::body::{Body, Frame};
+use magnus::error::Result;
 use serde::{Deserialize, Serialize};
 use std::convert::Infallible;
 use tokio::io::{AsyncRead, AsyncReadExt, BufReader};
@@ -151,6 +154,15 @@ fn update_content_encoding(parts: &mut http::response::Parts, new_encoding: Head
 
 #[async_trait]
 impl MiddlewareLayer for Compression {
+    async fn before(
+        &self,
+        req: HttpRequest,
+        context: &mut HttpRequestContext,
+    ) -> Result<Either<HttpRequest, HttpResponse>> {
+        context.set_supported_encoding_set(&req);
+        Ok(Either::Left(req))
+    }
+
     /// We'll apply compression on the response, where appropriate.
     /// This is if:
     /// * The response body is larger than the minimum size.
@@ -207,16 +219,21 @@ impl MiddlewareLayer for Compression {
             }
         }
 
-        let compression_method = match find_first_supported(
-            &context.supported_encoding_set,
-            self.algorithms.iter().map(|algo| algo.as_str()),
-        ) {
-            Some("gzip") => CompressionAlgorithm::Gzip,
-            Some("br") => CompressionAlgorithm::Brotli,
-            Some("deflate") => CompressionAlgorithm::Deflate,
-            Some("zstd") => CompressionAlgorithm::Zstd,
-            _ => CompressionAlgorithm::Identity,
-        };
+        let compression_method =
+            if let Some(supported_encoding_set) = context.supported_encoding_set() {
+                match find_first_supported(
+                    supported_encoding_set,
+                    self.algorithms.iter().map(|algo| algo.as_str()),
+                ) {
+                    Some("gzip") => CompressionAlgorithm::Gzip,
+                    Some("br") => CompressionAlgorithm::Brotli,
+                    Some("deflate") => CompressionAlgorithm::Deflate,
+                    Some("zstd") => CompressionAlgorithm::Zstd,
+                    _ => CompressionAlgorithm::Identity,
+                }
+            } else {
+                CompressionAlgorithm::Identity
+            };
 
         debug!(
             target: "middleware::compress",

data/ext/itsi_server/src/server/middleware_stack/middlewares/log_requests.rs

@@ -62,7 +62,7 @@ impl MiddlewareLayer for LogRequests {
         req: HttpRequest,
         context: &mut HttpRequestContext,
     ) -> Result<Either<HttpRequest, HttpResponse>> {
-        context.track_start_time();
+        context.init_logging_params();
         if let Some(LogConfig { level, format }) = self.before.as_ref() {
             level.log(format.rewrite_request(&req, context));
         }

data/ext/itsi_server/src/server/middleware_stack/middlewares/proxy.rs

@@ -33,7 +33,7 @@ use reqwest::{
     Body, Client, Url,
 };
 use serde::Deserialize;
-use tracing::{debug, info};
+use tracing::debug;
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct Proxy {
@@ -324,7 +324,6 @@ impl MiddlewareLayer for Proxy {
                 .unwrap_or("")
         });
 
-        info!("Extracted host str is {}", host_str);
         let req_info = RequestInfo {
             method: req.method().clone(),
             headers: req_headers.clone(),

data/ext/itsi_server/src/server/middleware_stack/middlewares/static_assets.rs

@@ -12,10 +12,11 @@ use async_trait::async_trait;
 use either::Either;
 use http::{
     header::{IF_MODIFIED_SINCE, RANGE},
-    HeaderMap, Method,
+    HeaderMap, HeaderValue, Method,
 };
 use itsi_error::ItsiError;
 use magnus::error::Result;
+use moka::sync::Cache;
 use regex::Regex;
 use serde::Deserialize;
 use std::{collections::HashMap, path::PathBuf, sync::OnceLock, time::Duration};
@@ -75,6 +76,10 @@ impl MiddlewareLayer for StaticAssets {
                 recheck_interval: Duration::from_secs(self.file_check_interval),
                 serve_hidden_files: self.serve_hidden_files,
                 allowed_extensions: self.allowed_extensions.clone(),
+                miss_cache: Cache::builder()
+                    .max_capacity(self.max_files_in_memory)
+                    .time_to_live(Duration::from_secs(self.file_check_interval))
+                    .build(),
             })?)
             .map_err(ItsiError::new)?;
         Ok(())
@@ -90,6 +95,8 @@ impl MiddlewareLayer for StaticAssets {
             debug!(target: "middleware::static_assets", "Refusing to handle non-GET/HEAD request");
             return Ok(Either::Left(req));
         }
+
+        context.set_supported_encoding_set(&req);
         let abs_path = req.uri().path();
         let rel_path = if !self.relative_path {
             abs_path.trim_start_matches("/")
@@ -123,6 +130,10 @@ impl MiddlewareLayer for StaticAssets {
 
         // Let the file server handle everything
         let file_server = self.file_server.get().unwrap();
+        let encodings: &[HeaderValue] = context
+            .supported_encoding_set()
+            .map(Vec::as_slice)
+            .unwrap_or(&[] as &[HeaderValue]);
         let response = file_server
             .serve(
                 &req,
@@ -131,9 +142,10 @@ impl MiddlewareLayer for StaticAssets {
                 serve_range,
                 if_modified_since,
                 is_head_request,
-                &context.supported_encoding_set,
+                encodings,
             )
             .await;
+
         if response.is_none() {
             Ok(Either::Left(req))
         } else {

data/ext/itsi_server/src/server/middleware_stack/middlewares/string_rewrite.rs

@@ -50,6 +50,35 @@ pub fn parse_template(template: &str) -> Vec<Segment> {
 }
 
 impl StringRewrite {
+    /// Apply a single modifier of the form `op:arg` (or for replace `op:from,to`)
+    #[inline]
+    fn apply_modifier(s: &mut String, mod_str: &str) {
+        if let Some((op, arg)) = mod_str.split_once(':') {
+            match op {
+                "strip_prefix" => {
+                    if s.starts_with(arg) {
+                        let _ = s.drain(..arg.len());
+                    }
+                }
+                "strip_suffix" => {
+                    if s.ends_with(arg) {
+                        let len = s.len();
+                        let start = len.saturating_sub(arg.len());
+                        let _ = s.drain(start..);
+                    }
+                }
+                "replace" => {
+                    if let Some((from, to)) = arg.split_once(',') {
+                        if s.contains(from) {
+                            *s = s.replace(from, to);
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
     pub fn rewrite_request(&self, req: &HttpRequest, context: &HttpRequestContext) -> String {
         let segments = self
             .segments
@@ -63,9 +92,17 @@ impl StringRewrite {
 
         for segment in segments {
             match segment {
-                Segment::Literal(text) => result.push_str(text),
-                Segment::Placeholder(placeholder) => {
-                    let replacement = match placeholder.as_str() {
+                Segment::Literal(text) => {
+                    result.push_str(text);
+                }
+                Segment::Placeholder(raw) => {
+                    // split into key and optional modifier
+                    let mut parts = raw.split('|');
+                    let key = parts.next().unwrap();
+                    let modifiers = parts; // zero o
+
+                    // 1) lookup the raw replacement
+                    let mut replacement = match key {
                         "request_id" => context.short_request_id(),
                         "request_id_full" => context.request_id(),
                         "method" => req.method().as_str().to_string(),
@@ -76,13 +113,13 @@ impl StringRewrite {
                             .uri()
                             .path_and_query()
                             .map(|pq| pq.to_string())
-                            .unwrap_or("".to_string()),
+                            .unwrap_or_default(),
                         "query" => {
-                            let query = req.uri().query().unwrap_or("").to_string();
-                            if query.is_empty() {
-                                query
+                            let q = req.uri().query().unwrap_or("");
+                            if q.is_empty() {
+                                "".to_string()
                             } else {
-                                format!("?{}", query)
+                                format!("?{}", q)
                             }
                         }
                         "port" => req
@@ -91,31 +128,34 @@ impl StringRewrite {
                             .map(|p| p.to_string())
                             .unwrap_or_else(|| "80".to_string()),
                         "start_time" => {
-                            if let Some(start_time) = context.start_time() {
-                                start_time.format("%Y-%m-%d:%H:%M:%S:%3f").to_string()
+                            if let Some(ts) = context.start_time() {
+                                ts.format("%Y-%m-%d:%H:%M:%S:%3f").to_string()
                             } else {
                                 "N/A".to_string()
                             }
                         }
                         other => {
-                            if let Some(header_val) = req.headers().get(other) {
-                                if let Ok(s) = header_val.to_str() {
-                                    s.to_string()
-                                } else {
-                                    "".to_string()
-                                }
-                            } else if let Some(caps) = &captures {
-                                if let Some(m) = caps.name(other) {
-                                    m.as_str().to_string()
-                                } else {
-                                    // Fallback: leave the placeholder as is.
-                                    format!("{{{}}}", other)
-                                }
-                            } else {
+                            // headers first
+                            if let Some(hv) = req.headers().get(other) {
+                                hv.to_str().unwrap_or("").to_string()
+                            }
+                            // then any regex‐capture
+                            else if let Some(caps) = &captures {
+                                caps.name(other)
+                                    .map(|m| m.as_str().to_string())
+                                    .unwrap_or_else(|| format!("{{{}}}", other))
+                            }
+                            // fallback: leave placeholder intact
+                            else {
                                 format!("{{{}}}", other)
                             }
                         }
                     };
+
+                    for m in modifiers {
+                        Self::apply_modifier(&mut replacement, m);
+                    }
+
                     result.push_str(&replacement);
                 }
             }
@@ -132,37 +172,42 @@ impl StringRewrite {
         let mut result = String::with_capacity(self.template_string.len());
         for segment in segments {
             match segment {
-                Segment::Literal(text) => result.push_str(text),
-                Segment::Placeholder(placeholder) => {
-                    let replacement = match placeholder.as_str() {
+                Segment::Literal(text) => {
+                    result.push_str(text);
+                }
+                Segment::Placeholder(raw) => {
+                    let mut parts = raw.split('|');
+                    let key = parts.next().unwrap();
+                    let modifiers = parts; // zero o
+
+                    let mut replacement = match key {
                         "request_id" => context.short_request_id(),
                         "request_id_full" => context.request_id(),
                         "status" => resp.status().as_str().to_string(),
                         "addr" => context.addr.to_owned(),
                         "response_time" => {
-                            if let Some(response_time) = context.get_response_time() {
-                                if let Some(microseconds) = response_time.num_microseconds() {
-                                    format!("{:.3}ms", microseconds as f64 / 1000.0)
-                                } else {
-                                    format!("{}ms", response_time.num_milliseconds())
-                                }
+                            let dur = context.get_response_time();
+                            let micros = dur.as_micros();
+                            if micros < 1_000 {
+                                format!("{}µs", micros)
                             } else {
-                                "-".to_string()
+                                let ms = dur.as_secs_f64() * 1_000.0;
+                                format!("{:.3}ms", ms)
                             }
                         }
                         other => {
-                            // Try pulling from response headers first
-                            if let Some(val) = resp.headers().get(other) {
-                                if let Ok(s) = val.to_str() {
-                                    s.to_string()
-                                } else {
-                                    "".to_string()
-                                }
+                            if let Some(hv) = resp.headers().get(other) {
+                                hv.to_str().unwrap_or("").to_string()
                             } else {
                                 format!("{{{}}}", other)
                             }
                         }
                     };
+
+                    for m in modifiers {
+                        Self::apply_modifier(&mut replacement, m);
+                    }
+
                     result.push_str(&replacement);
                 }
             }

data/ext/itsi_server/src/services/itsi_http_service.rs

@@ -1,14 +1,15 @@
 use crate::default_responses::{NOT_FOUND_RESPONSE, TIMEOUT_RESPONSE};
 use crate::ruby_types::itsi_server::itsi_server_config::{ItsiServerTokenPreference, ServerParams};
 use crate::server::binds::listener::ListenerInfo;
-use crate::server::http_message_types::{ConversionExt, HttpResponse, RequestExt, ResponseFormat};
+use crate::server::http_message_types::{
+    ConversionExt, HttpRequest, HttpResponse, RequestExt, ResponseFormat,
+};
 use crate::server::lifecycle_event::LifecycleEvent;
 use crate::server::middleware_stack::MiddlewareLayer;
 use crate::server::request_job::RequestJob;
 use crate::server::serve_strategy::single_mode::RunningPhase;
 use crate::server::signal::send_lifecycle_event;
-use chrono;
-use chrono::Local;
+use chrono::{self, DateTime, Local};
 use either::Either;
 use http::header::ACCEPT_ENCODING;
 use http::{HeaderValue, Request};
@@ -18,6 +19,7 @@ use itsi_error::ItsiError;
 use regex::Regex;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::OnceLock;
+use std::time::{Duration, Instant};
 use tracing::error;
 
 use std::{future::Future, ops::Deref, pin::Pin, sync::Arc};
@@ -68,17 +70,16 @@ impl Deref for RequestContextInner {
 }
 
 pub struct RequestContextInner {
-    pub request_id: u128,
+    pub request_id: u64,
     pub service: ItsiHttpService,
     pub accept: ResponseFormat,
     pub matching_pattern: Option<Arc<Regex>>,
     pub origin: OnceLock<Option<String>>,
     pub response_format: OnceLock<ResponseFormat>,
-    pub start_time: chrono::DateTime<chrono::Utc>,
-    pub request: Option<Arc<Request<Incoming>>>,
-    pub request_start_time: OnceLock<chrono::DateTime<Local>>,
+    pub request_start_time: OnceLock<DateTime<Local>>,
+    pub start_instant: Instant,
     pub if_none_match: OnceLock<Option<String>>,
-    pub supported_encoding_set: Vec<HeaderValue>,
+    pub supported_encoding_set: OnceLock<Vec<HeaderValue>>,
     pub is_ruby_request: Arc<AtomicBool>,
 }
 
@@ -87,27 +88,38 @@ impl HttpRequestContext {
         service: ItsiHttpService,
         matching_pattern: Option<Arc<Regex>>,
         accept: ResponseFormat,
-        supported_encoding_set: Vec<HeaderValue>,
         is_ruby_request: Arc<AtomicBool>,
     ) -> Self {
         HttpRequestContext {
             inner: Arc::new(RequestContextInner {
-                request_id: rand::random::<u128>(),
+                request_id: rand::random::<u64>(),
                 service,
                 matching_pattern,
                 accept,
                 origin: OnceLock::new(),
                 response_format: OnceLock::new(),
-                start_time: chrono::Utc::now(),
-                request: None,
                 request_start_time: OnceLock::new(),
+                start_instant: Instant::now(),
                 if_none_match: OnceLock::new(),
-                supported_encoding_set,
+                supported_encoding_set: OnceLock::new(),
                 is_ruby_request,
             }),
         }
     }
 
+    pub fn set_supported_encoding_set(&self, req: &HttpRequest) {
+        let supported_encoding_set = req
+            .headers()
+            .get_all(ACCEPT_ENCODING)
+            .into_iter()
+            .cloned()
+            .collect::<Vec<_>>();
+        self.inner
+            .supported_encoding_set
+            .set(supported_encoding_set)
+            .unwrap();
+    }
+
     pub fn set_origin(&self, origin: Option<String>) {
         self.inner.origin.set(origin).unwrap();
     }
@@ -121,28 +133,29 @@ impl HttpRequestContext {
     }
 
     pub fn short_request_id(&self) -> String {
-        format!("{:016x}", self.inner.request_id & 0xffff_ffff_ffff_ffff)
+        format!("{:08x}", self.inner.request_id & 0xffff_ffff)
     }
 
     pub fn request_id(&self) -> String {
-        format!("{:016x}", self.inner.request_id)
+        format!("{:08x}", self.inner.request_id)
     }
 
-    pub fn track_start_time(&self) {
+    pub fn init_logging_params(&self) {
         self.inner
             .request_start_time
             .get_or_init(chrono::Local::now);
     }
 
-    pub fn start_time(&self) -> Option<chrono::DateTime<Local>> {
+    pub fn start_instant(&self) -> Instant {
+        self.inner.start_instant
+    }
+
+    pub fn start_time(&self) -> Option<DateTime<Local>> {
         self.inner.request_start_time.get().cloned()
     }
 
-    pub fn get_response_time(&self) -> Option<chrono::TimeDelta> {
-        self.inner
-            .request_start_time
-            .get()
-            .map(|instant| Local::now() - instant)
+    pub fn get_response_time(&self) -> Duration {
+        self.inner.start_instant.elapsed()
     }
 
     pub fn set_response_format(&self, format: ResponseFormat) {
@@ -152,6 +165,10 @@ impl HttpRequestContext {
     pub fn response_format(&self) -> &ResponseFormat {
         self.inner.response_format.get().unwrap()
     }
+
+    pub fn supported_encoding_set(&self) -> Option<&Vec<HeaderValue>> {
+        self.inner.supported_encoding_set.get()
+    }
 }
 
 const SERVER_TOKEN_VERSION: HeaderValue =
@@ -170,12 +187,7 @@ impl Service<Request<Incoming>> for ItsiHttpService {
         let accept: ResponseFormat = req.accept().into();
         let accept_clone = accept.clone();
         let is_single_mode = self.server_params.workers == 1;
-        let supported_encoding_set = req
-            .headers()
-            .get_all(ACCEPT_ENCODING)
-            .into_iter()
-            .cloned()
-            .collect::<Vec<_>>();
+
         let request_timeout = self.server_params.request_timeout;
         let is_ruby_request = Arc::new(AtomicBool::new(false));
         let irr_clone = is_ruby_request.clone();
@@ -187,7 +199,6 @@ impl Service<Request<Incoming>> for ItsiHttpService {
                 self_clone,
                 matching_pattern,
                 accept_clone.clone(),
-                supported_encoding_set,
                 irr_clone,
             );
             let mut depth = 0;
@@ -229,8 +240,8 @@ impl Service<Request<Incoming>> for ItsiHttpService {
             Ok(resp)
         };
 
-        Box::pin(async move {
-            if let Some(timeout_duration) = request_timeout {
+        if let Some(timeout_duration) = request_timeout {
+            Box::pin(async move {
                 match timeout(timeout_duration, service_future).await {
                     Ok(result) => result,
                     Err(_) => {
@@ -249,9 +260,9 @@ impl Service<Request<Incoming>> for ItsiHttpService {
                         Ok(TIMEOUT_RESPONSE.to_http_response(accept).await)
                     }
                 }
-            } else {
-                service_future.await
-            }
-        })
+            })
+        } else {
+            Box::pin(service_future)
+        }
     }
 }

data/ext/itsi_server/src/services/static_file_server.rs

@@ -51,6 +51,10 @@ pub static ROOT_STATIC_FILE_SERVER: LazyLock<StaticFileServer> = LazyLock::new(|
         not_found_behavior: NotFoundBehavior::Error(ErrorResponse::not_found()),
         serve_hidden_files: false,
         allowed_extensions: vec!["html".to_string(), "css".to_string(), "js".to_string()],
+        miss_cache: Cache::builder()
+            .max_capacity(1000)
+            .time_to_live(Duration::from_secs(1))
+            .build(),
     })
     .unwrap()
 });
@@ -85,6 +89,7 @@ pub struct StaticFileServerConfig {
     pub headers: Option<HashMap<String, String>>,
     pub serve_hidden_files: bool,
     pub allowed_extensions: Vec<String>,
+    pub miss_cache: Cache<String, NotFoundBehavior>,
 }
 
 #[derive(Debug, Clone)]
@@ -389,6 +394,29 @@ impl StaticFileServer {
         abs_path: &str,
         accept: ResponseFormat,
     ) -> std::result::Result<ResolvedAsset, NotFoundBehavior> {
+        let ext_opt = Path::new(key)
+            .extension()
+            .and_then(|e| e.to_str())
+            .map(|s| s.to_lowercase());
+
+        // If the allowed list is non-empty, enforce membership
+        if !self.allowed_extensions.is_empty() {
+            match ext_opt {
+                Some(ref ext)
+                    if self
+                        .allowed_extensions
+                        .iter()
+                        .any(|ae| ae.eq_ignore_ascii_case(ext)) => {}
+                None if self.config.try_html_extension => {}
+                _ => {
+                    return Err(self.config.not_found_behavior.clone());
+                }
+            }
+        }
+
+        if let Some(cached_nf) = self.miss_cache.get(key) {
+            return Err(cached_nf.clone());
+        }
         // First check if we have a cached mapping for this key
         if let Some(path) = self.key_to_path.lock().await.get(key) {
             // Check if the cached entry is still valid
@@ -449,7 +477,6 @@ impl StaticFileServer {
 
         let mut full_path = self.config.root_dir.clone();
         full_path.push(normalized_path);
-        debug!("Resolving path {:?}", full_path);
         // Check if path exists and is a file
         match tokio::fs::metadata(&full_path).await {
             Ok(metadata) => {
@@ -561,7 +588,6 @@ impl StaticFileServer {
             }
             Err(_) => {
                 // Path doesn't exist, try with .html extension if configured
-                debug!("Path doesn't exist");
                 if self.config.try_html_extension {
                     let mut html_path = full_path.clone();
                     html_path.set_extension("html");
@@ -592,7 +618,9 @@ impl StaticFileServer {
         }
 
         // If we get here, we couldn't resolve the key to a file
-        Err(self.config.not_found_behavior.clone())
+        let nf = self.config.not_found_behavior.clone();
+        self.miss_cache.insert(key.to_string(), nf.clone());
+        Err(nf)
     }
 
     async fn stream_file_range(

data/lib/itsi/server/config/dsl.rb

@@ -52,9 +52,9 @@ module Itsi
           @accepts = accepts.map { |s| s.is_a?(Regexp) ? s : s.to_s }
 
           @options = {
-            middleware_loaders: [],
+            nested_locations: [],
             middleware_loader: lambda do
-              @options[:middleware_loaders].each(&:call)
+              @options[:nested_locations].each(&:call)
               @middleware[:app] ||= {}
               @middleware[:app][:app_proc] = @middleware[:app]&.[](:preloader)&.call || DEFAULT_APP[]
               [flatten_routes, Config.errors_to_error_lines(errors)]

data/lib/itsi/server/config/middleware/endpoint/endpoint.rb

@@ -84,10 +84,6 @@ module Itsi
             end
           else
             @params[:paths] << "" if @params[:paths].empty?
-            @params[:paths] = @params[:paths].flat_map do |p|
-              stripped_trailing = p[/(.*)\/?$/, 1]
-              [stripped_trailing, stripped_trailing + "/"]
-            end.uniq
             location.location(*@params[:paths], methods: @params[:http_methods]) do
               @middleware[:app] = app
             end

data/lib/itsi/server/config/middleware/location.rb

@@ -27,7 +27,7 @@ module Itsi
         end
 
         attr_accessor :location, :routes, :block, :protocols, :hosts, :ports,
-          :extensions, :content_types, :accepts, :block
+          :extensions, :content_types, :accepts
 
         def initialize(location,
           *routes,
@@ -56,13 +56,13 @@ module Itsi
             block: block
           }).to_h
           @routes = params[:routes].empty? ? ["*"] : params[:routes]
-          @methods = params[:methods]
-          @protocols = params[:protocols] | params[:schemes]
-          @hosts = params[:hosts]
-          @ports = params[:ports]
-          @extensions = params[:extensions]
-          @content_types = params[:content_types]
-          @accepts = params[:accepts]
+          @methods = params[:methods].map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @protocols = (params[:protocols] | params[:schemes]).map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @hosts = params[:hosts].map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @ports = params[:ports].map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @extensions = params[:extensions].map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @content_types = params[:content_types].map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @accepts = params[:accepts].map { |s| s.is_a?(Regexp) ? s : s.to_s }
           @block = block
         end
 
@@ -70,27 +70,31 @@ module Itsi
           @methods
         end
 
+        def intersect(a, b)
+          return b if a.empty?
+          return a if b.empty?
+          a & b
+        end
+
         def build!
           build_child = lambda {
-            location.children << DSL.new(
+            child = DSL.new(
               location,
               routes: routes,
-              methods: Array(http_methods) | location.http_methods,
-              protocols: Array(protocols) | location.protocols,
-              hosts: Array(hosts) | location.hosts,
-              ports: Array(ports) | location.ports,
-              extensions: Array(extensions) | location.extensions,
-              content_types: Array(content_types) | location.content_types,
-              accepts: Array(accepts) | location.accepts,
+              methods: intersect(http_methods, location.http_methods),
+              protocols: intersect(protocols, location.protocols),
+              hosts: intersect(hosts, location.hosts),
+              ports: intersect(ports, location.ports),
+              extensions: intersect(extensions, location.extensions),
+              content_types: intersect(content_types, location.content_types),
+              accepts: intersect(accepts, location.accepts),
               controller: location.controller,
               &block
             )
+            child.options[:nested_locations].each(&:call)
+            location.children << child
           }
-          if location.parent.nil?
-            location.options[:middleware_loaders] << build_child
-          else
-            build_child[]
-          end
+          location.options[:nested_locations] << build_child
         end
 
       end

data/lib/itsi/server/config/middleware/proxy.rb

@@ -2,17 +2,16 @@ module Itsi
   class Server
     module Config
       class Proxy < Middleware
-
         insert_text <<~SNIPPET
-        proxy \\
-          to: "${1:http://backend.example.com/api{path}{query}}", \\
-          backends: [${2:"127.0.0.1:3001", "127.0.0.1:3002"}], \\
-          backend_priority: ${3|"round_robin","ordered","random"|}, \\
-          headers: { ${4| "X-Forwarded-For" => { rewrite: "{addr}" },|} }, \\
-          verify_ssl: ${5|true,false|}, \\
-          timeout: ${6|30,60|}, \\
-          tls_sni: ${7|true,false|}, \\
-          error_response: ${8|"bad_gateway", "service_unavailable", { code: 503\\, default_format: "html"\\, html: { inline: "<h1>Service Unavailable</h1>" } }|}
+          proxy \\
+            to: "${1:http://backend.example.com{path_and_query}",
+            backends: [${2:"127.0.0.1:3001", "127.0.0.1:3002"}],
+            backend_priority: ${3|"round_robin","ordered","random"|},
+            headers: { ${4| "X-Forwarded-For" => { rewrite: "{addr}" },|} },
+            verify_ssl: ${5|true,false|},
+            timeout: ${6|30,60|},
+            tls_sni: ${7|true,false|},
+            error_response: ${8|"bad_gateway", "service_unavailable", { code: 503\\, default_format: "html"\\, html: { inline: "<h1>Service Unavailable</h1>" } }|}
         SNIPPET
 
         detail "Forwards incoming requests to a backend server using dynamic URL rewriting. Supports various backend selection strategies and header overriding."
@@ -21,18 +20,20 @@ module Itsi
           {
             to: Type(String) & Required(),
             backends: Array(Type(String)),
-            backend_priority: Enum(["round_robin", "ordered", "random"]).default("round_robin"),
+            backend_priority: Enum(%w[round_robin ordered random]).default("round_robin"),
             headers: Hash(Type(String), Type(String)).default({}),
             verify_ssl: Bool().default(true),
             tls_sni: Bool().default(true),
             timeout: Type(Integer).default(30),
-            error_response: Type(ErrorResponseDef).default("bad_gateway"),
+            error_response: Type(ErrorResponseDef).default("bad_gateway")
           }
         end
 
         def build!
-          require 'uri'
-          @params[:backends]||=  URI.extract(@params[:to]).map(&URI.method(:parse)).map{|u| "#{u.scheme}://#{u.host}:#{u.port}" }
+          require "uri"
+          @params[:backends] ||= URI.extract(@params[:to]).map(&URI.method(:parse)).map do |u|
+            "#{u.scheme}://#{u.host}:#{u.port}"
+          end
           super
         end
       end

data/lib/itsi/server/config/middleware/rackup_file.rb

@@ -2,12 +2,11 @@ module Itsi
   class Server
     module Config
       class RackupFile < Middleware
-
         insert_text <<~SNIPPET
-        rackup_file \\
-          "config.ru",
-          nonblocking: ${2|true,false|},
-          sendfile: ${3|true,false|}
+          rackup_file \\
+            "config.ru",
+            nonblocking: ${2|true,false|},
+            sendfile: ${3|true,false|}
 
         SNIPPET
 
@@ -23,20 +22,18 @@ module Itsi
         def initialize(location, app, **params)
           super(location, params)
           raise "Rackup file must be a string" unless app.is_a?(String)
+
           @app = Itsi::Server::RackInterface.for(app)
         end
 
         def build!
           app_args = {
-            preloader: -> { @app},
+            preloader: -> { @app },
             sendfile: @params[:sendfile],
             nonblocking: @params[:nonblocking],
-            base_path: "^(?<base_path>#{location.paths_from_parent.gsub(/\.\*\)$/, ')')}).*$"
+            base_path: "^(?<base_path>#{location.paths_from_parent.gsub(/\.\*\)$/, ")")}).*$"
           }
           location.middleware[:app] = app_args
-          location.location("*") do
-            @middleware[:app] = app_args
-          end
         end
       end
     end

data/lib/itsi/server/config/middleware/static_assets.rb

@@ -75,11 +75,15 @@ module Itsi
             @params[:allowed_extensions] << ""
           end
 
-          @params[:base_path] = "^(?<base_path>#{location.paths_from_parent}).*$"
-          params = @params
-          location.location("*", extensions: @params[:allowed_extensions]) do
-            @middleware[:static_assets] = params
+          if @params[:allowed_extensions].any? && @params[:auto_index]
+            @params[:allowed_extensions] |= ["html"]
+            @params[:allowed_extensions] |= [""]
           end
+
+          @params[:base_path] = "^(?<base_path>#{location.paths_from_parent.gsub(/\.\*\)$/,")")}).*$"
+          params = @params
+
+          location.middleware[:static_assets] = params
         end
       end
     end

data/lib/itsi/server/config/middleware/string_rewrite.md

@@ -13,6 +13,20 @@ The String Rewrite mechanism is used when configuring Itsi for
 
 It allows you to create dynamic strings from a template by combining literal text with placeholders. Placeholders (denoted using curly braces: `{}`) are replaced at runtime with data derived from the HTTP request, response, or context.
 
+Modifiers can be appended after a pipe | to transform the substituted value.
+
+## Modifiers
+
+After a placeholder name, add |<modifier>:<arg> (or for replace, |replace:<from>,<to>). Available modifiers:
+
+`strip_prefix:<text>` If the substituted value starts with <text>, remove that prefix.
+
+`strip_suffix:<text>` If the substituted value ends with <text>, remove that suffix.
+
+`replace:<from>,<to>` Replace all occurrences of <from> in the substituted value with <to>.
+
+Modifiers are applied in the order they appear. You can chain multiple modifiers by repeating the |<modifier>:<arg> syntax (e.g. `{path|strip_prefix:/rails|replace:old,new}`).
+
 ### Rewriting a Request
 
 The following placeholders are supported:

data/lib/itsi/server/config/options/include.rb

@@ -3,7 +3,7 @@ module Itsi
     module Config
       class Include < Option
 
-        insert_text "include \"${1|other_file.rb|}\" # Include another file to be loaded within the current configuration"
+        insert_text "include \"${1|other_file|}\" # Include another file to be loaded within the current configuration"
 
         detail "Include another file to be loaded within the current configuration"
 

data/lib/itsi/server/rack_interface.rb

@@ -7,7 +7,7 @@ module Itsi
         if app.is_a?(String)
           dir = File.expand_path(File.dirname(app))
           Dir.chdir(dir) do
-            loaded_app = ::Rack::Builder.parse_file(app)
+            loaded_app = ::Rack::Builder.parse_file(File.basename(app))
             app = loaded_app.is_a?(Array) ? loaded_app.first : loaded_app
           end
         end

data/lib/itsi/server/route_tester.rb

@@ -4,7 +4,7 @@ module Itsi
     module RouteTester
       require "set"
       require "strscan"
-      require "debug"
+
       def format_mw(mw)
         mw_name, mw_args = mw
         case mw_name

data/lib/itsi/server/typed_handlers/param_parser.rb

@@ -143,6 +143,31 @@ module Itsi
         # Fixed keys are converted to symbols, and regex-matched keys remain as strings.
         # The current location in the params is tracked as an array of path segments.
         def apply_schema!(params, schema, path = [])
+          # Support top-level array schema: homogeneous arrays.
+          if schema.is_a?(Array)
+            # Only allow homogeneous array types
+            unless schema.size == 1
+              raise ValidationError.new(["Schema Array must contain exactly one type. Got #{schema.size}"])
+            end
+            expected_type = schema.first
+            # Expect params to be an Array
+            unless params.is_a?(Array)
+              raise ValidationError.new(["Expected Array at #{format_path(path)}, got #{params.class}"])
+            end
+            errors = []
+            params.each_with_index do |_, idx|
+              err = cast_value!(params, idx, expected_type, path + [idx])
+              errors << err if err
+            end
+            raise ValidationError.new(errors) unless errors.empty?
+            return params
+          end
+
+          # Ensure schema is a Hash
+          unless schema.is_a?(Hash)
+            raise ValidationError.new(["Unsupported schema type: #{schema.class} at #{format_path(path)}"])
+          end
+
           errors = []
           processed = processed_schema(schema)
           fixed_schema = processed[0]

data/lib/itsi/server/version.rb

@@ -2,6 +2,6 @@
 
 module Itsi
   class Server
-    VERSION = "0.2.3"
+    VERSION = "0.2.4"
   end
 end

data/lib/itsi/server.rb

@@ -262,7 +262,7 @@ module Itsi
       end
 
       def routes(cli_params = {})
-        load_route_middleware_stack(cli_params).each do |stack|
+        load_route_middleware_stack(cli_params).first.each do |stack|
           routes = explode_route_pattern(stack["route"].source)
           routes.each do |route|
             print_route(route, stack)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: itsi-server
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Wouter Coppieters