itsi-scheduler 0.1.5 → 0.1.14

data/ext/itsi_server/Cargo.toml

@@ -10,37 +10,80 @@ 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 = [
+  "tokio",
+  "zstd",
+  "brotli",
+  "deflate",
+  "gzip",
+] }
+async-channel = "2.3.1"
+async-trait = "0.1.87"
 base64 = "0.22.1"
+bytes = "1.3"
+chrono = "0.4.35"
+crossbeam = "0.8.4"
+dashmap = "6.1.0"
+derive_more = { version = "2.0.1", features = ["debug"] }
+dirs = "6.0.0"
+either = "1.15.0"
+fnv = "1.0.7"
+fs2 = "0.4.3"
+futures = "0.3.31"
+globset = "0.4.16"
+hmac = "0.12.1"
+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-staticfile = "0.10.1"
 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" }
+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"
+rand = "0.9.0"
 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"
+rcgen = { version = "0.13.2", features = ["x509-parser", "pem"] }
+regex = "1.11.1"
+reqwest = { version = "0.12.15", features = ["stream"] }
+ring = "0.17.14"
+route-recognizer = "0.3.1"
+redis = { version = "0.29.2", features = [
+  "tokio-comp",
+  "r2d2",
+  "tokio-rustls-comp",
+  "connection-manager",
+] }
+rustls = "0.23.23"
+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-rustls-acme = "0.6.0"
-rustls = "0.23.23"
-fs2 = "0.4.3"
-ring = "0.17.14"
-async-trait = "0.1.87"
+tokio-stream = "0.1.17"
+tokio-util = "0.7.13"
+tracing = "0.1.41"
+url = "2.5.4"
+uuid = "1.16.0"
+md5 = "0.7.0"

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,58 +1,17 @@
-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 magnus::{error::Result, function, method, Module, Object, Ruby};
+use ruby_types::{
+    itsi_body_proxy::ItsiBodyProxy, itsi_grpc_request::ItsiGrpcRequest,
+    itsi_grpc_stream::ItsiGrpcStream, itsi_http_request::ItsiHttpRequest,
+    itsi_http_response::ItsiHttpResponse, itsi_server::ItsiServer, ITSI_BODY_PROXY,
+    ITSI_GRPC_REQUEST, ITSI_GRPC_RESPONSE, ITSI_GRPC_STREAM, ITSI_MODULE, ITSI_REQUEST,
+    ITSI_RESPONSE, ITSI_SERVER,
+};
+use server::signal::reset_signal_handlers;
 use tracing::*;
-
-pub mod body_proxy;
-pub mod request;
-pub mod response;
+pub mod env;
+pub mod ruby_types;
 pub mod server;
 
-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);
-}
-
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<()> {
     itsi_tracing::init();
@@ -67,24 +26,29 @@ fn init(ruby: &Ruby) -> Result<()> {
     itsi.define_singleton_method("log_error", function!(log_error, 1))?;
 
     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("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("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", 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))?;
 
     let body_proxy = ruby.get_inner(&ITSI_BODY_PROXY);
     body_proxy.define_method("gets", method!(ItsiBodyProxy::gets, 0))?;
@@ -93,14 +57,56 @@ 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("json?", method!(ItsiHttpResponse::is_json, 0))?;
+    response.define_method("html?", method!(ItsiHttpResponse::is_html, 0))?;
+
+    let grpc_request = ruby.get_inner(&ITSI_GRPC_REQUEST);
+
+    grpc_request.define_method("service_name", method!(ItsiGrpcRequest::service_name, 0))?;
+    grpc_request.define_method("method_name", method!(ItsiGrpcRequest::method_name, 0))?;
+    grpc_request.define_method("stream", method!(ItsiGrpcRequest::stream, 0))?;
+    grpc_request.define_method("json?", method!(ItsiGrpcRequest::is_json, 0))?;
+    grpc_request.define_method(
+        "content_type",
+        method!(ItsiGrpcRequest::content_type_str, 0),
+    )?;
+
+    let grpc_stream = ruby.get_inner(&ITSI_GRPC_STREAM);
+    grpc_stream.define_method("read", method!(ItsiGrpcStream::read, 1))?;
+    grpc_stream.define_method("write", method!(ItsiGrpcStream::write, 1))?;
+    grpc_stream.define_method("flush", method!(ItsiGrpcStream::flush, 0))?;
+    grpc_stream.define_method("send_trailers", method!(ItsiGrpcStream::send_trailers, 1))?;
+
+    let _grpc_response = ruby.get_inner(&ITSI_GRPC_RESPONSE);
 
     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/{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};
@@ -25,10 +26,10 @@ 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()),
         }
     }
 }
@@ -98,6 +99,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::exception(),
+                    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()?;

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

