itsi-scheduler 0.1.5 → 0.2.2

data/ext/itsi_server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "itsi-server"
-version = "0.1.0"
+version = "0.2.2"
 edition = "2021"
 authors = ["Wouter Coppieters <wc@pico.net.nz>"]
 license = "MIT"
@@ -10,37 +10,81 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-magnus = { version = "0.7.1", features = ["bytes", "rb-sys"] }
-itsi_tracing = { path = "../itsi_tracing" }
-itsi_rb_helpers = { path = "../itsi_rb_helpers" }
-itsi_error = { path = "../itsi_error" }
-socket2 = "0.5.8"
-parking_lot = "0.12.3"
-rustls-pemfile = "2.2.0"
-tokio-rustls = "0.26.2"
-bytes = "1.3"
-rcgen = { version = "0.13.2", features = ["x509-parser", "pem"] }
+async-compression = { version = "0.4.21", features = [
+  "futures-io",
+  "tokio",
+  "zstd",
+  "brotli",
+  "deflate",
+  "gzip",
+  "zlib",
+] }
+async-channel = "2.3.1"
+async-trait = "0.1.87"
+bcrypt = "0.17.0"
 base64 = "0.22.1"
+bytes = "1.3"
+chrono = "0.4.35"
+derive_more = { version = "2.0.1", features = ["debug"] }
+dirs = "6.0.0"
+either = "1.15.0"
+fs2 = "0.4.3"
+futures = "0.3.31"
+globset = "0.4.16"
+http = "1.3.1"
 http-body-util = "0.1.2"
+httpdate = "1.0.3"
+httparse = "1.10.1"
 hyper = { version = "1.5.0", features = ["full", "server", "http1", "http2"] }
-tokio = { version = "1", features = ["full"] }
 hyper-util = { version = "0.1.10", features = ["full"] }
-derive_more = { version = "2.0.1", features = ["debug"] }
-http = "1.3.1"
-crossbeam = "0.8.4"
-futures = "0.3.31"
-nix = { version = "0.29.0", features = ["socket", "uio", "signal"] }
+itsi_error = { path = "../itsi_error" }
+itsi_rb_helpers = { path = "../itsi_rb_helpers" }
+itsi_tracing = { path = "../itsi_tracing" }
+itsi_acme = { path = "../itsi_acme" }
+jsonwebtoken = "9.3.1"
+magnus = { version = "0.7.1", features = ["bytes", "rb-sys"] }
+moka = { version = "0.12.10", features = ["sync"] }
+notify = { version = "8.0.0" }
+nix = { version = "0.29.0", features = [
+  "socket",
+  "uio",
+  "signal",
+  "fs",
+  "process",
+] }
+num_cpus = "1.16.0"
+parking_lot = "0.12.3"
 pin-project = "1.1.9"
-rb-sys = "0.9.111"
-tracing = "0.1.41"
-tokio-util = "0.7.13"
-tokio-stream = "0.1.17"
-httparse = "1.10.1"
-async-channel = "2.3.1"
-tempfile = "3.18.0"
-sysinfo = "0.33.1"
-tokio-rustls-acme = "0.6.0"
+rand = "0.9.0"
+rcgen = { version = "0.13.2", features = ["x509-parser", "pem"] }
+regex = "1.11.1"
+reqwest = { version = "0.12.15", features = [
+  "stream",
+  "rustls-tls",
+], default-features = false }
+redis = { version = "0.29.2", features = [
+  "tokio-comp",
+  "r2d2",
+  "tokio-rustls-comp",
+  "connection-manager",
+] }
 rustls = "0.23.23"
-fs2 = "0.4.3"
-ring = "0.17.14"
-async-trait = "0.1.87"
+rustls-pemfile = "2.2.0"
+serde = "1.0.219"
+serde_json = "1.0.140"
+serde_magnus = "0.9.0"
+sha2 = "0.10.8"
+socket2 = "0.5.8"
+sysinfo = "0.33.1"
+tempfile = "3.18.0"
+tokio = { version = "1.44.1", features = ["full"] }
+tokio-rustls = "0.26.2"
+tokio-stream = "0.1.17"
+tokio-util = { version = "0.7.14", features = ["compat"] }
+tracing = "0.1.41"
+url = "2.5.4"
+md5 = "0.7.0"
+percent-encoding = "2.3.1"
+sha-crypt = "0.5.0"
+argon2 = "0.5.3"
+core_affinity = "0.8.3"

