itsi-server 0.2.21.rc2 → 0.2.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b429e81e1fd3091d28a61a2db0c55ea8d38965077c4da330470c248f8a7f39c
-  data.tar.gz: c6bb3a7a3ac05b5d1a8b75d97774b6576717e900dae56e33bae11b70cf6ea782
+  metadata.gz: 1bd2a908171b06331905949fa422899f9f1c104bc351cf18f64fa194e75d3a53
+  data.tar.gz: 75a9044dc44089edc2555ee72af7a61c51c50910c8845ae05e876bddc369d42b
 SHA512:
-  metadata.gz: cfc08df98fb6faad6c36e240f96e10e9c49f6ffc1f87c4fd874317ea382cf4a27dd06136844d8a3831781c308cac0c49f60ad870e66ad88e09659fd4e10b4a93
-  data.tar.gz: 2b09c90b8079d16998a213f6fdb49cb655463ea6d0c487fafd9c590b0a54c1a64fc3ed360a3ffb7bfbc3135cc5c7e2310f21894de4c3b08fa38d3a7bf1142613
+  metadata.gz: 35d0c81a040e5e182e210ebf0365775c0f8c8e277fa01942b491e43c4a6fee5efe28b48202c3925a6c3158bffe754403d4960ce66f00a7be415df73bc50549f7
+  data.tar.gz: fe30420266024df4a094d49b6cead529faa20a84b940fc6c99c095c5f3d7fd54fc77f103906d56919b7fa2588f65484e3c45c030bbb6467501565ba0a85525ad

data/Cargo.lock

@@ -1642,9 +1642,27 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
+[[package]]
+name = "itsi-scheduler"
+version = "0.2.21"
+dependencies = [
+ "bytes",
+ "derive_more",
+ "itsi_error",
+ "itsi_instrument_entry",
+ "itsi_rb_helpers",
+ "itsi_tracing",
+ "magnus",
+ "mio",
+ "nix",
+ "parking_lot",
+ "rb-sys",
+ "tracing",
+]
+
 [[package]]
 name = "itsi-server"