@@ -0,0 +1,147 @@
+use derive_more::Debug;
+use http::{request::Parts, Response, StatusCode};
+use http_body_util::{combinators::BoxBody, BodyExt, Empty};
+use itsi_error::from::CLIENT_CONNECTION_CLOSED;
+use itsi_rb_helpers::{print_rb_backtrace, HeapValue};
+use itsi_tracing::debug;
+use magnus::{
+    block::Proc,
+    error::{ErrorType, Result as MagnusResult},
+    Error,
+};
+use magnus::{
+    value::{LazyId, ReprValue},
+    Ruby, Value,
+};
+use std::{sync::Arc, time::Instant};
+use tokio::sync::mpsc::{self};
+use tracing::error;
+
+use super::itsi_grpc_stream::ItsiGrpcStream;
+use crate::server::{
+    byte_frame::ByteFrame,
+    itsi_service::RequestContext,
+    request_job::RequestJob,
+    types::{HttpRequest, HttpResponse},
+};
+
+static ID_MESSAGE: LazyId = LazyId::new("message");
+
+#[derive(Debug)]
+#[magnus::wrap(class = "Itsi::GrpcRequest", free_immediately, size)]
+pub struct ItsiGrpcRequest {
+    pub parts: Parts,
+    pub start: Instant,
+    #[debug(skip)]
+    pub context: RequestContext,
+    #[debug(skip)]
+    pub stream: ItsiGrpcStream,
+}
+
+impl ItsiGrpcRequest {
+    pub fn service_name(&self) -> MagnusResult<String> {
+        let path = self.parts.uri.path();
+        Ok(path.split('/').nth_back(1).unwrap().to_string())
+    }
+
+    pub fn method_name(&self) -> MagnusResult<String> {
+        let path = self.parts.uri.path();
+        Ok(path.split('/').nth_back(0).unwrap().to_string())
+    }
+
+    pub fn stream(&self) -> MagnusResult<ItsiGrpcStream> {
+        Ok(self.stream.clone())
+    }
+
+    pub fn content_type_str(&self) -> &str {
+        self.parts
+            .headers
+            .get("Content-Type")
+            .and_then(|hv| hv.to_str().ok())
+            .unwrap_or("application/x-www-form-urlencoded")
+    }
+
+    pub fn is_json(&self) -> bool {
+        self.content_type_str() == "application/json"
+    }
+
+    pub fn process(self, ruby: &Ruby, app_proc: Arc<HeapValue<Proc>>) -> magnus::error::Result<()> {
+        let response = self.stream.clone();
+        let result = app_proc.call::<_, Value>((self,));
+        if let Err(err) = result {
+            Self::internal_error(ruby, response, err);
+        }
+        Ok(())
+    }
+
+    pub fn internal_error(_ruby: &Ruby, stream: ItsiGrpcStream, err: Error) {
+        if let Some(rb_err) = err.value() {
+            print_rb_backtrace(rb_err);
+            stream.internal_server_error(err.to_string());
+        } else {
+            stream.internal_server_error(err.to_string());
+        }
+    }
+
+    pub(crate) async fn process_request(
+        app: Arc<HeapValue<Proc>>,
+        hyper_request: HttpRequest,
+        context: &RequestContext,
+    ) -> itsi_error::Result<HttpResponse> {
+        let (request, mut receiver) = ItsiGrpcRequest::new(hyper_request, context).await;
+        let shutdown_channel = context.service.shutdown_channel.clone();
+        let response_stream = request.stream.clone();
+        match context
+            .sender
+            .send(RequestJob::ProcessGrpcRequest(request, app))
+            .await
+        {
+            Err(err) => {
+                error!("Error occurred: {}", err);
+                let mut response = Response::new(BoxBody::new(Empty::new()));
+                *response.status_mut() = StatusCode::BAD_REQUEST;
+                Ok(response)
+            }
+            _ => match receiver.recv().await {
+                Some(first_frame) => Ok(response_stream
+                    .build_response(first_frame, receiver, shutdown_channel)
+                    .await),
+                None => Ok(Response::new(BoxBody::new(Empty::new()))),
+            },
+        }
+    }
+    pub fn is_connection_closed_err(ruby: &Ruby, err: &Error) -> bool {
+        match err.error_type() {
+            ErrorType::Jump(_) => false,
+            ErrorType::Error(_, _) => false,
+            ErrorType::Exception(exception) => {
+                exception.is_kind_of(ruby.exception_eof_error())
+                    && err
+                        .value()
+                        .map(|v| {
+                            v.funcall::<_, _, String>(*ID_MESSAGE, ())
+                                .unwrap_or("".to_string())
+                                .eq(CLIENT_CONNECTION_CLOSED)
+                        })
+                        .unwrap_or(false)
+            }
+        }
+    }
+
+    pub(crate) async fn new(
+        request: HttpRequest,
+        context: &RequestContext,
+    ) -> (ItsiGrpcRequest, mpsc::Receiver<ByteFrame>) {
+        let (parts, body) = request.into_parts();
+        let response_channel = mpsc::channel::<ByteFrame>(100);
+        (
+            Self {
+                context: context.clone(),
+                start: Instant::now(),
+                parts,
+                stream: ItsiGrpcStream::new(response_channel.0, body.into_data_stream()),
+            },
+            response_channel.1,
+        )
+    }
+}

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

@@ -0,0 +1,19 @@
+use derive_more::Debug;
+use http::request::Parts;
+use tokio::sync::mpsc::Sender;
+
+use crate::server::byte_frame::ByteFrame;
+
+#[derive(Debug, Clone)]
+#[magnus::wrap(class = "Itsi::GrpcResponse", free_immediately, size)]
+pub struct ItsiGrpcResponse {
+    pub parts: Parts,
+    #[debug(skip)]
+    pub sender: Sender<ByteFrame>,
+}
+
+impl ItsiGrpcResponse {
+    pub fn new(parts: Parts, sender: Sender<ByteFrame>) -> Self {
+        Self { parts, sender }
+    }
+}