itsi-server 0.2.21.rc2 → 0.2.22

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, 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/ext/itsi_server/src/ruby_types/itsi_server.rs

@@ -27,7 +27,7 @@ impl ItsiServer {
     ) -> Result<()> {
         let ruby = Ruby::get().map_err(|_| {
             magnus::Error::new(
-                magnus::exception::runtime_error(),
+                magnus::Ruby::get().unwrap().exception_runtime_error(),
                 "Failed to acquire Ruby VM handle",
             )
         })?;
@@ -49,7 +49,7 @@ impl ItsiServer {
     fn config(&self) -> Result<Arc<ItsiServerConfig>> {
         self.config.lock().as_ref().cloned().ok_or_else(|| {
             magnus::Error::new(
-                magnus::exception::runtime_error(),
+                magnus::Ruby::get().unwrap().exception_runtime_error(),
                 "Itsi::Server not initialized",
             )
         })

data/ext/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/ext/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/ext/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, Ruby};
 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;
@@ -90,7 +90,7 @@ pub trait FromValue: Sized + Send + Sync + 'static {
 
         let ruby = Ruby::get().map_err(|_| {
             magnus::Error::new(
-                magnus::exception::runtime_error(),
+                magnus::Ruby::get().unwrap().exception_runtime_error(),
                 "Failed to acquire Ruby VM handle",
             )
         })?;

data/ext/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/ext/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/ext/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/ext/itsi_server/src/server/middleware_stack/mod.rs

@@ -49,7 +49,7 @@ impl StringMatch {
             let src_str = value.funcall::<_, _, String>("source", ())?;
             let regex = Regex::new(&src_str).map_err(|e| {
                 magnus::Error::new(
-                    magnus::exception::standard_error(),
+                    magnus::Ruby::get().unwrap().exception_standard_error(),
                     format!("Invalid regexp: {}", e),
                 )
             })?;
@@ -142,7 +142,7 @@ impl MiddlewareSet {
             let mut routes = vec![];
             for (index, route) in RArray::from_value(*routes_raw)
                 .ok_or(magnus::Error::new(
-                    magnus::exception::standard_error(),
+                    magnus::Ruby::get().unwrap().exception_standard_error(),
                     format!("Routes must be an array. Got {:?}", routes_raw),
                 ))?
                 .into_iter()
@@ -152,18 +152,18 @@ impl MiddlewareSet {
                 let route_raw = route_hash
                     .get("route")
                     .ok_or(magnus::Error::new(
-                        magnus::exception::standard_error(),
+                        magnus::Ruby::get().unwrap().exception_standard_error(),
                         "Route is missing :route key",
                     ))?
                     .funcall::<_, _, String>("source", ())?;
 
                 let middleware =
                     RHash::from_value(route_hash.get("middleware").ok_or(magnus::Error::new(
-                        magnus::exception::standard_error(),
+                        magnus::Ruby::get().unwrap().exception_standard_error(),
                         "Route is missing middleware key",
                     ))?)
                     .ok_or(magnus::Error::new(
-                        magnus::exception::standard_error(),
+                        magnus::Ruby::get().unwrap().exception_standard_error(),
                         format!("middleware must be a hash. Got {:?}", routes_raw),
                     ))?;
 
@@ -179,7 +179,7 @@ impl MiddlewareSet {
                             RArray::from_value(value)
                                 .ok_or_else(|| {
                                     magnus::Error::new(
-                                        magnus::exception::type_error(),
+                                        magnus::Ruby::get().unwrap().exception_type_error(),
                                         "Expected array",
                                     )
                                 })
@@ -232,7 +232,7 @@ impl MiddlewareSet {
             Ok(Self {
                 route_set: RegexSet::new(&routes).map_err(|e| {
                     magnus::Error::new(
-                        magnus::exception::standard_error(),
+                        magnus::Ruby::get().unwrap().exception_standard_error(),
                         format!("Failed to create route set: {}", e),
                     )
                 })?,
@@ -243,7 +243,7 @@ impl MiddlewareSet {
                     .collect::<std::result::Result<Vec<Regex>, regex::Error>>()
                     .map_err(|e| {
                         magnus::Error::new(
-                            magnus::exception::standard_error(),
+                            magnus::Ruby::get().unwrap().exception_standard_error(),
                             format!("Failed to create route set: {}", e),
                         )
                     })?
@@ -254,7 +254,7 @@ impl MiddlewareSet {
             })
         } else {
             Err(magnus::Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 "Failed to create middleware stack",
             ))
         }
@@ -286,7 +286,7 @@ impl MiddlewareSet {
             self.route_set
         );
         Err(magnus::Error::new(
-            magnus::exception::standard_error(),
+            magnus::Ruby::get().unwrap().exception_standard_error(),
             format!(
                 "No matching middleware stack found for request: {:?}",
                 request
@@ -338,7 +338,7 @@ impl MiddlewareSet {
                 "app" => Ok(Middleware::RubyApp(RubyApp::from_value(parameters.into())?)),
                 "proxy" => Ok(Middleware::Proxy(Proxy::from_value(parameters)?)),
                 _ => Err(magnus::Error::new(
-                    magnus::exception::standard_error(),
+                    magnus::Ruby::get().unwrap().exception_standard_error(),
                     format!("Unknown filter type: {}", mw_type),
                 )),
             }
@@ -349,7 +349,7 @@ impl MiddlewareSet {
         match result {
             Ok(result) => Ok(result),
             Err(err) => Err(magnus::Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 format!(
                     "Failed to instantiate middleware of type {}, due to {}",
                     middleware_type, err

data/ext/itsi_server/src/server/serve_strategy/cluster_mode.rs

@@ -145,9 +145,10 @@ impl ClusterMode {
 
                     call_with_gvl(|_| {
                         create_ruby_thread(move || {
-                            call_without_gvl(move || match worker_clone.boot(self_clone) {
-                                Err(err) => error!("Worker boot failed {:?}", err),
-                                _ => {}
+                            call_without_gvl(move || {
+                                if let Err(err) = worker_clone.boot(self_clone) {
+                                    error!("Worker boot failed {:?}", err);
+                                }
                             })
                         });
                     });

data/ext/itsi_server/src/server/signal.rs

@@ -45,15 +45,17 @@ pub fn unsubscribe_runtime() {
 pub fn send_lifecycle_event(event: LifecycleEvent) {
     if let Some(sender) = SIGNAL_HANDLER_CHANNEL.lock().as_ref() {
         if let Err(e) = sender.send(event) {
-            // Channel full or receivers dropped - this is a critical error for shutdown signals
-            eprintln!("Critical: Failed to send lifecycle event {:?}", e);
-            // For shutdown events, try to force exit if channel delivery fails
             if matches!(
                 e.0,
                 LifecycleEvent::Shutdown | LifecycleEvent::ForceShutdown
             ) {
-                eprintln!("Emergency shutdown due to signal delivery failure");
-                std::process::exit(1);
+                SHUTDOWN_REQUESTED.store(true, Ordering::SeqCst);
+                warn!(
+                    "Dropping shutdown lifecycle event after receiver closed: {:?}",
+                    e
+                );
+            } else {
+                eprintln!("Warning: Failed to send lifecycle event {:?}", e);
             }
         }
     } else {

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

@@ -28,7 +28,7 @@ pub enum HashAlgorithm {
 pub fn create_password_hash(password: String, algo: Value) -> Result<String> {
     let ruby = Ruby::get().map_err(|_| {
         magnus::Error::new(
-            magnus::exception::runtime_error(),
+            magnus::Ruby::get().unwrap().exception_runtime_error(),
             "Failed to acquire Ruby VM handle",
         )
     })?;

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

@@ -598,8 +598,7 @@ impl StaticFileServer {
                             }
                         }
                     }
-                    if index_file.is_some() {
-                        let index_path = index_file.unwrap();
+                    if let Some(index_path) = index_file {
                         self.key_to_path
                             .lock()
                             .insert(key.to_string(), index_path.clone());
@@ -1254,8 +1253,8 @@ async fn generate_directory_listing(
             });
 
             // Serialize the JSON object to a pretty-printed string.
-            let json_string = serde_json::to_string_pretty(&json_obj)
-                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
+            let json_string =
+                serde_json::to_string_pretty(&json_obj).map_err(std::io::Error::other)?;
 
             Ok(json_string)
         }

data/lib/itsi/server/native_extension.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Itsi
+  class Server
+    module NativeExtension
+      module_function
+
+      def require!
+        ruby_abi = RUBY_VERSION[/\A\d+\.\d+/]
+
+        if ruby_abi && versioned_binary_present?(ruby_abi)
+          begin
+            require_relative "#{ruby_abi}/itsi_server"
+            return
+          rescue LoadError
+            # Fall back to the source-built extension when a packaged binary
+            # exists but cannot be loaded on this machine.
+          end
+        end
+
+        require_relative "itsi_server"
+      end
+
+      def versioned_binary_present?(ruby_abi)
+        binary_path = File.join(__dir__, ruby_abi, "itsi_server.#{RbConfig::CONFIG.fetch("DLEXT")}")
+        File.exist?(binary_path)
+      end
+    end
+  end
+end
+
+Itsi::Server::NativeExtension.require!

data/lib/itsi/server/version.rb

@@ -2,6 +2,6 @@
 
 module Itsi
   class Server
-    VERSION = "0.2.21.rc2"
+    VERSION = "0.2.22"
   end
 end

data/lib/itsi/server.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "server/version"
-require_relative "server/itsi_server"
+require_relative "server/native_extension"
 require_relative "server/rack_interface"
 require_relative "server/grpc/grpc_interface"
 require_relative "server/grpc/grpc_call"
@@ -87,7 +87,15 @@ module Itsi
 
       def stop_background_threads
         @running && @running.each(&:stop)
-        @background_threads&.each(&:join)
+        @background_threads&.each do |thread|
+          next unless thread
+
+          thread.join(5)
+          next unless thread.alive?
+
+          thread.kill
+          thread.join(1)
+        end
         @background_threads = []
         @running = []
       end

data/vendor/rb-sys-build/.cargo-ok

@@ -0,0 +1 @@
+{"v":1}

data/vendor/rb-sys-build/.cargo_vcs_info.json

@@ -0,0 +1,6 @@
+{
+  "git": {
+    "sha1": "8b8369748af0e3fa80d20e11b38b423cb2009bdf"
+  },
+  "path_in_vcs": "crates/rb-sys-build"
+}