itsi-server 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 945215c55c27ed88c72156d88ab5606ec321dbb609406a2fa301d620a2dfdb8d
-  data.tar.gz: 74682a5850c9c2d1a2c449550bbeedd932e153dc8e753e5224fcc98999d51353
+  metadata.gz: '09f3db1a1f234effca0f069532c406269afd5d97fd94f2bd84e0897794111c94'
+  data.tar.gz: 9b58b1c27aa1be97ffbcda9f58d7d10773c34ec17ed2f8266f7b4515a1916866
 SHA512:
-  metadata.gz: 2239fac3020f7b9887765b41ab42ea9ffabe08b338875608857b96e93f307637bcf872f5d855feb8906a5cbffd057ea2b0d6a3e9148d3ce9d706b531cd41a897
-  data.tar.gz: 23aab8255a3d5e7bb731c32f65ce340a632363b482dba3f1674c99b4bbb5d22728197523d515205ef18a91b19ea8307fc27144b14d22d186ead5de746d6deb21
+  metadata.gz: 4b0adee39683e6aa6d8fde02c7caeb448924090c85db779cd210ddc01a6b1ded6944604e16b17a9e18cf8833a8565c6473d3761c0015ab13af56570f0b769850
+  data.tar.gz: 2733bfcbb217c88fb2c49f577eb764952551c2c0f6f0be6435505eb55334276367d3ef854bb3aed054f33c192c4c7b5ee02a2ca90d0abf2249b991b1d9a531fd

data/Cargo.lock

@@ -117,9 +117,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.97"
+version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
 [[package]]
 name = "arc-swap"