-version = "0.2.21-rc1"
+version = "0.2.21"
 dependencies = [
  "argon2",
  "async-channel",
@@ -1754,6 +1772,15 @@ dependencies = [
  "thiserror 2.0.12",
 ]
 
+[[package]]
+name = "itsi_instrument_entry"
+version = "0.1.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "itsi_rb_helpers"
 version = "0.1.0"

data/ext/itsi_acme/src/caches/no.rs

@@ -7,7 +7,7 @@ use std::sync::atomic::AtomicPtr;
 
 /// No-op cache, which does nothing.
 /// ```rust
-/// # use tokio_rustls_acme::caches::NoCache;
+/// # use itsi_acme::caches::NoCache;
 /// # type EC = std::io::Error;
 /// # type EA = EC;
 /// let no_cache = NoCache::<EC, EA>::new();

data/ext/itsi_acme/src/caches/test.rs

@@ -10,9 +10,9 @@ use std::sync::atomic::AtomicPtr;
 use std::sync::Arc;
 
 /// Test cache, which generates certificates for ACME incompatible test environments.
-/// ```rust
-/// # use tokio_rustls_acme::{AcmeConfig};
-/// # use tokio_rustls_acme::caches::{DirCache, TestCache};
+/// ```rust,no_run
+/// # use itsi_acme::AcmeConfig;
+/// # use itsi_acme::caches::{DirCache, TestCache};
 /// # let test_environment = true;
 /// let mut config = AcmeConfig::new(["example.com"])
 ///     .cache(DirCache::new("./cache"));

data/ext/itsi_acme/src/config.rs

@@ -31,9 +31,9 @@ impl AcmeConfig<Infallible, Infallible> {
     /// error types will be `Infallible` since the cache cannot return an error. The methods to set
     /// a cache will change the error types to match those returned by the supplied cache.
     ///
-    /// ```rust
-    /// # use tokio_rustls_acme::AcmeConfig;
-    /// use tokio_rustls_acme::caches::DirCache;
+    /// ```rust,no_run
+    /// # use itsi_acme::AcmeConfig;
+    /// use itsi_acme::caches::DirCache;
     /// let config = AcmeConfig::new(["example.com"]).cache(DirCache::new("./rustls_acme_cache"));
     /// ```
     ///
@@ -43,9 +43,9 @@ impl AcmeConfig<Infallible, Infallible> {
     /// An uncached instance of [AcmeConfig] with particular type parameters can be created using
     /// [NoCache].
     ///
-    /// ```rust
-    /// # use tokio_rustls_acme::AcmeConfig;
-    /// use tokio_rustls_acme::caches::NoCache;
+    /// ```rust,no_run
+    /// # use itsi_acme::AcmeConfig;
+    /// use itsi_acme::caches::NoCache;
     /// # type EC = std::io::Error;
     /// # type EA = EC;
     /// let config: AcmeConfig<EC, EA> = AcmeConfig::new(["example.com"]).cache(NoCache::new());

data/ext/itsi_acme/src/lib.rs

@@ -31,7 +31,7 @@
 //! ```rust,no_run
 //! use tokio::io::AsyncWriteExt;
 //! use futures::StreamExt;
-//! use tokio_rustls_acme::{AcmeConfig, caches::DirCache};
+//! use itsi_acme::{AcmeConfig, caches::DirCache};
 //! use tokio_stream::wrappers::TcpListenerStream;
 //!
 //! #[tokio::main]

data/ext/itsi_error/src/lib.rs

@@ -1,9 +1,6 @@
 pub use anyhow::Context;
 use magnus::Error as MagnusError;
-use magnus::{
-    error::ErrorType,
-    exception::{self, arg_error, standard_error},
-};
+use magnus::{error::ErrorType, Ruby};
 use thiserror::Error;
 
 pub static CLIENT_CONNECTION_CLOSED: &str = "Client disconnected";
@@ -73,7 +70,10 @@ pub trait IntoMagnusError {
 
 impl<T: std::error::Error> IntoMagnusError for T {
     fn into_magnus_error(self) -> MagnusError {
-        MagnusError::new(standard_error(), self.to_string())
+        MagnusError::new(
+            Ruby::get().unwrap().exception_standard_error(),
+            self.to_string(),
+        )
     }
 }
 
@@ -92,17 +92,34 @@ impl From<String> for ItsiError {
 impl From<ItsiError> for magnus::Error {
     fn from(err: ItsiError) -> Self {
         match err {
-            ItsiError::InvalidInput(msg) => magnus::Error::new(arg_error(), msg),
-            ItsiError::InternalServerError(msg) => magnus::Error::new(standard_error(), msg),
-            ItsiError::InternalError(msg) => magnus::Error::new(standard_error(), msg),
-            ItsiError::UnsupportedProtocol(msg) => magnus::Error::new(arg_error(), msg),
-            ItsiError::ArgumentError(msg) => magnus::Error::new(arg_error(), msg),
-            ItsiError::Jump(msg) => magnus::Error::new(exception::local_jump_error(), msg),
-            ItsiError::ClientConnectionClosed => {
-                magnus::Error::new(exception::eof_error(), CLIENT_CONNECTION_CLOSED)
+            ItsiError::InvalidInput(msg) => {
+                magnus::Error::new(Ruby::get().unwrap().exception_arg_error(), msg)
+            }
+            ItsiError::InternalServerError(msg) => {
+                magnus::Error::new(Ruby::get().unwrap().exception_standard_error(), msg)
+            }
+            ItsiError::InternalError(msg) => {
+                magnus::Error::new(Ruby::get().unwrap().exception_standard_error(), msg)
+            }
+            ItsiError::UnsupportedProtocol(msg) => {
+                magnus::Error::new(Ruby::get().unwrap().exception_arg_error(), msg)
+            }
+            ItsiError::ArgumentError(msg) => {
+                magnus::Error::new(Ruby::get().unwrap().exception_arg_error(), msg)
+            }
+            ItsiError::Jump(msg) => {
+                magnus::Error::new(Ruby::get().unwrap().exception_local_jump_error(), msg)
+            }
+            ItsiError::ClientConnectionClosed => magnus::Error::new(
+                Ruby::get().unwrap().exception_eof_error(),
+                CLIENT_CONNECTION_CLOSED,
+            ),
+            ItsiError::Break => {
+                magnus::Error::new(Ruby::get().unwrap().exception_interrupt(), "Break")
+            }
+            ItsiError::Pass => {
+                magnus::Error::new(Ruby::get().unwrap().exception_interrupt(), "Pass")
             }
-            ItsiError::Break => magnus::Error::new(exception::interrupt(), "Break"),
-            ItsiError::Pass => magnus::Error::new(exception::interrupt(), "Pass"),
             ItsiError::Io(err) => err.into_magnus_error(),
             ItsiError::Rcgen(err) => err.into_magnus_error(),
             ItsiError::HttpParse(err) => err.into_magnus_error(),

data/ext/itsi_rb_helpers/src/heap_value.rs

@@ -66,7 +66,7 @@ where
     T: ReprValue,
 {
     fn into_value_with(self, _: &Ruby) -> Value {
-        self.0.into_value()
+        self.0.into_value_with(&magnus::Ruby::get().unwrap())
     }
 }
 
@@ -116,7 +116,7 @@ impl Deref for HeapVal {
 
 impl IntoValue for HeapVal {
     fn into_value_with(self, _: &Ruby) -> Value {
-        self.0.into_value()
+        self.0.into_value_with(&magnus::Ruby::get().unwrap())
     }
 }
 

data/ext/itsi_scheduler/Cargo.toml

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

data/ext/itsi_scheduler/src/itsi_scheduler.rs

@@ -68,7 +68,7 @@ impl ItsiScheduler {
     pub fn wake(&self) -> MagnusResult<()> {
         self.waker.lock().wake().map_err(|_| {
             magnus::Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 "Failed to wake the scheduler",
             )
         })?;

data/ext/itsi_server/Cargo.toml

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

data/ext/itsi_server/src/ruby_types/itsi_body_proxy/big_bytes.rs

@@ -50,14 +50,21 @@ impl BigBytes {
                 if bytes.is_empty() {
                     None
                 } else {
-                    Some(bytes.into_value())
+                    Some(bytes.into_value_with(&magnus::Ruby::get().unwrap()))
                 }
             }
             BigBytes::OnDisk(path) => {
                 let ruby = Ruby::get().unwrap();
                 let rarray = ruby.ary_new();
-                rarray.push(path.path().to_str().unwrap().into_value()).ok();
-                Some(rarray.into_value())
+                rarray
+                    .push(
+                        path.path()
+                            .to_str()
+                            .unwrap()
+                            .into_value_with(&magnus::Ruby::get().unwrap()),
+                    )
+                    .ok();
+                Some(rarray.into_value_with(&magnus::Ruby::get().unwrap()))
             }
         }
     }

data/ext/itsi_server/src/ruby_types/itsi_body_proxy/mod.rs

@@ -32,7 +32,9 @@ impl ItsiBody {
     pub fn into_value(&self) -> Option<Value> {
         match self {
             ItsiBody::Buffered(bytes) => bytes.as_value(),
-            ItsiBody::Stream(proxy) => Some(proxy.clone().into_value()),
+            ItsiBody::Stream(proxy) => {
+                Some(proxy.clone().into_value_with(&magnus::Ruby::get().unwrap()))
+            }
             ItsiBody::Empty => None,
         }
     }
@@ -54,7 +56,7 @@ impl ItsiBodyProxy {
             if let Some(chunk) = block_on(stream.next()) {
                 let chunk = chunk.map_err(|err| {
                     magnus::Error::new(
-                        magnus::exception::standard_error(),
+                        magnus::Ruby::get().unwrap().exception_standard_error(),
                         format!("Error reading body {:?}", err),
                     )
                 })?;
@@ -86,7 +88,7 @@ impl ItsiBodyProxy {
             if let Some(chunk) = block_on(stream.next()) {
                 let chunk = chunk.map_err(|err| {
                     magnus::Error::new(
-                        magnus::exception::standard_error(),
+                        magnus::Ruby::get().unwrap().exception_standard_error(),
                         format!("Error reading body {:?}", err),
                     )
                 })?;
@@ -97,7 +99,9 @@ impl ItsiBodyProxy {
                 break;
             }
         }
-        let output_string = buffer.take().unwrap_or(RString::buf_new(buf.len()));
+        let output_string = buffer
+            .take()
+            .unwrap_or(magnus::Ruby::get().unwrap().str_buf_new(buf.len()));
         output_string.cat(buf.clone());
         buf.clear();
         Ok(Some(output_string))
@@ -111,7 +115,7 @@ impl ItsiBodyProxy {
         while let Some(chunk) = block_on(stream.next()) {
             let chunk = chunk.map_err(|err| {
                 magnus::Error::new(
-                    magnus::exception::standard_error(),
+                    magnus::Ruby::get().unwrap().exception_standard_error(),
                     format!("Error reading body {:?}", err),
                 )
             })?;
@@ -133,7 +137,7 @@ impl ItsiBodyProxy {
     fn verify_open(&self) -> MagnusResult<()> {
         if self.closed.load(atomic::Ordering::SeqCst) {
             return Err(magnus::Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 "Body stream is closed",
             ));
         }

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

@@ -64,7 +64,9 @@ impl ItsiGrpcCall {
         let snake_case_method_name = METHOD_NAME_REGEX
             .replace_all(method_name, "${1}_${2}")
             .to_lowercase();
-        Ok(Symbol::new(snake_case_method_name))
+        Ok(magnus::Ruby::get()
+            .unwrap()
+            .to_symbol(snake_case_method_name))
     }
 
     pub fn stream(&self) -> MagnusResult<ItsiGrpcResponseStream> {
@@ -205,7 +207,7 @@ impl ItsiGrpcCall {
         })
         .map_err(|e: std::io::Error| {
             Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 format!("deflate decompression failed: {}", e),
             )
         })?;
@@ -224,7 +226,7 @@ impl ItsiGrpcCall {
         })
         .map_err(|e: std::io::Error| {
             Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 format!("gzip decompression failed: {}", e),
             )
         })?;
@@ -243,7 +245,7 @@ impl ItsiGrpcCall {
         })
         .map_err(|e| {
             Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 format!("gzip compression failed: {e}"),
             )
         })?;
@@ -262,7 +264,7 @@ impl ItsiGrpcCall {
         })
         .map_err(|e| {
             Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 format!("deflate compression failed: {e}"),
             )
         })?;

data/ext/itsi_server/src/ruby_types/itsi_grpc_response_stream/mod.rs

@@ -59,7 +59,7 @@ impl ItsiGrpcResponseStreamInner {
             .blocking_send(ByteFrame::Data(bytes))
             .map_err(|err| {
                 magnus::Error::new(
-                    magnus::exception::io_error(),
+                    magnus::Ruby::get().unwrap().exception_io_error(),
                     format!("Trying to write to closed stream: {:?}", err),
                 )
             })?;
@@ -80,7 +80,7 @@ impl ItsiGrpcResponseStreamInner {
         let trailer_tx = std::mem::replace(&mut self.trailer_tx, oneshot::channel().0);
         trailer_tx.send(header_map).map_err(|err| {
             magnus::Error::new(
-                magnus::exception::standard_error(),
+                magnus::Ruby::get().unwrap().exception_standard_error(),
                 format!("Error sending trailers {:?}", err),
             )
         })?;

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

@@ -6,9 +6,9 @@ use itsi_error::CLIENT_CONNECTION_CLOSED;
 use itsi_rb_helpers::{funcall_no_ret, print_rb_backtrace, HeapValue};
 use itsi_tracing::debug;
 use magnus::{
-    block::{yield_values, Proc},
+    block::Proc,
     error::{ErrorType, Result as MagnusResult},
-    Error, IntoValue, RHash, Symbol,
+    Error, IntoValue, RHash,
 };
 use magnus::{
     value::{LazyId, ReprValue},
@@ -110,20 +110,20 @@ impl ItsiHttpRequest {
                 // when building against Ruby < 3.2...
                 #[cfg(not(ruby_gte_3_2))]
                 {
-                    RHash::new()
+                    magnus::Ruby::get().unwrap().hash_new()
                 }
             };
             for (i, group_name) in re.capture_names().enumerate().skip(1) {
                 if let Some(name) = group_name {
                     if let Some(m) = caps.get(i) {
                         // Insert into the hash: key is the group name, value is the match.
-                        params.aset(Symbol::new(name), m.as_str())?;
+                        params.aset(magnus::Ruby::get().unwrap().to_symbol(name), m.as_str())?;
                     }
                 }
             }
             Ok(params)
         } else {
-            Ok(RHash::new())
+            Ok(magnus::Ruby::get().unwrap().hash_new())
         }
     }
 
@@ -201,7 +201,7 @@ impl ItsiHttpRequest {
                         }
                     },
                     Ok(_) => match receiver.await {
-                        Ok(ResponseFrame::HttpResponse(response)) => Ok(response),
+                        Ok(ResponseFrame::HttpResponse(response)) => Ok(*response),
                         Ok(ResponseFrame::HijackedResponse(response)) => {
                             match response.process_hijacked_response().await {
                                 Ok(result) => Ok(result),
@@ -354,7 +354,10 @@ impl ItsiHttpRequest {
 
     pub(crate) fn each_header(&self) -> MagnusResult<()> {
         self.parts.headers.iter().for_each(|(hn, hv)| {
-            yield_values::<_, Value>((hn.as_str(), hv.to_str().unwrap_or(""))).ok();
+            magnus::Ruby::get()
+                .unwrap()
+                .yield_values::<_, Value>((hn.as_str(), hv.to_str().unwrap_or("")))
+                .ok();
         });
         Ok(())
     }

data/ext/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/ext/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/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/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/version.rb

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

metadata

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