itsi 0.2.21.rc1 → 0.2.21

data/crates/itsi_server/src/ruby_types/itsi_http_response.rs

@@ -63,7 +63,7 @@ pub struct ResponseInner {
 
 #[derive(Debug)]
 pub enum ResponseFrame {
-    HttpResponse(HttpResponse),
+    HttpResponse(Box<HttpResponse>),
     HijackedResponse(ItsiHttpResponse),
 }
 
@@ -225,7 +225,9 @@ impl ItsiHttpResponse {
         if let Some(mut response) = self.response.write().take() {
             *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
             if let Some(sender) = self.response_sender.write().take() {
-                sender.send(ResponseFrame::HttpResponse(response)).ok();
+                sender
+                    .send(ResponseFrame::HttpResponse(Box::new(response)))
+                    .ok();
             }
         }
     }
@@ -235,7 +237,9 @@ impl ItsiHttpResponse {
         if let Some(mut response) = self.response.write().take() {
             *response.status_mut() = StatusCode::SERVICE_UNAVAILABLE;
             if let Some(sender) = self.response_sender.write().take() {
-                sender.send(ResponseFrame::HttpResponse(response)).ok();
+                sender
+                    .send(ResponseFrame::HttpResponse(Box::new(response)))
+                    .ok();
             }
         }
     }
@@ -253,7 +257,9 @@ impl ItsiHttpResponse {
                     *response.body_mut() = HttpBody::stream(buffered);
                     self.frame_writer.write().replace(writer);
                     if let Some(sender) = self.response_sender.write().take() {
-                        sender.send(ResponseFrame::HttpResponse(response)).ok();
+                        sender
+                            .send(ResponseFrame::HttpResponse(Box::new(response)))
+                            .ok();
                     }
                 } else {
                     info!("No response!");
@@ -280,7 +286,9 @@ impl ItsiHttpResponse {
                 *response.body_mut() = HttpBody::full(frame);
             }
             if let Some(sender) = self.response_sender.write().take() {
-                sender.send(ResponseFrame::HttpResponse(response)).ok();
+                sender
+                    .send(ResponseFrame::HttpResponse(Box::new(response)))
+                    .ok();
             }
         }
 

data/crates/itsi_server/src/ruby_types/itsi_server/file_watcher.rs

@@ -110,7 +110,7 @@ pub fn send_watcher_command(fd: &OwnedFd, cmd: WatcherCommand) -> Result<()> {
     match write(fd, &buf) {
         Ok(_) => Ok(()),
         Err(e) => Err(magnus::Error::new(
-            magnus::exception::standard_error(),
+            magnus::Ruby::get().unwrap().exception_standard_error(),
             format!("Failed to send command to watcher: {}", e),
         )),
     }
@@ -122,14 +122,14 @@ pub fn watch_groups(
     // Create bidirectional pipes for communication
     let (parent_read_fd, child_write_fd): (OwnedFd, OwnedFd) = pipe().map_err(|e| {
         magnus::Error::new(
-            magnus::exception::standard_error(),
+            magnus::Ruby::get().unwrap().exception_standard_error(),
             format!("Failed to create parent read pipe: {}", e),
         )
     })?;
 
     let (child_read_fd, parent_write_fd): (OwnedFd, OwnedFd) = pipe().map_err(|e| {
         magnus::Error::new(
-            magnus::exception::standard_error(),
+            magnus::Ruby::get().unwrap().exception_standard_error(),
             format!("Failed to create child read pipe: {}", e),
         )
     })?;
@@ -137,7 +137,7 @@ pub fn watch_groups(
     let fork_result = unsafe {
         fork().map_err(|e| {
             magnus::Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 format!("Failed to fork file watcher: {}", e),
             )
         })
@@ -194,7 +194,7 @@ pub fn watch_groups(
 
             let glob = Glob::new(&remaining_pattern).map_err(|e| {
                 magnus::Error::new(
-                    magnus::exception::standard_error(),
+                    magnus::Ruby::get().unwrap().exception_standard_error(),
                     format!(
                         "Failed to create watch glob for pattern '{}': {}",
                         remaining_pattern, e
@@ -203,7 +203,7 @@ pub fn watch_groups(
             })?;
             let glob_set = GlobSetBuilder::new().add(glob).build().map_err(|e| {
                 magnus::Error::new(
-                    magnus::exception::standard_error(),
+                    magnus::Ruby::get().unwrap().exception_standard_error(),
                     format!("Failed to create watch glob set: {}", e),
                 )
             })?;

data/crates/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, TryConvert, Value,
+    RArray, RHash, Ruby, TryConvert, Value,
 };
 use nix::{
     fcntl::{fcntl, FcntlArg, FdFlag},
@@ -161,14 +161,14 @@ impl ServerParams {
                     Vec::<String>::try_convert(error_lines.unwrap().as_value())?;
                 ItsiServerConfig::print_config_errors(errors);
                 return Err(magnus::Error::new(
-                    magnus::exception::runtime_error(),
+                    magnus::Ruby::get().unwrap().exception_runtime_error(),
                     "Failed to set middleware",
                 ));
             }
             let middleware = MiddlewareSet::new(routes_raw)?;
             self.middleware.set(middleware).map_err(|_| {
                 magnus::Error::new(
-                    magnus::exception::runtime_error(),
+                    magnus::Ruby::get().unwrap().exception_runtime_error(),
                     "Failed to set middleware",
                 )
             })?;
@@ -361,7 +361,7 @@ impl ServerParams {
             let bind_to_fd_map: HashMap<String, i32> = serde_json::from_str(preexisting_listeners)
                 .map_err(|e| {
                     magnus::Error::new(
-                        magnus::exception::standard_error(),
+                        magnus::Ruby::get().unwrap().exception_standard_error(),
                         format!("Invalid listener info: {}", e),
                     )
                 })?;
@@ -393,7 +393,10 @@ impl ServerParams {
             .iter()
             .map(|listener| {
                 listener.handover().map_err(|e| {
-                    magnus::Error::new(magnus::exception::runtime_error(), e.to_string())
+                    magnus::Error::new(
+                        magnus::Ruby::get().unwrap().exception_runtime_error(),
+                        e.to_string(),
+                    )
                 })
             })
             .collect::<Result<HashMap<String, i32>>>()?;
@@ -419,7 +422,8 @@ impl ItsiServerConfig {
             itsi_config_proc.clone(),
         ) {
             Ok(server_params) => {
-                cli_params.delete::<_, Value>(Symbol::new("listeners"))?;
+                cli_params
+                    .delete::<_, Value>(magnus::Ruby::get().unwrap().to_symbol("listeners"))?;
 
                 let watcher_fd = if let Some(watchers) = server_params.notify_watchers.clone() {
                     file_watcher::watch_groups(watchers)?
@@ -436,7 +440,7 @@ impl ItsiServerConfig {
                 })
             }
             Err(err) => Err(magnus::Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 format!("Error loading initial configuration {:?}", err),
             )),
         }
@@ -493,7 +497,7 @@ impl ItsiServerConfig {
         if !errors.is_empty() {
             Self::print_config_errors(errors);
             return Err(magnus::Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 "Invalid server config",
             ));
         }
@@ -567,13 +571,13 @@ impl ItsiServerConfig {
             .map(|(str, fd)| {
                 let dupped_fd = dup(*fd).map_err(|errno| {
                     magnus::Error::new(
-                        magnus::exception::standard_error(),
+                        magnus::Ruby::get().unwrap().exception_standard_error(),
                         format!("Errno {} while trying to dup {}", errno, fd),
                     )
                 })?;
                 Self::clear_cloexec(dupped_fd).map_err(|e| {
                     magnus::Error::new(
-                        magnus::exception::standard_error(),
+                        magnus::Ruby::get().unwrap().exception_standard_error(),
                         format!("Failed to clear cloexec flag for fd {}: {}", dupped_fd, e),
                     )
                 })?;
@@ -629,7 +633,7 @@ impl ItsiServerConfig {
             serde_json::to_string(&self.server_params.read().listener_info.lock().clone())
                 .map_err(|e| {
                     magnus::Error::new(
-                        magnus::exception::standard_error(),
+                        magnus::Ruby::get().unwrap().exception_standard_error(),
                         format!("Invalid listener info: {}", e),
                     )
                 })?;

data/crates/itsi_server/src/ruby_types/itsi_server.rs

@@ -13,26 +13,32 @@ use tracing::{info, instrument};
 mod file_watcher;
 pub mod itsi_server_config;
 #[magnus::wrap(class = "Itsi::Server", free_immediately, size)]
-#[derive(Clone)]
+#[derive(Clone, Default)]
 pub struct ItsiServer {
-    pub config: Arc<Mutex<Arc<ItsiServerConfig>>>,
+    pub config: Arc<Mutex<Option<Arc<ItsiServerConfig>>>>,
 }
 
 impl ItsiServer {
-    pub fn new(
-        ruby: &Ruby,
+    pub fn initialize(
+        &self,
         cli_params: RHash,
         itsifile_path: Option<PathBuf>,
         itsi_config_proc: Option<Proc>,
-    ) -> Result<Self> {
-        Ok(Self {
-            config: Arc::new(Mutex::new(Arc::new(ItsiServerConfig::new(
-                ruby,
-                cli_params,
-                itsifile_path,
-                itsi_config_proc,
-            )?))),
-        })
+    ) -> Result<()> {
+        let ruby = Ruby::get().map_err(|_| {
+            magnus::Error::new(
+                magnus::Ruby::get().unwrap().exception_runtime_error(),
+                "Failed to acquire Ruby VM handle",
+            )
+        })?;
+        let config = Arc::new(ItsiServerConfig::new(
+            &ruby,
+            cli_params,
+            itsifile_path,
+            itsi_config_proc,
+        )?);
+        *self.config.lock() = Some(config);
+        Ok(())
     }
 
     pub fn stop(&self) -> Result<()> {
@@ -40,10 +46,20 @@ impl ItsiServer {
         Ok(())
     }
 
+    fn config(&self) -> Result<Arc<ItsiServerConfig>> {
+        self.config.lock().as_ref().cloned().ok_or_else(|| {
+            magnus::Error::new(
+                magnus::Ruby::get().unwrap().exception_runtime_error(),
+                "Itsi::Server not initialized",
+            )
+        })
+    }
+
     #[instrument(skip(self))]
     pub fn start(&self) -> Result<()> {
-        self.config.lock().server_params.read().setup_listeners()?;
-        let result = if self.config.lock().server_params.read().silence {
+        let server_config = self.config()?;
+        server_config.server_params.read().setup_listeners()?;
+        let result = if server_config.server_params.read().silence {
             run_silently(|| self.build_and_run_strategy())
         } else {
             info!("Itsi - Rolling into action. ⚪💨");
@@ -60,11 +76,11 @@ impl ItsiServer {
     }
 
     pub(crate) fn build_strategy(&self) -> Result<ServeStrategy> {
-        let server_config = self.config.lock();
+        let server_config = self.config()?;
         Ok(if server_config.server_params.read().workers > 1 {
-            ServeStrategy::Cluster(Arc::new(ClusterMode::new(server_config.clone())))
+            ServeStrategy::Cluster(Arc::new(ClusterMode::new(server_config)))
         } else {
-            ServeStrategy::Single(Arc::new(SingleMode::new(server_config.clone(), 0)?))
+            ServeStrategy::Single(Arc::new(SingleMode::new(server_config, 0)?))
         })
     }
 

data/crates/itsi_server/src/server/frame_stream.rs

@@ -48,9 +48,10 @@ impl Stream for FrameStream {
                 if this.shutdown_rx.has_changed().unwrap_or(false)
                     && *this.shutdown_rx.borrow() == RunningPhase::ShutdownPending
                 {
-                    while let Ok(bytes) = this.receiver.try_recv() {
+                    if let Ok(bytes) = this.receiver.try_recv() {
                         return Poll::Ready(Some(Ok(bytes)));
                     }
+
                     this.drained = true;
                     return Poll::Ready(None);
                 }

data/crates/itsi_server/src/server/middleware_stack/middleware.rs

@@ -159,7 +159,7 @@ impl Eq for Middleware {}
 
 impl PartialOrd for Middleware {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.variant_order().cmp(&other.variant_order()))
+        Some(self.cmp(other))
     }
 }
 

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

@@ -293,9 +293,7 @@ impl MiddlewareLayer for Compression {
             };
             HttpBody::full(Bytes::from(compressed_bytes))
         } else {
-            let stream = body
-                .into_data_stream()
-                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e));
+            let stream = body.into_data_stream().map_err(std::io::Error::other);
             let async_read_fut = StreamReader::new(stream);
             let reader = BufReader::new(async_read_fut);
             match compression_method {

data/crates/itsi_server/src/server/middleware_stack/middlewares/mod.rs

@@ -43,9 +43,9 @@ pub use error_response::ErrorResponse;
 pub use etag::ETag;
 pub use intrusion_protection::IntrusionProtection;
 pub use log_requests::LogRequests;
-use magnus::error::Result;
 use magnus::rb_sys::AsRawValue;
 use magnus::Value;
+use magnus::{error::Result, Ruby};
 pub use max_body::MaxBody;
 pub use proxy::Proxy;
 pub use rate_limit::RateLimit;
@@ -88,7 +88,13 @@ pub trait FromValue: Sized + Send + Sync + 'static {
             }
         }
 
-        let deserialized: Arc<Self> = Arc::new(deserialize(value)?);
+        let ruby = Ruby::get().map_err(|_| {
+            magnus::Error::new(
+                magnus::Ruby::get().unwrap().exception_runtime_error(),
+                "Failed to acquire Ruby VM handle",
+            )
+        })?;
+        let deserialized: Arc<Self> = Arc::new(deserialize(&ruby, value)?);
         cache.insert(raw, deserialized.clone());
         Ok(deserialized)
     }

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

@@ -280,14 +280,14 @@ impl MiddlewareLayer for Proxy {
                     .build()
                     .map_err(|e| {
                         magnus::Error::new(
-                            magnus::exception::runtime_error(),
+                            magnus::Ruby::get().unwrap().exception_runtime_error(),
                             format!("Failed to build Reqwest client: {}", e),
                         )
                     })?,
             )
             .map_err(|_e| {
                 magnus::Error::new(
-                    magnus::exception::standard_error(),
+                    magnus::Ruby::get().unwrap().exception_standard_error(),
                     "Failed to save resolver backends",
                 )
             })?;

data/crates/itsi_server/src/server/middleware_stack/middlewares/redirect.rs

@@ -42,7 +42,7 @@ impl Redirect {
         *response.status_mut() = self.redirect_type.status_code();
         let destination = self.to.rewrite_request(req, context).parse().map_err(|e| {
             magnus::Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 format!("Invalid Rewrite String: {:?}: {}", self.to, e),
             )
         })?;

data/crates/itsi_server/src/server/middleware_stack/middlewares/ruby_app.rs

@@ -8,7 +8,7 @@ use async_trait::async_trait;
 use derive_more::Debug;
 use either::Either;
 use itsi_rb_helpers::{HeapVal, HeapValue};
-use magnus::{block::Proc, error::Result, value::ReprValue, Symbol};
+use magnus::{block::Proc, error::Result, value::ReprValue};
 use regex::Regex;
 use std::str::FromStr;
 use std::sync::atomic::Ordering;
@@ -44,23 +44,33 @@ impl FromStr for RequestType {
 
 impl RubyApp {
     pub fn from_value(params: HeapVal) -> magnus::error::Result<Arc<Self>> {
-        let app = params.funcall::<_, _, Proc>(Symbol::new("[]"), ("app_proc",))?;
+        let app = params
+            .funcall::<_, _, Proc>(magnus::Ruby::get().unwrap().to_symbol("[]"), ("app_proc",))?;
         let sendfile = params
-            .funcall::<_, _, bool>(Symbol::new("[]"), ("sendfile",))
+            .funcall::<_, _, bool>(magnus::Ruby::get().unwrap().to_symbol("[]"), ("sendfile",))
             .unwrap_or(true);
         let nonblocking = params
-            .funcall::<_, _, bool>(Symbol::new("[]"), ("nonblocking",))
+            .funcall::<_, _, bool>(
+                magnus::Ruby::get().unwrap().to_symbol("[]"),
+                ("nonblocking",),
+            )
             .unwrap_or(false);
         let base_path_src = params
-            .funcall::<_, _, String>(Symbol::new("[]"), ("base_path",))
+            .funcall::<_, _, String>(magnus::Ruby::get().unwrap().to_symbol("[]"), ("base_path",))
             .unwrap_or("".to_owned());
         let script_name = params
-            .funcall::<_, _, Option<String>>(Symbol::new("[]"), ("script_name",))
+            .funcall::<_, _, Option<String>>(
+                magnus::Ruby::get().unwrap().to_symbol("[]"),
+                ("script_name",),
+            )
             .unwrap_or(None);
         let base_path = Regex::new(&base_path_src).unwrap();
 
         let request_type: RequestType = params
-            .funcall::<_, _, String>(Symbol::new("[]"), ("request_type",))
+            .funcall::<_, _, String>(
+                magnus::Ruby::get().unwrap().to_symbol("[]"),
+                ("request_type",),
+            )
             .unwrap_or("http".to_string())
             .parse()
             .unwrap_or(RequestType::Http);

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

@@ -27,6 +27,59 @@ use std::{
 };
 use tracing::debug;
 
+/// Compact representation of the client's Accept-Encoding preferences.
+/// Priority order is determined by the bit checks in `pick_encoding`.
+#[derive(Clone, Copy, Debug, Default)]
+struct AcceptEncodingMask(u8);
+
+impl AcceptEncodingMask {
+    const BR: u8 = 1 << 0;
+    const GZIP: u8 = 1 << 1;
+    const ZSTD: u8 = 1 << 2;
+    const DEFLATE: u8 = 1 << 3;
+
+    fn from_headers(headers: &[HeaderValue]) -> Self {
+        let mut mask = 0u8;
+
+        for hv in headers {
+            let Ok(s) = hv.to_str() else { continue };
+
+            // We intentionally ignore q-values and treat any mention as "acceptable".
+            // This is a fast-path optimization for common benchmark/client headers.
+            for part in s.split(',') {
+                let token = part.split(';').next().unwrap_or("").trim();
+                match token {
+                    "br" => mask |= Self::BR,
+                    "gzip" => mask |= Self::GZIP,
+                    "zstd" => mask |= Self::ZSTD,
+                    "deflate" => mask |= Self::DEFLATE,
+                    _ => {}
+                }
+            }
+        }
+
+        Self(mask)
+    }
+
+    fn pick_encoding(self) -> Option<&'static str> {
+        // Prefer stronger/faster compression if available.
+        // (Actual availability is checked by the file server.)
+        if (self.0 & Self::ZSTD) != 0 {
+            return Some("zstd");
+        }
+        if (self.0 & Self::BR) != 0 {
+            return Some("br");
+        }
+        if (self.0 & Self::GZIP) != 0 {
+            return Some("gzip");
+        }
+        if (self.0 & Self::DEFLATE) != 0 {
+            return Some("deflate");
+        }
+        None
+    }
+}
+
 #[derive(Debug, Deserialize)]
 pub struct StaticAssets {
     pub root_dir: PathBuf,
@@ -98,7 +151,10 @@ impl MiddlewareLayer for StaticAssets {
             return Ok(Either::Left(req));
         }
 
+        // We still populate the context cache for any other middleware that might want it,
+        // but we avoid re-parsing Accept-Encoding later by computing a compact mask here.
         context.set_supported_encoding_set(&req);
+
         let abs_path = req.uri().path();
         let rel_path = if !self.relative_path {
             abs_path.trim_start_matches("/")
@@ -119,7 +175,6 @@ impl MiddlewareLayer for StaticAssets {
         };
 
         debug!(target: "middleware::static_assets", "Asset path is {}", rel_path);
-        // Determine if this is a HEAD request
         let is_head_request = req.method() == Method::HEAD;
 
         // Extract range and if-modified-since headers
@@ -135,6 +190,22 @@ impl MiddlewareLayer for StaticAssets {
         let encodings: &[HeaderValue] = context
             .supported_encoding_set()
             .map_or(&[], |set| set.as_slice());
+
+        // Compute a fast encoding preference and narrow the encoding list we hand to the server.
+        // This avoids repeated per-request string splitting/trim in the static file server.
+        let mask = AcceptEncodingMask::from_headers(encodings);
+        let preferred = mask.pick_encoding();
+
+        let narrowed: [HeaderValue; 1];
+        let encodings_for_server: &[HeaderValue] = if let Some(token) = preferred {
+            // Safe: these are valid header values and the file server only needs to see
+            // a minimal representation to pick a cached variant.
+            narrowed = [HeaderValue::from_static(token)];
+            &narrowed
+        } else {
+            &[]
+        };
+
         let response = file_server
             .serve(
                 &req,
@@ -143,7 +214,7 @@ impl MiddlewareLayer for StaticAssets {
                 serve_range,
                 if_modified_since,
                 is_head_request,
-                encodings,
+                encodings_for_server,
             )
             .await;
 
@@ -156,40 +227,38 @@ impl MiddlewareLayer for StaticAssets {
 }
 
 fn parse_range_header(headers: &HeaderMap) -> ServeRange {
-    let range_header = headers.get(RANGE);
-    if range_header.is_none() {
+    let Some(range_header) = headers.get(RANGE) else {
         return ServeRange::Full;
-    }
-    let range_header = range_header.unwrap().to_str().unwrap_or("");
+    };
+
+    let range_header = range_header.to_str().unwrap_or("");
     let bytes_prefix = "bytes=";
     if !range_header.starts_with(bytes_prefix) {
         return ServeRange::Full;
     }
 
-    let range_str = &range_header[bytes_prefix.len()..];
-
-    let range_parts: Vec<&str> = range_str
+    // Only consider the first range specifier, ignore multi-range requests.
+    let range_str = range_header[bytes_prefix.len()..]
         .split(',')
         .next()
-        .unwrap_or("")
-        .split('-')
-        .collect();
-    if range_parts.len() != 2 {
+        .unwrap_or("");
+
+    let Some((start_str, end_str)) = range_str.split_once('-') else {
         return ServeRange::Full;
-    }
+    };
 
-    let start = if range_parts[0].is_empty() {
-        range_parts[1].parse::<u64>().unwrap_or(0)
-    } else if let Ok(start) = range_parts[0].parse::<u64>() {
+    let start = if start_str.is_empty() {
+        end_str.parse::<u64>().unwrap_or(0)
+    } else if let Ok(start) = start_str.parse::<u64>() {
         start
     } else {
         return ServeRange::Full;
     };
 
-    let end = if range_parts[1].is_empty() {
-        u64::MAX // Use u64::MAX as sentinel for open-ended ranges
-    } else if let Ok(end) = range_parts[1].parse::<u64>() {
-        end // No conversion needed, already u64
+    let end = if end_str.is_empty() {
+        u64::MAX // sentinel for open-ended ranges
+    } else if let Ok(end) = end_str.parse::<u64>() {
+        end
     } else {
         return ServeRange::Full;
     };