data/ext/itsi_server/src/default_responses/mod.rs

@@ -0,0 +1,11 @@
+use std::sync::LazyLock;
+
+use crate::server::middleware_stack::ErrorResponse;
+
+pub static TIMEOUT_RESPONSE: LazyLock<ErrorResponse> =
+    LazyLock::new(ErrorResponse::gateway_timeout);
+
+pub static NOT_FOUND_RESPONSE: LazyLock<ErrorResponse> = LazyLock::new(ErrorResponse::not_found);
+
+pub static INTERNAL_SERVER_ERROR_RESPONSE: LazyLock<ErrorResponse> =
+    LazyLock::new(ErrorResponse::internal_server_error);

data/ext/itsi_server/src/env.rs

@@ -0,0 +1,43 @@
+use std::{
+    env::{var, VarError},
+    path::PathBuf,
+    sync::LazyLock,
+};
+
+type StringVar = LazyLock<String>;
+type MaybeStringVar = LazyLock<Result<String, VarError>>;
+type PathVar = LazyLock<PathBuf>;
+
+/// ACME Configuration for auto-generating production certificates
+/// *ITSI_ACME_CACHE_DIR* - Directory to store cached certificates
+/// so that these are not regenerated every time the server starts
+pub static ITSI_ACME_CACHE_DIR: StringVar = LazyLock::new(|| {
+    var("ITSI_ACME_CACHE_DIR").unwrap_or_else(|_| "./.rustls_acme_cache".to_string())
+});
+
+/// *ITSI_ACME_CONTACT_EMAIL* - Contact Email address to provide to ACME server during certificate renewal
+pub static ITSI_ACME_CONTACT_EMAIL: MaybeStringVar =
+    LazyLock::new(|| var("ITSI_ACME_CONTACT_EMAIL"));
+
+/// *ITSI_ACME_CA_PEM_PATH* - Optional CA Pem path, used for testing with non-trusted CAs for certifcate generation.
+pub static ITSI_ACME_CA_PEM_PATH: MaybeStringVar = LazyLock::new(|| var("ITSI_ACME_CA_PEM_PATH"));
+
+/// *ITSI_ACME_DIRECTORY_URL* - Directory URL to use for ACME certificate generation.
+pub static ITSI_ACME_DIRECTORY_URL: StringVar = LazyLock::new(|| {
+    var("ITSI_ACME_DIRECTORY_URL")
+        .unwrap_or_else(|_| "https://acme-v02.api.letsencrypt.org/directory".to_string())
+});
+
+/// *ITSI_ACME_LOCK_FILE_NAME* - Name of the lock file used to prevent concurrent certificate generation.
+pub static ITSI_ACME_LOCK_FILE_NAME: StringVar =
+    LazyLock::new(|| var("ITSI_ACME_LOCK_FILE_NAME").unwrap_or(".acme.lock".to_string()));
+
+pub static ITSI_LOCAL_CA_DIR: PathVar = LazyLock::new(|| {
+    var("ITSI_LOCAL_CA_DIR")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| {
+            dirs::home_dir()
+                .expect("Failed to find HOME directory when initializing ITSI_LOCAL_CA_DIR")
+                .join(".itsi")
+        })
+});

data/ext/itsi_server/src/lib.rs

@@ -1,57 +1,21 @@
-use body_proxy::itsi_body_proxy::ItsiBodyProxy;
-use magnus::{error::Result, function, method, value::Lazy, Module, Object, RClass, RModule, Ruby};
-use request::itsi_request::ItsiRequest;
-use response::itsi_response::ItsiResponse;
-use server::{itsi_server::Server, signal::reset_signal_handlers};
-use tracing::*;
-
-pub mod body_proxy;
-pub mod request;
-pub mod response;
+#![deny(unused_crate_dependencies)]
+pub mod default_responses;
+pub mod env;
+pub mod prelude;
+pub mod ruby_types;
 pub mod server;
+pub mod services;
 