@@ -253,9 +253,9 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-sys"
-version = "0.28.0"
+version = "0.28.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9f7720b74ed28ca77f90769a71fd8c637a0137f6fae4ae947e1050229cff57f"
+checksum = "bfa9b6986f250236c27e5a204062434a773a13243d2ffc2955f37bdba4c5c6a1"
 dependencies = [
  "bindgen",
  "cc",
@@ -467,9 +467,9 @@ dependencies = [
 
 [[package]]
 name = "brotli-decompressor"
-version = "4.0.2"
+version = "4.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74fa05ad7d803d413eb8380983b092cbbaf9a85f151b871360e7b00cd7060b37"
+checksum = "a334ef7c9e23abf0ce748e8cd309037da93e606ad52eb372e4ce327a0dcfbdfd"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
@@ -587,9 +587,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.36"
+version = "4.5.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2df961d8c8a0d08aa9945718ccf584145eee3f3aa06cddbeac12933781102e04"
+checksum = "eccb054f56cbd38340b380d4a8e69ef1f02f1af43db2f0cc817a4774d80ae071"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -597,9 +597,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.36"
+version = "4.5.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "132dbda40fb6753878316a489d5a1242a8ef2f0d9e47ba01c951ea8aa7d013a5"
+checksum = "efd9466fac8543255d3b1fcad4762c5e116ffe808c8a3043d4263cd4fd4862a2"
 dependencies = [
  "anstream",
  "anstyle",
@@ -764,9 +764,9 @@ dependencies = [
 
 [[package]]
 name = "data-encoding"
-version = "2.8.0"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "575f75dfd25738df5b91b8e43e14d44bda14637a58fae779fd2b064f8bf3e010"
+checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476"
 
 [[package]]
 name = "der-parser"
@@ -1176,9 +1176,9 @@ dependencies = [
 
 [[package]]
 name = "h2"
-version = "0.4.8"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5017294ff4bb30944501348f6f8e42e6ad28f42c8bbef7a74029aff064a4e3c2"
+checksum = "75249d144030531f8dee69fe9cea04d3edf809a017ae445e2abdff6629e86633"
 dependencies = [
  "atomic-waker",
  "bytes",
@@ -1363,7 +1363,7 @@ dependencies = [
  "bytes",
  "futures-channel",
  "futures-util",
- "h2 0.4.8",
+ "h2 0.4.9",
  "http 1.3.1",
  "http-body 1.0.1",
  "httparse",
@@ -1644,7 +1644,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "itsi-server"
-version = "0.2.2"
+version = "0.2.4"
 dependencies = [
  "argon2",
  "async-channel",
@@ -1681,7 +1681,7 @@ dependencies = [
  "parking_lot",
  "percent-encoding",
  "pin-project",
- "rand 0.9.0",
+ "rand 0.9.1",
  "rcgen",
  "redis",
  "regex",
@@ -1713,7 +1713,7 @@ dependencies = [
  "axum-server",
  "base64 0.22.1",
  "chrono",
- "clap 4.5.36",
+ "clap 4.5.37",
  "futures",
  "log",
  "num-bigint",
@@ -1841,9 +1841,9 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
 name = "libc"
-version = "0.2.171"
+version = "0.2.172"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
+checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
 
 [[package]]
 name = "libloading"
@@ -1852,7 +1852,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
 dependencies = [
  "cfg-if",
- "windows-targets 0.52.6",
+ "windows-targets 0.48.5",
 ]
 
 [[package]]
@@ -2366,9 +2366,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.94"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
 dependencies = [
  "unicode-ident",
 ]
@@ -2401,7 +2401,7 @@ checksum = "b820744eb4dc9b57a3398183639c511b5a26d2ed702cedd3febaa1393caa22cc"
 dependencies = [
  "bytes",
  "getrandom 0.3.2",
- "rand 0.9.0",
+ "rand 0.9.1",
  "ring",
  "rustc-hash 2.1.1",
  "rustls",
@@ -2466,13 +2466,12 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3779b94aeb87e8bd4e834cee3650289ee9e0d5677f976ecdb6d219e5f4f6cd94"
+checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
 dependencies = [
  "rand_chacha 0.9.0",
  "rand_core 0.9.3",
- "zerocopy",
 ]
 
 [[package]]
@@ -3062,9 +3061,9 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "signal-hook-registry"
-version = "1.4.2"
+version = "1.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1"
+checksum = "9203b8055f63a2a00e2f593bb0510367fe707d7ff1e5c872de2f537b339e5410"
 dependencies = [
  "libc",
 ]

data/ext/itsi_scheduler/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "itsi-scheduler"
-version = "0.2.2"
+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.2"
+version = "0.2.4"
 edition = "2021"
 authors = ["Wouter Coppieters <wc@pico.net.nz>"]
 license = "MIT"

data/ext/itsi_server/src/ruby_types/itsi_server/itsi_server_config.rs

@@ -14,7 +14,7 @@ use magnus::{
     block::Proc,
     error::Result,
     value::{LazyId, ReprValue},
-    RArray, RHash, Ruby, Symbol, Value,
+    RArray, RHash, Ruby, Symbol, TryConvert, Value,
 };
 use nix::{
     fcntl::{fcntl, FcntlArg, FdFlag},
@@ -124,9 +124,17 @@ impl ServerParams {
                 debug!("Loading Itsi Scheduler");
                 ruby.require("itsi/scheduler")?;
             }
-            let routes_raw = self
+            let result_pair = self
                 .middleware_loader
-                .call::<_, Option<Value>>(())
+                .call::<(), RArray>(())
+                .inspect_err(|e| {
+                    eprintln!("Error loading middleware: {:?}", e);
+                    if let Some(err_value) = e.value() {
+                        print_rb_backtrace(err_value);
+                    }
+                })?;
+            let routes_raw = result_pair
+                .entry::<Option<Value>>(0)
                 .inspect_err(|e| {
                     eprintln!("Error loading middleware: {:?}", e);
                     if let Some(err_value) = e.value() {
@@ -134,6 +142,21 @@ impl ServerParams {
                     }
                 })?
                 .map(|mw| mw.into());
+            let error_lines = result_pair.entry::<Option<RArray>>(1).inspect_err(|e| {
+                eprintln!("Error loading middleware: {:?}", e);
+                if let Some(err_value) = e.value() {
+                    print_rb_backtrace(err_value);
+                }
+            })?;
+            if error_lines.is_some_and(|r| !r.is_empty()) {
+                let errors: Vec<String> =
+                    Vec::<String>::try_convert(error_lines.unwrap().as_value())?;
+                ItsiServerConfig::print_config_errors(errors);
+                return Err(magnus::Error::new(
+                    magnus::exception::runtime_error(),
+                    "Failed to set middleware",
+                ));
+            }
             let middleware = MiddlewareSet::new(routes_raw)?;
             self.middleware.set(middleware).map_err(|_| {
                 magnus::Error::new(

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);
                 }
             }