-pub static ITSI_MODULE: Lazy<RModule> = Lazy::new(|ruby| ruby.define_module("Itsi").unwrap());
-pub static ITSI_SERVER: Lazy<RClass> = Lazy::new(|ruby| {
-    ruby.get_inner(&ITSI_MODULE)
-        .define_class("Server", ruby.class_object())
-        .unwrap()
-});
-pub static ITSI_REQUEST: Lazy<RClass> = Lazy::new(|ruby| {
-    ruby.get_inner(&ITSI_MODULE)
-        .define_class("Request", ruby.class_object())
-        .unwrap()
-});
-
-pub static ITSI_RESPONSE: Lazy<RClass> = Lazy::new(|ruby| {
-    ruby.get_inner(&ITSI_MODULE)
-        .define_class("Response", ruby.class_object())
-        .unwrap()
-});
-
-pub static ITSI_BODY_PROXY: Lazy<RClass> = Lazy::new(|ruby| {
-    ruby.get_inner(&ITSI_MODULE)
-        .define_class("BodyProxy", ruby.class_object())
-        .unwrap()
-});
-
-pub static ITSI_SERVER_SCHEDULER_TASK: Lazy<RClass> = Lazy::new(|ruby| {
-    ruby.get_inner(&ITSI_MODULE)
-        .define_class("ServerSchedulerTask", ruby.class_object())
-        .unwrap()
-});
-
-pub fn log_debug(msg: String) {
-    debug!(msg);
-}
-pub fn log_info(msg: String) {
-    info!(msg);
-}
-pub fn log_warn(msg: String) {
-    warn!(msg);
-}
-pub fn log_error(msg: String) {
-    error!(msg);
-}
+use magnus::{error::Result, function, method, Module, Object, Ruby};
+use prelude::*;
+use ruby_types::{
+    itsi_body_proxy::ItsiBodyProxy, itsi_grpc_call::ItsiGrpcCall,
+    itsi_grpc_response_stream::ItsiGrpcResponseStream, itsi_http_request::ItsiHttpRequest,
+    itsi_http_response::ItsiHttpResponse, itsi_server::ItsiServer, ITSI_BODY_PROXY, ITSI_GRPC_CALL,
+    ITSI_GRPC_RESPONSE_STREAM, ITSI_MODULE, ITSI_REQUEST, ITSI_RESPONSE, ITSI_SERVER,
+};
+use server::signal::reset_signal_handlers;
+use services::password_hasher;
 
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<()> {
@@ -65,26 +29,47 @@ fn init(ruby: &Ruby) -> Result<()> {
     itsi.define_singleton_method("log_info", function!(log_info, 1))?;
     itsi.define_singleton_method("log_warn", function!(log_warn, 1))?;
     itsi.define_singleton_method("log_error", function!(log_error, 1))?;
+    itsi.define_singleton_method(
+        "create_password_hash",
+        function!(password_hasher::create_password_hash, 2),
+    )?;
 
     let server = ruby.get_inner(&ITSI_SERVER);
-    server.define_singleton_method("new", function!(Server::new, -1))?;
+    server.define_singleton_method("new", function!(ItsiServer::new, 3))?;
     server.define_singleton_method("reset_signal_handlers", function!(reset_signal_handlers, 0))?;
-    server.define_method("start", method!(Server::start, 0))?;
+    server.define_method("start", method!(ItsiServer::start, 0))?;
+    server.define_method("stop", method!(ItsiServer::stop, 0))?;
 
     let request = ruby.get_inner(&ITSI_REQUEST);
-    request.define_method("path", method!(ItsiRequest::path, 0))?;
-    request.define_method("script_name", method!(ItsiRequest::script_name, 0))?;
-    request.define_method("query_string", method!(ItsiRequest::query_string, 0))?;
-    request.define_method("method", method!(ItsiRequest::method, 0))?;
-    request.define_method("version", method!(ItsiRequest::version, 0))?;
-    request.define_method("rack_protocol", method!(ItsiRequest::rack_protocol, 0))?;
-    request.define_method("host", method!(ItsiRequest::host, 0))?;
-    request.define_method("headers", method!(ItsiRequest::headers, 0))?;
-    request.define_method("scheme", method!(ItsiRequest::scheme, 0))?;
-    request.define_method("remote_addr", method!(ItsiRequest::remote_addr, 0))?;
-    request.define_method("port", method!(ItsiRequest::port, 0))?;
-    request.define_method("body", method!(ItsiRequest::body, 0))?;
-    request.define_method("response", method!(ItsiRequest::response, 0))?;
+    request.define_method("path", method!(ItsiHttpRequest::path, 0))?;
+    request.define_method("script_name", method!(ItsiHttpRequest::script_name, 0))?;
+    request.define_method("query_string", method!(ItsiHttpRequest::query_string, 0))?;
+    request.define_method(
+        "content_type",
+        method!(ItsiHttpRequest::content_type_str, 0),
+    )?;
+    request.define_method(
+        "content_length",
+        method!(ItsiHttpRequest::content_length, 0),
+    )?;
+    request.define_method("request_method", method!(ItsiHttpRequest::method, 0))?;
+    request.define_method("version", method!(ItsiHttpRequest::version, 0))?;
+    request.define_method("rack_protocol", method!(ItsiHttpRequest::rack_protocol, 0))?;
+    request.define_method("host", method!(ItsiHttpRequest::host, 0))?;
+    request.define_method("headers", method!(ItsiHttpRequest::headers, 0))?;
+    request.define_method("uri", method!(ItsiHttpRequest::uri, 0))?;
+    request.define_method("header", method!(ItsiHttpRequest::header, 1))?;
+    request.define_method("[]", method!(ItsiHttpRequest::header, 1))?;
+    request.define_method("scheme", method!(ItsiHttpRequest::scheme, 0))?;
+    request.define_method("remote_addr", method!(ItsiHttpRequest::remote_addr, 0))?;
+    request.define_method("port", method!(ItsiHttpRequest::port, 0))?;
+    request.define_method("body_parts", method!(ItsiHttpRequest::body, 0))?;
+    request.define_method("response", method!(ItsiHttpRequest::response, 0))?;
+    request.define_method("json?", method!(ItsiHttpRequest::is_json, 0))?;
+    request.define_method("html?", method!(ItsiHttpRequest::is_html, 0))?;
+    request.define_method("url_encoded?", method!(ItsiHttpRequest::is_url_encoded, 0))?;
+    request.define_method("multipart?", method!(ItsiHttpRequest::is_multipart, 0))?;
+    request.define_method("url_params", method!(ItsiHttpRequest::url_params, 0))?;
 
     let body_proxy = ruby.get_inner(&ITSI_BODY_PROXY);
     body_proxy.define_method("gets", method!(ItsiBodyProxy::gets, 0))?;
@@ -93,14 +78,68 @@ fn init(ruby: &Ruby) -> Result<()> {
     body_proxy.define_method("close", method!(ItsiBodyProxy::close, 0))?;
 
     let response = ruby.get_inner(&ITSI_RESPONSE);
-    response.define_method("add_header", method!(ItsiResponse::add_header, 2))?;
-    response.define_method("status=", method!(ItsiResponse::set_status, 1))?;
-    response.define_method("send_frame", method!(ItsiResponse::send_frame, 1))?;
-    response.define_method("send_and_close", method!(ItsiResponse::send_and_close, 1))?;
-    response.define_method("close_write", method!(ItsiResponse::close_write, 0))?;
-    response.define_method("close_read", method!(ItsiResponse::close_read, 0))?;
-    response.define_method("close", method!(ItsiResponse::close, 0))?;
-    response.define_method("hijack", method!(ItsiResponse::hijack, 1))?;
+    response.define_method("[]=", method!(ItsiHttpResponse::add_header, 2))?;
+    response.define_method("add_header", method!(ItsiHttpResponse::add_header, 2))?;
+    response.define_method("add_headers", method!(ItsiHttpResponse::add_headers, 1))?;
+    response.define_method("status=", method!(ItsiHttpResponse::set_status, 1))?;
+    response.define_method("send_frame", method!(ItsiHttpResponse::send_frame, 1))?;
+    response.define_method("<<", method!(ItsiHttpResponse::send_frame, 1))?;
+    response.define_method("write", method!(ItsiHttpResponse::send_frame, 1))?;
+    response.define_method("read", method!(ItsiHttpResponse::recv_frame, 0))?;
+    response.define_method(
+        "send_and_close",
+        method!(ItsiHttpResponse::send_and_close, 1),
+    )?;
+    response.define_method("close_write", method!(ItsiHttpResponse::close_write, 0))?;
+    response.define_method("close_read", method!(ItsiHttpResponse::close_read, 0))?;
+    response.define_method("close", method!(ItsiHttpResponse::close, 0))?;
+    response.define_method("hijack", method!(ItsiHttpResponse::hijack, 1))?;
+    response.define_method("accept", method!(ItsiHttpResponse::accept_str, 0))?;
+    response.define_method("json?", method!(ItsiHttpResponse::is_json, 0))?;
+    response.define_method("html?", method!(ItsiHttpResponse::is_html, 0))?;
+
+    let grpc_call = ruby.get_inner(&ITSI_GRPC_CALL);
+    grpc_call.define_method("service_name", method!(ItsiGrpcCall::service_name, 0))?;
+    grpc_call.define_method("method_name", method!(ItsiGrpcCall::method_name, 0))?;
+    grpc_call.define_method("stream", method!(ItsiGrpcCall::stream, 0))?;
+    grpc_call.define_method("json?", method!(ItsiGrpcCall::is_json, 0))?;
+    grpc_call.define_method("content_type", method!(ItsiGrpcCall::content_type_str, 0))?;
+    grpc_call.define_method("timeout", method!(ItsiGrpcCall::timeout, 0))?;
+    grpc_call.define_method("cancelled?", method!(ItsiGrpcCall::is_cancelled, 0))?;
+    grpc_call.define_method("add_headers", method!(ItsiGrpcCall::add_headers, 1))?;
+    grpc_call.define_method("compress_output", method!(ItsiGrpcCall::compress_output, 1))?;
+    grpc_call.define_method(
+        "decompress_input",
+        method!(ItsiGrpcCall::decompress_input, 1),
+    )?;
+    grpc_call.define_method(
+        "should_compress_output?",
+        method!(ItsiGrpcCall::should_compress_output, 1),
+    )?;
+
+    let grpc_response_stream = ruby.get_inner(&ITSI_GRPC_RESPONSE_STREAM);
+    grpc_response_stream
+        .define_method("reader_fileno", method!(ItsiGrpcResponseStream::reader, 0))?;
+    grpc_response_stream.define_method("write", method!(ItsiGrpcResponseStream::write, 1))?;
+    grpc_response_stream.define_method("flush", method!(ItsiGrpcResponseStream::flush, 0))?;
+    grpc_response_stream.define_method(
+        "send_trailers",
+        method!(ItsiGrpcResponseStream::send_trailers, 1),
+    )?;
+    grpc_response_stream.define_method("close", method!(ItsiGrpcResponseStream::close, 0))?;
 
     Ok(())
 }
+
+pub fn log_debug(msg: String) {
+    debug!(msg);
+}
+pub fn log_info(msg: String) {
+    info!(msg);
+}
+pub fn log_warn(msg: String) {
+    warn!(msg);
+}
+pub fn log_error(msg: String) {
+    error!(msg);
+}

data/ext/itsi_server/src/prelude.rs

@@ -0,0 +1,2 @@
+pub use itsi_error::*;
+pub use itsi_tracing::{debug, error, info, trace, warn};

data/ext/itsi_server/src/{body_proxy → ruby_types/itsi_body_proxy}/big_bytes.rs

@@ -6,7 +6,7 @@ use tempfile::NamedTempFile;
 
 const THRESHOLD: usize = 1024 * 1024; // 1 MB
 
-/// An container that holds data in memory if it’s small, or in a temporary file on disk if it exceeds THRESHOLD.
+/// A container that will hold data in memory if it’s small, or in a temporary file on disk if it exceeds THRESHOLD.
 /// Used for providing Rack input data.
 pub enum BigBytes {
     InMemory(Vec<u8>),
@@ -27,7 +27,7 @@ impl BigBytes {
         BigBytes::InMemory(Vec::new())
     }
 
-    /// Reads the entire contents that have been written.
+    /// Returns either the raw bytes, or the file path of the BigBytes
     ///
     /// - If stored in memory, returns a clone of the bytes.
     /// - If stored on disk, returns the file path of the temporary file.
@@ -42,17 +42,22 @@ impl BigBytes {
         }
     }
 
-    pub fn as_value(&self) -> Value {
+    /// Turn this into a value that can be used in Ruby.
+    pub fn as_value(&self) -> Option<Value> {
         match self {
             BigBytes::InMemory(bytes) => {
                 let bytes = Bytes::from(bytes.to_owned());
-                bytes.into_value()
+                if bytes.is_empty() {
+                    None
+                } else {
+                    Some(bytes.into_value())
+                }
             }
             BigBytes::OnDisk(path) => {
                 let ruby = Ruby::get().unwrap();
                 let rarray = ruby.ary_new();
                 rarray.push(path.path().to_str().unwrap().into_value()).ok();
-                rarray.into_value()
+                Some(rarray.into_value())
             }
         }
     }

data/ext/itsi_server/src/{body_proxy/itsi_body_proxy.rs → ruby_types/itsi_body_proxy/mod.rs}

@@ -1,4 +1,5 @@
-use super::big_bytes::BigBytes;
+pub mod big_bytes;
+use big_bytes::BigBytes;
 use bytes::Bytes;
 use futures::executor::block_on;
 use http_body_util::{BodyDataStream, BodyExt};
@@ -11,10 +12,12 @@ use std::sync::{
 };
 use tokio_stream::StreamExt;
 
+use crate::server::size_limited_incoming::SizeLimitedIncoming;
+
 #[magnus::wrap(class = "Itsi::BodyProxy", free_immediately, size)]
 #[derive(Debug, Clone)]
 pub struct ItsiBodyProxy {
-    pub incoming: Arc<Mutex<BodyDataStream<Incoming>>>,
+    pub incoming: Arc<Mutex<BodyDataStream<SizeLimitedIncoming<Incoming>>>>,
     pub closed: Arc<AtomicBool>,
     pub buf: Arc<Mutex<Vec<u8>>>,
 }
@@ -25,15 +28,15 @@ pub enum ItsiBody {
 }
 
 impl ItsiBody {
-    pub fn into_value(&self) -> Value {
+    pub fn into_value(&self) -> Option<Value> {
         match self {
             ItsiBody::Buffered(bytes) => bytes.as_value(),
-            ItsiBody::Stream(proxy) => proxy.clone().into_value(),
+            ItsiBody::Stream(proxy) => Some(proxy.clone().into_value()),
         }
     }
 }
 impl ItsiBodyProxy {
-    pub fn new(incoming: Incoming) -> Self {
+    pub fn new(incoming: SizeLimitedIncoming<Incoming>) -> Self {
         ItsiBodyProxy {
             incoming: Arc::new(Mutex::new(incoming.into_data_stream())),
             closed: Arc::new(AtomicBool::new(false)),
@@ -49,7 +52,7 @@ impl ItsiBodyProxy {
             if let Some(chunk) = block_on(stream.next()) {
                 let chunk = chunk.map_err(|err| {
                     magnus::Error::new(
-                        magnus::exception::exception(),
+                        magnus::exception::standard_error(),
                         format!("Error reading body {:?}", err),
                     )
                 })?;
@@ -81,7 +84,7 @@ impl ItsiBodyProxy {
             if let Some(chunk) = block_on(stream.next()) {
                 let chunk = chunk.map_err(|err| {
                     magnus::Error::new(
-                        magnus::exception::exception(),
+                        magnus::exception::standard_error(),
                         format!("Error reading body {:?}", err),
                     )
                 })?;
@@ -98,6 +101,24 @@ impl ItsiBodyProxy {
         Ok(Some(output_string))
     }
 
+    pub fn to_bytes(&self) -> MagnusResult<Vec<u8>> {
+        self.verify_open()?;
+        let mut stream = self.incoming.lock();
+        let mut buf = self.buf.lock();
+
+        while let Some(chunk) = block_on(stream.next()) {
+            let chunk = chunk.map_err(|err| {
+                magnus::Error::new(
+                    magnus::exception::standard_error(),
+                    format!("Error reading body {:?}", err),
+                )
+            })?;
+            buf.extend_from_slice(&chunk);
+        }
+
+        Ok(buf.clone())
+    }
+
     /// Equivalent to calling gets and yielding it, until we reach EOF
     pub fn each(ruby: &Ruby, rbself: &Self) -> MagnusResult<()> {
         let proc = ruby.block_proc()?;
@@ -110,7 +131,7 @@ impl ItsiBodyProxy {
     fn verify_open(&self) -> MagnusResult<()> {
         if self.closed.load(atomic::Ordering::SeqCst) {
             return Err(magnus::Error::new(
-                magnus::exception::exception(),
+                magnus::exception::standard_error(),
                 "Body stream is closed",
             ));
         }