osprey 0.1.0

data/ext/osprey/src/lib.rs

@@ -0,0 +1,1659 @@
+#![deny(unused_crate_dependencies)]
+
+use bytes::Bytes;
+use crossbeam::channel::{Receiver, Sender};
+use http_body_util::combinators::BoxBody;
+use http_body_util::{BodyExt, Empty};
+use hyper::body::{Body, Incoming};
+use hyper::header::{HeaderName, HeaderValue};
+use hyper::service::service_fn;
+use hyper::upgrade::Upgraded;
+use hyper::{HeaderMap, Request, Response, StatusCode};
+use hyper_util::rt::{TokioExecutor, TokioIo};
+use hyper_util::server::conn::auto::Builder;
+use libc::{sighandler_t, sleep};
+use log::{debug, error, info, warn};
+use magnus::value::{Id, Lazy, LazyId, ReprValue};
+use magnus::{
+    block::Proc,
+    exception, function,
+    scan_args::{get_kwargs, scan_args, Args, KwArgs},
+    Error, Object, RHash, Value,
+};
+use magnus::{eval, Class, Module, RModule, Ruby};
+use magnus::{RArray, RClass};
+use nix::cmsg_space;
+use nix::sys::socket::{
+    recvmsg, sendmsg, socketpair, AddressFamily, ControlMessage, ControlMessageOwned, MsgFlags,
+    SockFlag, SockType,
+};
+use std::cell::RefCell;
+use std::convert::Infallible;
+use std::os::unix::io::RawFd;
+use std::os::unix::net::UnixStream;
+use std::ptr::null_mut;
+use structs::rack_request::{define_request_info, RackRequest, RackRequestInner};
+use tokio::io::unix::AsyncFd;
+use tokio::io::{AsyncRead, AsyncWrite};
+use tokio::sync::broadcast::channel;
+use tokio_stream::StreamExt;
+
+use rb_sys::{rb_thread_call_with_gvl, rb_thread_call_without_gvl, rb_thread_create};
+use simple_logger::SimpleLogger;
+use socket2::{Domain, Protocol, Socket, Type};
+use std::io::{IoSlice, IoSliceMut};
+use std::net::{TcpListener, TcpStream};
+use std::os::fd::{FromRawFd, IntoRawFd, OwnedFd};
+use std::panic;
+use std::pin::Pin;
+use std::sync::atomic::Ordering;
+use std::sync::atomic::{AtomicBool, AtomicUsize};
+use std::sync::{Mutex, RwLock};
+use std::{
+    collections::HashMap, ffi::c_void, fs::OpenOptions, net::SocketAddr, os::fd::AsRawFd,
+    sync::Arc, time::Duration,
+};
+use structs::rack_response::{define_collector, RackResponse};
+use tokio::net::{TcpListener as TokioTcpListener, TcpStream as TokioTcpStream};
+use tokio::runtime::Builder as RuntimeBuilder;
+use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};
+use tokio::sync::oneshot::{self};
+use tokio::task::{JoinError, JoinHandle};
+use tokio::time::sleep as TokioSleep;
+use tokio_rustls::rustls::ServerConfig;
+use tokio_rustls::TlsAcceptor;
+
+mod structs;
+
+trait IoStream: tokio::io::AsyncRead + tokio::io::AsyncWrite + Send + Unpin {}
+impl<T: tokio::io::AsyncRead + tokio::io::AsyncWrite + Send + Unpin> IoStream for T {}
+
+/// --------------------------------------------------
+/// Global/Static shared data for forking & shutdown
+/// --------------------------------------------------
+
+static CHILDREN: RwLock<Vec<ChildProcess>> = RwLock::new(vec![]);
+
+static SHUTDOWN_REQUESTED: AtomicBool = AtomicBool::new(false);
+static CTRL_C_SIGNAL_CHANNEL: RwLock<Option<tokio::sync::broadcast::Sender<()>>> =
+    RwLock::new(None);
+
+pub static OSPREY: Lazy<RModule> = Lazy::new(|ruby| ruby.define_module("Osprey").unwrap());
+pub static ID_SCHEDULE: LazyId = LazyId::new("schedule");
+pub static ID_CALL: LazyId = LazyId::new("call");
+pub static ID_NEW: LazyId = LazyId::new("new");
+pub static ID_PUSH: LazyId = LazyId::new("push");
+pub static ID_RESUME: LazyId = LazyId::new("resume");
+pub static ID_TRANSFORM_VALUES: LazyId = LazyId::new("transform_values");
+pub static ARRAY_PROC: Lazy<Proc> = Lazy::new(|ruby| {
+    ruby.module_kernel()
+        .funcall::<&str, (&str,), Value>("method", ("Array",))
+        .unwrap()
+        .funcall("to_proc", ())
+        .unwrap()
+});
+pub static WORK_QUEUE: Lazy<Value> = Lazy::new(|ruby| {
+    let queue = ruby
+        .define_class("Queue", ruby.class_object())
+        .unwrap()
+        .funcall::<&str, (), Value>("new", ())
+        .unwrap();
+    ruby.get_inner(&OSPREY)
+        .ivar_set("@work_queue", queue)
+        .unwrap();
+    queue
+});
+
+static SCHEDULER_CLASS: Lazy<RClass> = Lazy::new(|ruby| {
+    ruby.define_module("Async")
+        .unwrap()
+        .const_get("Scheduler")
+        .unwrap()
+});
+
+static FIBER_CLASS: Lazy<RClass> =
+    Lazy::new(|ruby| ruby.define_class("Fiber", ruby.class_object()).unwrap());
+/// A simple struct to hold the server config + the Ruby app `Proc`
+#[derive(Clone)]
+struct RackServerConfig {
+    host: String,
+    port: u16,
+    http_port: Option<u16>,
+    workers: u16,
+    threads: u16,
+    cert_path: Option<String>,
+    key_path: Option<String>,
+    shutdown_timeout: Duration,
+    script_name: String,
+    before_fork: Option<Proc>,
+    after_fork: Option<Proc>,
+}
+
+#[derive(Debug, Clone)]
+struct ChildProcess {
+    pid: i32,
+    writer: Arc<OwnedFd>,
+}
+
+struct AcceptLoopArgs {
+    http_listener: Option<TcpListener>,
+    https_listener: Option<TcpListener>,
+    shutdown_timeout: Duration,
+    threads: u16,
+    reader: Option<OwnedFd>,
+    script_name: String,
+    cert_path: Option<String>,
+    key_path: Option<String>,
+}
+
+unsafe extern "C" fn accept_loop_interrupt(_ptr: *mut c_void) {
+    info!("(PID={}) Interrupt accept loop", libc::getpid());
+}
+
+unsafe fn setup_listeners(
+    server: &RackServerConfig,
+) -> Result<(Option<TcpListener>, Option<TcpListener>), Error> {
+    let mut http_listener = None;
+    let mut https_listener = None;
+
+    // Set up HTTP listener if http_port is provided
+    if let Some(http_port) = server.http_port {
+        let socket = Socket::new(Domain::IPV6, Type::STREAM, Some(Protocol::TCP)).map_err(|e| {
+            Error::new(
+                exception::io_error(),
+                format!("Socket creation failed: {}", e),
+            )
+        })?;
+        socket.set_reuse_address(true).ok();
+        socket.set_reuse_port(true).ok();
+        socket.set_nonblocking(true).ok();
+        socket.set_nodelay(true).ok();
+        socket.set_recv_buffer_size(1048576).ok();
+
+        let address: SocketAddr =
+            format!("{}:{}", server.host, http_port)
+                .parse()
+                .map_err(|e| {
+                    Error::new(
+                        exception::io_error(),
+                        format!(
+                            "Failed to parse address {}: {}",
+                            format!("{}:{}", server.host, http_port),
+                            e
+                        ),
+                    )
+                })?;
+        socket.bind(&address.into()).map_err(|e| {
+            Error::new(
+                exception::io_error(),
+                format!("bind failed for HTTP: {}", e),
+            )
+        })?;
+        socket.listen(1024).map_err(|e| {
+            Error::new(
+                exception::io_error(),
+                format!("listen failed for HTTP: {}", e),
+            )
+        })?;
+        let listener: TcpListener = socket.into();
+        listener.set_nonblocking(true).map_err(|e| {
+            Error::new(
+                exception::io_error(),
+                format!("set_nonblocking failed for HTTP: {}", e),
+            )
+        })?;
+        info!("(PID={}) Listening on http://{}", libc::getpid(), address);
+        http_listener = Some(listener);
+    }
+
+    // Set up HTTPS listener if cert_path and key_path are provided
+    if server.cert_path.is_some() && server.key_path.is_some() {
+        let socket = Socket::new(Domain::IPV6, Type::STREAM, Some(Protocol::TCP)).map_err(|e| {
+            Error::new(
+                exception::io_error(),
+                format!("Socket creation failed: {}", e),
+            )
+        })?;
+        socket.set_reuse_address(true).ok();
+        socket.set_reuse_port(true).ok();
+        socket.set_nonblocking(true).ok();
+        socket.set_nodelay(true).ok();
+        socket.set_recv_buffer_size(1048576).ok();
+
+        let address: SocketAddr =
+            format!("{}:{}", server.host, server.port)
+                .parse()
+                .map_err(|e| {
+                    Error::new(
+                        exception::io_error(),
+                        format!(
+                            "Failed to parse address {}: {}",
+                            format!("{}:{}", server.host, server.port),
+                            e
+                        ),
+                    )
+                })?;
+        socket.bind(&address.into()).map_err(|e| {
+            Error::new(
+                exception::io_error(),
+                format!("bind failed for HTTPS: {}", e),
+            )
+        })?;
+        socket.listen(1024).map_err(|e| {
+            Error::new(
+                exception::io_error(),
+                format!("listen failed for HTTPS: {}", e),
+            )
+        })?;
+        let listener: TcpListener = socket.into();
+        listener.set_nonblocking(true).map_err(|e| {
+            Error::new(
+                exception::io_error(),
+                format!("set_nonblocking failed for HTTP: {}", e),
+            )
+        })?;
+        info!("(PID={}) Listening on https://{}", libc::getpid(), address);
+        https_listener = Some(listener);
+    }
+
+    Ok((http_listener, https_listener))
+}
+
+async fn await_fd(fd: RawFd) -> Result<(), JoinError> {
+    let async_fd_result = AsyncFd::new(fd);
+
+    if let Ok(async_fd) = async_fd_result {
+        return tokio::spawn(async move {
+            loop {
+                match async_fd.readable().await {
+                    Ok(guard) => {
+                        if guard.ready().is_read_closed() {
+                            break;
+                        } else {
+                            let _ = TokioSleep(Duration::from_millis(1000)).await;
+                        }
+                    }
+                    Err(e) => {
+                        println!("Error waiting for readiness: {:?}", e);
+                        break;
+                    }
+                }
+            }
+        })
+        .await;
+    }
+    Ok(())
+}
+
+async unsafe fn accept_loop_async(serve_args: &mut AcceptLoopArgs) -> Result<(), Error> {
+    let tls_listener = serve_args.https_listener.as_ref().map(|listener| {
+        TokioTcpListener::from_std(listener.try_clone().expect("Clone STD Listener"))
+            .expect("Construct Tokio Listener from STD")
+    });
+    let non_tls_listener = serve_args.http_listener.as_ref().map(|listener| {
+        TokioTcpListener::from_std(listener.try_clone().expect("Clone STD Listener"))
+            .expect("Construct Tokio Listener from STD")
+    });
+
+    let (signal_tx, mut signal_rx) = channel(1);
+    let (shutdown_tx, mut shutdown_rx) = channel(1);
+    *CTRL_C_SIGNAL_CHANNEL.write().unwrap() = Some(signal_tx);
+    let children = CHILDREN.read().unwrap().to_vec();
+    let mut child_cycle = children.iter().cycle();
+
+    tokio::spawn(async move {
+        signal_rx.recv().await.ok();
+        info!(
+            "(PID={}) Signal received. Initiating shutdown",
+            libc::getpid()
+        );
+        shutdown_tx.send(()).ok();
+    });
+
+    loop {
+        tokio::select! {
+            conn = async { if let Some(listener) = tls_listener.as_ref() { Some(listener.accept().await) } else { None } }, if tls_listener.is_some() => {
+                if let Some(Ok((stream, _peer_addr))) = conn {
+                  let fd = stream.into_std().expect("Failed to convert to std FD").into_raw_fd();
+
+                  let iov = [IoSlice::new(b"1")];
+                  let next_child = child_cycle.next().expect("Next child process");
+                  sendmsg::<()>(
+                      next_child.writer.as_raw_fd() as i32,
+                      &iov,
+                      &[ControlMessage::ScmRights(&[fd])],  // Send the file descriptor
+                      MsgFlags::empty(),
+                      None,  // No address
+                  ).expect("Failed to send file descriptor");
+
+                  if SHUTDOWN_REQUESTED.load(Ordering::Relaxed) {
+                      break;
+                  }
+                }
+            },
+            conn = async { if let Some(listener) = non_tls_listener.as_ref() { Some(listener.accept().await) } else { None } }, if non_tls_listener.is_some() => {
+                if let Some(Ok((stream, _peer_addr))) = conn {
+                  let fd = stream.into_std().expect("Failed to convert to std FD").into_raw_fd();
+                  let iov = [IoSlice::new(b"0")];
+                  let next_child = child_cycle.next().expect("Next child process");
+                  sendmsg::<()>(
+                      next_child.writer.as_raw_fd() as i32,
+                      &iov,
+                      &[ControlMessage::ScmRights(&[fd])],  // Send the file descriptor
+                      MsgFlags::empty(),
+                      None,  // No address
+                  ).expect("Failed to send file descriptor");
+                  if SHUTDOWN_REQUESTED.load(Ordering::Relaxed) {
+                      break;
+                  }
+                }
+            }
+            _ = shutdown_rx.recv() => {
+                info!("(PID={}) Shutdown signal received. Breaking out of accept loop", libc::getpid());
+                break;
+            }
+        }
+    }
+
+    info!(
+        "(PID={}) Waiting up to {:?} for in-flight requests to complete",
+        libc::getpid(),
+        serve_args.shutdown_timeout
+    );
+
+    debug!("(PID={}) Dropping listeners", libc::getpid());
+    drop(tls_listener);
+    drop(non_tls_listener);
+    initiate_shutdown(0, 0);
+
+    Ok(())
+}
+
+use std::io;
+use tokio::{io::AsyncWriteExt, net::UnixStream as TokioUnixStream};
+
+async fn bridge_with_logging(
+    mut from: (impl AsyncRead + Unpin),
+    mut to: (impl AsyncWrite + Unpin),
+    direction_label: &str,
+) -> io::Result<u64> {
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+    let mut buf = [0u8; 4096];
+    let mut total_bytes = 0u64;
+
+    loop {
+        let n = from.read(&mut buf).await?;
+        if n == 0 {
+            // EOF => no more data
+            break;
+        }
+        println!(
+            "[bridge {}] Read {} bytes: {:?}",
+            direction_label,
+            n,
+            &buf[..n]
+        );
+
+        to.write_all(&buf[..n]).await?;
+        total_bytes += n as u64;
+    }
+    Ok(total_bytes)
+}
+
+async fn two_way_bridge(upgraded: Upgraded, local: TokioUnixStream) -> io::Result<()> {
+    // Wrap the `Upgraded` with `TokioIo` so it implements AsyncRead+AsyncWrite
+    let client_io = TokioIo::new(upgraded);
+
+    // Split each side
+    let (mut lr, mut lw) = tokio::io::split(local);
+    let (mut cr, mut cw) = tokio::io::split(client_io);
+
+    let to_ruby = tokio::spawn(async move {
+        if let Err(e) = tokio::io::copy(&mut cr, &mut lw).await {
+            eprintln!("Error copying upgraded->local: {:?}", e);
+        }
+    });
+    let from_ruby = tokio::spawn(async move {
+        if let Err(e) = tokio::io::copy(&mut lr, &mut cw).await {
+            eprintln!("Error copying upgraded->local: {:?}", e);
+        }
+    });
+
+    let _ = to_ruby.await;
+    let _ = from_ruby.await;
+    Ok(())
+}
+
+async unsafe fn handle_hyper_request(
+    req: Request<Incoming>,
+    peer_addr: SocketAddr,
+    sender: Sender<RackRequest>,
+    script_name: String,
+) -> Result<Response<BoxBody<Bytes, Infallible>>, &'static str> {
+    let (parts, body) = req.into_parts();
+
+    let has_body = !body.is_end_stream();
+
+    // 1. (Optional) If there's a body, we'll expose it as an IO into our Ruby process.
+    let (local_fd, remote_fd) = if has_body {
+        let (local, remote) = TokioUnixStream::pair().map_err(|_| "socketpair failed")?;
+        let local_fd = local.as_raw_fd();
+        let (_lr, mut lw) = tokio::io::split(local);
+        let mut data_stream = body.into_data_stream();
+
+        // Stream all incoming data into our remote FD (Opened inside Ruby as an IO)
+        tokio::spawn(async move {
+            while let Some(Ok(chunk)) = data_stream.next().await {
+                info!("Got write chunk ! {:?}", chunk);
+                if lw.write_all(&chunk).await.is_err() {
+                    break;
+                }
+            }
+            info!("Relinquishing ownership of local_fd");
+            _lr.unsplit(lw).into_std().unwrap().into_raw_fd()
+        });
+
+        let remote_fd = remote.into_std().unwrap().into_raw_fd();
+        (Some(local_fd), remote_fd)
+    } else {
+        (None, -1)
+    };
+
+    // 2) Build and send a RackRequest to our Rack app.
+    let (rack_req, resp_rx) =
+        map_hyper_request(parts.clone(), peer_addr, script_name, remote_fd).await;
+    sender.send(rack_req).expect("Failed to send to Ruby");
+
+    // 3) Then wait for our Rack app to return a RackResponse
+    let rack_response = resp_rx.await.map_err(|_| "Ruby channel closed")?;
+
+    // 4) We return a negative status if the response was hijacked. We'll reuse the body pipe
+    // if it already exists, otherwise, we can count on the hijacked response to have created a new one.
+    if rack_response.status < 0 {
+        let local_fd = match local_fd {
+            Some(ld) => ld,
+            None => (rack_response.status * -1) as i32,
+        };
+
+        return match handle_hijacked_response(local_fd, parts).await {
+            Ok(resp) => Ok(resp),
+            Err(_) => Err("Error handling hijacked response"),
+        };
+    }
+
+    // 5) Otherwise, normal HTTP response
+    Ok(rack_response.into_hyper_response())
+}
+
+async fn handle_connection(
+    input_stream: Pin<Box<tokio::net::TcpStream>>,
+    tls_acceptor: Option<TlsAcceptor>,
+    server: Arc<Builder<TokioExecutor>>,
+    peer_addr: SocketAddr,
+    sender: Sender<RackRequest>,
+    script_name: String,
+) {
+    unsafe {
+        debug!("(PID={}) Handling connection", libc::getpid());
+    }
+    let stream: TokioIo<_> = match &tls_acceptor {
+        Some(acceptor) => match acceptor.accept(input_stream).await {
+            Ok(tls_stream) => TokioIo::new(Box::pin(tls_stream) as Pin<Box<dyn IoStream>>),
+            Err(err) => {
+                warn!("TLS handshake error: {}", err);
+                return;
+            }
+        },
+        None => TokioIo::new(Box::pin(input_stream) as Pin<Box<dyn IoStream>>),
+    };
+
+    unsafe {
+        debug!("(PID={}) serve connection with upgrades", libc::getpid());
+    }
+
+    if let Err(err) = server
+        .serve_connection_with_upgrades(
+            stream,
+            service_fn(move |hyper_request| unsafe {
+                handle_hyper_request(
+                    hyper_request,
+                    peer_addr,
+                    sender.clone(),
+                    script_name.clone(),
+                )
+            }),
+        )
+        .await
+    {
+        debug!("Connection aborted: {:?}", err);
+    }
+
+    unsafe { debug!("(PID={}) Connection closed", libc::getpid()) };
+}
+
+async unsafe fn accept_ruby_connection_async(
+    serve_args: &mut AcceptLoopArgs,
+    sender: Sender<RackRequest>,
+) {
+    let reader = serve_args.reader.as_mut().unwrap();
+
+    drop(serve_args.http_listener.take());
+    drop(serve_args.https_listener.take());
+
+    let buf_raw = &mut [0u8; 1024];
+    let mut buf = [IoSliceMut::new(buf_raw)];
+    let server = Arc::new(Builder::new(TokioExecutor::new()));
+    let mut cmsg_space = cmsg_space!(Vec<RawFd>);
+
+    let (signal_tx, mut signal_rx) = channel(1);
+    let (shutdown_tx, mut shutdown_rx) = channel(1);
+    *CTRL_C_SIGNAL_CHANNEL.write().unwrap() = Some(signal_tx);
+
+    let mut current_requests: (
+        UnboundedSender<JoinHandle<()>>,
+        UnboundedReceiver<JoinHandle<()>>,
+    ) = tokio::sync::mpsc::unbounded_channel();
+
+    let in_flight_requests_handle = tokio::spawn(async move {
+        loop {
+            tokio::select! {
+                _ = signal_rx.recv() => {
+                    info!("(PID={}) Signal received. Initiating shutdown", libc::getpid());
+                    shutdown_tx.send(()).ok();
+                    break
+                }
+                result = current_requests.1.recv() => {
+                      match result {
+                          Some(handle) => {
+                              if let Err(e) = handle.await {
+                                  error!("Error handling request: {:?}", e);
+                              }
+                          },
+                          _ => {
+                              continue;
+                          }
+                      }
+                  }
+            }
+        }
+        info!("(PID={}) Flushing final requests", libc::getpid());
+
+        info!(
+            "(PID={}) Awaiting in-flight request for clean shut down",
+            libc::getpid()
+        );
+        while let Ok(handle) = current_requests.1.try_recv() {
+            if let Err(e) = handle.await {
+                error!("Error handling request: {:?}", e);
+            }
+        }
+    });
+    let child_socket = Arc::new(AsyncFd::new(reader.as_raw_fd()).unwrap());
+    let tls_config = configure_tls(serve_args.cert_path.clone(), serve_args.key_path.clone());
+    let tls_acceptor = tls_config.map(TlsAcceptor::from);
+
+    info!("(PID={}) Starting main loop", libc::getpid());
+
+    loop {
+        tokio::select! {
+            guard = child_socket.readable() => {
+                match guard {
+                    Ok(mut ready_guard) => {
+                        while let Ok(msg) = recvmsg::<()>(
+                            reader.as_raw_fd(),
+                            &mut buf,
+                            Some(&mut cmsg_space),
+                            MsgFlags::MSG_DONTWAIT,
+                        ) {
+                            if msg.bytes == 0 {
+                                info!("(PID={}) Received EOF. Exiting", libc::getpid());
+                                return;
+                            }
+
+                            if let Some(ControlMessageOwned::ScmRights(fds)) = msg.cmsgs().unwrap().next() {
+                                let fd: i32 = *fds.first().expect("File descriptor");
+                                let tls: bool = buf[0][0] == '1' as u8;
+
+                                let stream = TokioTcpStream::from_std(unsafe { TcpStream::from_raw_fd(fd) })
+                                    .expect("Tokio from std");
+
+
+                                match stream.peer_addr(){
+                                  Ok(peer_addr) => {
+                                    let server_clone = server.clone();
+
+                                    let script_name_clone = serve_args.script_name.clone();
+                                    let tls_acceptor = if tls { tls_acceptor.clone() } else { None };
+                                    let sender_clone = sender.clone();
+                                    let handle = tokio::spawn(async move {
+                                        handle_connection(
+                                            Box::pin(stream),
+                                            tls_acceptor,
+                                            server_clone,
+                                            peer_addr,
+                                            sender_clone,
+                                            script_name_clone
+                                        )
+                                        .await;
+                                    });
+
+                                    info!("(PID={}) Spawned connection handler", libc::getpid());
+                                    if let Err(e) = current_requests.0.send(handle) {
+                                        error!("Failed to enqueue request: {:?}", e);
+                                    }
+                                  }
+                                  Err(e) => {
+                                    error!("Failed to get peer address: {:?}", e);
+                                    continue;
+                                  }
+                              }
+
+                            } else {
+                                error!("No file descriptor received");
+                            }
+                        }
+
+                        // Clear readiness state after processing
+                        ready_guard.clear_ready();
+                    }
+                    Err(e) => {
+                        error!("(PID={}) Failed to poll readability: {:?}", libc::getpid(), e);
+                    }
+                }
+            }
+            _ = shutdown_rx.recv() => {
+                info!("(PID={}) Shutdown signal received. Breaking out of accept loop", libc::getpid());
+                break;
+            }
+        }
+    }
+
+    tokio::select! {
+        _ = in_flight_requests_handle => {
+            debug!("(PID={}) In-flight requests handled gracefully", libc::getpid());
+        }
+        _ = tokio::time::sleep(serve_args.shutdown_timeout) => {
+            debug!("(PID={}) Forced shutdown timeout reached", libc::getpid());
+        }
+    }
+
+    debug!("(PID={}) Dropping listeners", libc::getpid());
+    initiate_shutdown(0, 0);
+}
+
+pub unsafe fn call_without_gvl<F, R>(f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    // This is the function that Ruby calls “in the background” with the GVL released.
+    extern "C" fn trampoline<F, R>(arg: *mut c_void) -> *mut c_void
+    where
+        F: FnOnce() -> R,
+    {
+        // 1) Reconstruct the Box that holds our closure
+        let closure_ptr = arg as *mut Option<F>;
+        let closure = unsafe { (*closure_ptr).take().expect("Closure already taken") };
+
+        // 2) Call the user’s closure
+        let result = closure();
+
+        // 3) Box up the result so we can return a pointer to it
+        let boxed_result = Box::new(result);
+        Box::into_raw(boxed_result) as *mut c_void
+    }
+
+    // Box up the closure so we have a stable pointer
+    let mut closure_opt = Some(f);
+    let closure_ptr = &mut closure_opt as *mut Option<F> as *mut c_void;
+
+    // 4) Actually call `rb_thread_call_without_gvl`
+    let raw_result_ptr =
+        rb_thread_call_without_gvl(Some(trampoline::<F, R>), closure_ptr, None, null_mut());
+
+    // 5) Convert the returned pointer back into R
+    let result_box = Box::from_raw(raw_result_ptr as *mut R);
+    *result_box
+}
+
+pub unsafe fn call_with_gvl<F, R>(f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    // This is the function that Ruby calls “in the background” with the GVL released.
+    extern "C" fn trampoline<F, R>(arg: *mut c_void) -> *mut c_void
+    where
+        F: FnOnce() -> R,
+    {
+        // 1) Reconstruct the Box that holds our closure
+        let closure_ptr = arg as *mut Option<F>;
+        let closure = unsafe { (*closure_ptr).take().expect("Closure already taken") };
+
+        // 2) Call the user’s closure
+        let result = closure();
+
+        // 3) Box up the result so we can return a pointer to it
+        let boxed_result = Box::new(result);
+        Box::into_raw(boxed_result) as *mut c_void
+    }
+
+    // Box up the closure so we have a stable pointer
+    let mut closure_opt = Some(f);
+    let closure_ptr = &mut closure_opt as *mut Option<F> as *mut c_void;
+
+    // 4) Actually call `rb_thread_call_without_gvl`
+    let raw_result_ptr = rb_thread_call_with_gvl(Some(trampoline::<F, R>), closure_ptr);
+
+    // 5) Convert the returned pointer back into R
+    let result_box = Box::from_raw(raw_result_ptr as *mut R);
+    *result_box
+}
+
+unsafe extern "C" fn accept_ruby_connection_loop(ptr: *mut c_void) -> *mut c_void {
+    let serve_args = &mut *(ptr as *mut AcceptLoopArgs);
+    let mut builder: RuntimeBuilder = RuntimeBuilder::new_current_thread();
+
+    libc::signal(libc::SIGTERM, initiate_shutdown as usize);
+    libc::signal(libc::SIGINT, initiate_shutdown as usize);
+
+    let runtime = builder
+        .thread_name("osprey-accept-runtime")
+        .thread_stack_size(3 * 1024 * 1024)
+        .enable_io()
+        .enable_time()
+        .build()
+        .expect("Failed to build Tokio runtime");
+
+    let (sender, receiver) = crossbeam::channel::unbounded::<RackRequest>();
+    start_ruby_thread_pool(serve_args.threads as usize, Arc::new(receiver));
+
+    let _ = runtime.block_on(accept_ruby_connection_async(serve_args, sender));
+
+    std::ptr::null_mut()
+}
+
+unsafe extern "C" fn accept_loop(ptr: *mut c_void) -> *mut c_void {
+    let serve_args = &mut *(ptr as *mut AcceptLoopArgs);
+    let mut builder: RuntimeBuilder = if serve_args.threads == 1 {
+        RuntimeBuilder::new_current_thread()
+    } else {
+        RuntimeBuilder::new_multi_thread()
+    };
+    let runtime = builder
+        .worker_threads(serve_args.threads as usize)
+        .thread_name("osprey-accept-runtime")
+        .thread_stack_size(3 * 1024 * 1024)
+        .enable_io()
+        .enable_time()
+        .build()
+        .expect("Failed to build Tokio runtime");
+
+    libc::signal(libc::SIGTERM, initiate_shutdown as usize);
+    libc::signal(libc::SIGINT, initiate_shutdown as usize);
+
+    let _ = runtime.block_on(accept_loop_async(serve_args));
+    runtime.shutdown_timeout(Duration::from_millis(2000));
+
+    info!(
+        "(PID={}) accept_loop finished, shutting down.",
+        libc::getpid()
+    );
+
+    libc::signal(libc::SIGTERM, libc::SIG_DFL);
+    libc::signal(libc::SIGINT, libc::SIG_DFL);
+
+    debug!(
+        "(PID={}) HTTP listener state: {:?}",
+        libc::getpid(),
+        serve_args.http_listener
+    );
+    debug!("(PID={}) Dropping STD listeners", libc::getpid());
+    drop(serve_args.http_listener.take());
+    drop(serve_args.https_listener.take());
+
+    std::ptr::null_mut()
+}
+
+unsafe extern "C" fn gather_requests_no_gvl(ptr: *mut c_void) -> *mut c_void {
+    let receiver = unsafe { &*(ptr as *const Arc<Receiver<RackRequest>>) };
+
+    let batch_size = 25;
+    let mut batch = Vec::with_capacity(batch_size);
+
+    // Try to collect a batch of up to `batch_size` requests
+    while batch.len() < batch_size {
+        match receiver.try_recv() {
+            Ok(request) => batch.push(request),
+            Err(_) => break,
+        }
+    }
+
+    // If the batch is empty, wait for a single request
+    if batch.is_empty() {
+        match receiver.recv_timeout(Duration::from_micros(100)) {
+            Ok(request) => batch.push(request),
+            Err(_) => (),
+        }
+    }
+
+    // Process the collected batch of requests
+    Box::into_raw(Box::new(batch)) as *mut c_void
+}
+
+unsafe fn gather_requests(receiver: &Arc<Receiver<RackRequest>>) -> Vec<RackRequest> {
+    let data_ptr = receiver as *const Arc<Receiver<RackRequest>> as *mut c_void;
+    let result_ptr =
+        rb_thread_call_without_gvl(Some(gather_requests_no_gvl), data_ptr, None, null_mut());
+    let result = Box::from_raw(result_ptr as *mut Vec<RackRequest>);
+    *result
+}
+
+unsafe extern "C" fn ruby_thread_worker(ptr: *mut c_void) -> u64 {
+    let ruby = Ruby::get_unchecked();
+    let receiver = *Box::from_raw(ptr as *mut Arc<Receiver<RackRequest>>);
+    let use_scheduler = true;
+
+    if use_scheduler {
+        let receiver_clone = receiver.clone();
+        let fiber_class = ruby.get_inner(&FIBER_CLASS);
+        let scheduler = ruby.get_inner(&SCHEDULER_CLASS).new_instance(()).unwrap();
+        fiber_class
+            .funcall::<_, _, Value>("set_scheduler", (scheduler,))
+            .unwrap();
+        let fib = ruby.proc_from_fn(move |_rb, _arg, _blk| {
+            let ruby = Ruby::get_unchecked();
+            let fiber_class = ruby.get_inner(&FIBER_CLASS);
+            let receiver = receiver_clone.clone();
+            let scheduler: Value = fiber_class.funcall("scheduler", ()).unwrap();
+            let id_yield = ruby.intern("yield");
+            let atomic_counter = Arc::new(AtomicUsize::new(0));
+            loop {
+                let current_count = atomic_counter.load(Ordering::Relaxed);
+                if current_count > 0 {
+                    if let Err(_) = scheduler.funcall::<Id, (), Value>(id_yield, ()) {
+                        break;
+                    }
+                }
+                let batch = gather_requests(&receiver);
+                for request in batch {
+                    let atomic_counter_clone = Arc::clone(&atomic_counter);
+                    let fiber = ruby
+                        .fiber_new_from_fn(Default::default(), move |ruby, _args, _block| {
+                            atomic_counter_clone.fetch_add(1, Ordering::Relaxed);
+                            request.process(ruby).expect("Error processing request");
+                            atomic_counter_clone.fetch_sub(1, Ordering::Relaxed);
+                        })
+                        .unwrap();
+
+                    scheduler.funcall::<_, _, Value>(*ID_RESUME, (fiber,)).ok();
+                }
+
+                if SHUTDOWN_REQUESTED.load(Ordering::Relaxed) {
+                    break;
+                }
+            }
+        });
+        fiber_class
+            .funcall_with_block::<_, _, Value>(*ID_SCHEDULE, (), fib)
+            .expect("scheduled fiber");
+    } else {
+        loop {
+            let batch = gather_requests(&receiver);
+            for request in batch {
+                request.process(&ruby).expect("Error processing request");
+            }
+
+            if SHUTDOWN_REQUESTED.load(Ordering::Relaxed) {
+                break;
+            }
+        }
+    }
+    0
+}
+
+fn start_ruby_thread_pool(pool_size: usize, receiver: Arc<Receiver<RackRequest>>) {
+    for _i in 0..pool_size {
+        unsafe {
+            rb_thread_create(
+                Some(ruby_thread_worker),
+                Box::into_raw(Box::new(receiver.clone())) as *mut c_void,
+            )
+        };
+    }
+}
+
+unsafe fn initiate_shutdown(signum: i32, action: sighandler_t) {
+    if SHUTDOWN_REQUESTED.load(Ordering::Relaxed) {
+        return;
+    }
+    SHUTDOWN_REQUESTED.store(true, Ordering::SeqCst);
+    info!(
+        "(PID={}) Initiating shutdown with signal {}: {}",
+        libc::getpid(),
+        signum,
+        action
+    );
+
+    if let Some(sender) = CTRL_C_SIGNAL_CHANNEL.write().unwrap().take() {
+        let _ = sender.send(());
+    }
+
+    let children = CHILDREN.read().unwrap();
+    for child in children.iter() {
+        if child.pid > 0 {
+            let sig_result = libc::kill(child.pid, libc::SIGTERM);
+            if sig_result == -1 {
+                eprint!("Failed to send SIGTERM to child {}", child.pid);
+            }
+            let mut status = 0;
+            let wait_result = libc::waitpid(child.pid, &mut status, libc::WNOHANG);
+            if wait_result != 0 {
+                libc::kill(child.pid, libc::SIGKILL);
+                libc::waitpid(child.pid, &mut status, 0);
+            }
+        }
+    }
+}
+
+struct PreforkArgs {
+    workers: u16,
+    before_fork: Option<Proc>,
+    after_fork: Option<Proc>,
+}
+
+pub unsafe extern "C" fn kill_other_threads(
+    _: *mut std::os::raw::c_void,
+) -> *mut std::os::raw::c_void {
+    let thread_class =
+        RClass::from_value(eval("Thread").expect("Failed to fetch Ruby Thread class"))
+            .expect("Failed to fetch Ruby Thread class");
+    let threads: RArray = thread_class
+        .funcall("list", ())
+        .expect("Failed to list Ruby threads");
+    let current: Value = thread_class
+        .funcall("current", ())
+        .expect("Failed to get current thread");
+
+    // Signal thread exit
+    for thr in threads {
+        let same: bool = thr
+            .funcall("==", (current,))
+            .expect("Failed to compare threads");
+        if !same {
+            let _: Option<Value> = thr.funcall("exit", ()).expect("Failed to exit thread");
+        }
+    }
+
+    // Attempt to join
+    for thr in threads {
+        let same: bool = thr
+            .funcall("==", (current,))
+            .expect("Failed to compare threads");
+        if !same {
+            let _: Option<Value> = thr
+                .funcall("join", (0.5_f64,))
+                .expect("Failed to join thread");
+        }
+    }
+
+    // Terminate
+    for thr in threads {
+        let same: bool = thr
+            .funcall("==", (current,))
+            .expect("Failed to compare threads");
+        if !same {
+            let alive: bool = thr
+                .funcall("alive?", ())
+                .expect("Failed to check if thread is alive");
+            if alive {
+                let _: Option<Value> = thr.funcall("kill", ()).expect("Failed to kill thread");
+            }
+        }
+    }
+
+    std::ptr::null_mut()
+}
+
+pub unsafe extern "C" fn before_fork(ptr: *mut std::os::raw::c_void) -> *mut std::os::raw::c_void {
+    let pf_args = &mut *(ptr as *mut PreforkArgs);
+    debug!("(PID={}) Before fork", libc::getpid());
+    if let Some(ref p) = pf_args.before_fork {
+        let _ = p.call::<(), Value>(());
+    };
+    std::ptr::null_mut()
+}
+
+pub unsafe extern "C" fn after_fork(ptr: *mut std::os::raw::c_void) -> *mut std::os::raw::c_void {
+    let pf_args = &mut *(ptr as *mut PreforkArgs);
+    debug!("(PID={}) After fork", libc::getpid());
+    if let Some(ref p) = pf_args.after_fork {
+        let _ = p.call::<(), Value>(());
+    };
+    std::ptr::null_mut()
+}
+
+pub unsafe extern "C" fn rb_fork(_: *mut std::os::raw::c_void) -> *mut std::os::raw::c_void {
+    let ruby = Ruby::get_unchecked();
+    let pid: Option<i32> = ruby
+        .module_kernel()
+        .funcall(ruby.intern("fork"), ())
+        .unwrap();
+    if let Some(child_pid) = pid {
+        debug!(
+            "(PID={}) Forked child process with PID {}",
+            libc::getpid(),
+            child_pid
+        );
+        return child_pid as *mut std::os::raw::c_void;
+    } else {
+        debug!("(PID={}) New child process starting ", libc::getpid());
+        std::ptr::null_mut()
+    }
+}
+
+unsafe extern "C" fn prefork_setup(ptr: *mut c_void) -> *mut c_void {
+    let pf_args = &*(ptr as *mut PreforkArgs);
+    let workers = pf_args.workers;
+    if workers >= 1 {
+        let mut children = Vec::with_capacity(workers as usize - 1);
+        rb_thread_call_with_gvl(Some(before_fork), ptr);
+        rb_thread_call_with_gvl(Some(kill_other_threads), std::ptr::null_mut());
+
+        for _i in 0..workers {
+            let (read, write) = socketpair(
+                AddressFamily::Unix,
+                SockType::Stream,
+                None,
+                SockFlag::empty(),
+            )
+            .unwrap();
+
+            let response_ptr = rb_thread_call_with_gvl(Some(rb_fork), std::ptr::null_mut());
+            let pid = response_ptr as i32;
+            debug!("Got reader and writer");
+
+            match pid {
+                0 => {
+                    let _ = Box::into_raw(Box::new(write));
+
+                    rb_thread_call_with_gvl(Some(after_fork), ptr);
+                    let devnull = OpenOptions::new()
+                        .write(true)
+                        .open("/dev/null")
+                        .expect("Failed to open /dev/null");
+                    unsafe {
+                        libc::dup2(devnull.as_raw_fd(), libc::STDIN_FILENO);
+                    }
+                    return Box::into_raw(Box::new(read)) as *mut c_void;
+                }
+                child_pid => {
+                    let _ = Box::into_raw(Box::new(read));
+                    children.push(ChildProcess {
+                        pid: child_pid,
+                        writer: Arc::new(write),
+                    })
+                }
+            }
+        }
+        CHILDREN.write().unwrap().extend(children);
+    }
+    return std::ptr::null_mut();
+}
+
+// TLS configuration
+fn configure_tls(cert_path: Option<String>, key_path: Option<String>) -> Option<Arc<ServerConfig>> {
+    if cert_path.is_none() || key_path.is_none() {
+        return None;
+    }
+    use tokio_rustls::rustls::{Certificate, PrivateKey};
+
+    let cert_bytes =
+        std::fs::read(cert_path.expect("Expected a cert_path")).expect("Failed to read cert file");
+    let key_bytes =
+        std::fs::read(key_path.expect("Expected a key_path")).expect("Failed to read key file");
+
+    let certs = vec![Certificate(cert_bytes)];
+    let key = PrivateKey(key_bytes);
+
+    let mut config = ServerConfig::builder()
+        .with_safe_defaults()
+        .with_no_client_auth()
+        .with_single_cert(certs, key)
+        .expect("Failed to build TLS config");
+    config.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
+
+    Some(Arc::new(config))
+}
+
+fn filter_keywords(keywords: RHash, allowed: &[&str]) -> RHash {
+    let filtered = RHash::new();
+    for key in keywords.funcall::<_, _, RArray>("keys", ()).unwrap() {
+        let key_str: String = key.funcall("to_s", ()).unwrap();
+        if allowed.contains(&key_str.as_str()) {
+            filtered.aset(key, keywords.get(key).unwrap()).unwrap();
+        }
+    }
+    filtered
+}
+/// The main "start(...)" function that Ruby calls via `Osprey.start`
+fn start_server(args: &[Value]) -> Result<(), Error> {
+    SHUTDOWN_REQUESTED.store(false, Ordering::SeqCst);
+
+    let srv = RackServerConfig::from_args(args)?;
+
+    let mut http_listener: Option<TcpListener> = None;
+    let mut https_listener: Option<TcpListener> = None;
+    let mut reader: Option<OwnedFd> = None;
+
+    let mut pf_args = PreforkArgs {
+        workers: srv.workers,
+        before_fork: srv.before_fork,
+        after_fork: srv.after_fork,
+    };
+
+    let pf_args_ptr = &mut pf_args as *mut PreforkArgs as *mut c_void;
+
+    unsafe {
+        info!("(PID={}) Parent process started.", libc::getpid());
+        let ptr = rb_thread_call_without_gvl(
+            Some(prefork_setup),
+            pf_args_ptr,
+            None,
+            std::ptr::null_mut(),
+        );
+        if !ptr.is_null() {
+            reader = Some(*Box::from_raw(ptr as *mut OwnedFd));
+        }
+    }
+
+    unsafe {
+        let is_parent = !CHILDREN.read().unwrap().is_empty(); //|| srv.workers == 1;
+
+        if is_parent {
+            (http_listener, https_listener) = setup_listeners(&srv)?;
+        }
+        let serve_args = AcceptLoopArgs {
+            http_listener,
+            https_listener,
+            reader,
+            cert_path: srv.cert_path,
+            key_path: srv.key_path,
+            threads: srv.threads,
+            shutdown_timeout: srv.shutdown_timeout,
+            script_name: srv.script_name,
+        };
+        let args_ptr = Box::into_raw(Box::new(serve_args)) as *mut c_void;
+        if is_parent {
+            call_without_gvl(|| 3 + 2);
+            rb_thread_call_without_gvl(
+                Some(accept_loop),
+                args_ptr,
+                Some(accept_loop_interrupt),
+                std::ptr::null_mut(),
+            );
+            wait_for_children(srv.shutdown_timeout);
+            CHILDREN.write().unwrap().clear();
+        } else {
+            rb_thread_call_without_gvl(
+                Some(accept_ruby_connection_loop),
+                args_ptr,
+                None,
+                std::ptr::null_mut(),
+            );
+        }
+    }
+
+    debug!("(PID={}) accept_loop returned. Exiting.", unsafe {
+        libc::getpid()
+    });
+    Ok(())
+}
+
+unsafe fn is_pid_running(pid: i32) -> bool {
+    let mut status = 0;
+    let result = unsafe { libc::waitpid(pid, &mut status, libc::WNOHANG) };
+    return result == 0;
+}
+
+fn wait_for_children(shutdown_timeout: Duration) {
+    unsafe {
+        libc::signal(libc::SIGTERM, initiate_shutdown as usize);
+        libc::signal(libc::SIGINT, initiate_shutdown as usize);
+    }
+
+    for child_process in CHILDREN.read().unwrap().iter() {
+        let mut status = 0;
+
+        loop {
+            if !unsafe { is_pid_running(child_process.pid) } {
+                break;
+            }
+
+            let wait_result =
+                unsafe { libc::waitpid(child_process.pid, &mut status, libc::WNOHANG) };
+
+            if wait_result == -1 {
+                // Error occurred, handle appropriately
+
+                debug!(
+                    "(PID={}) Error waiting for child process: {}",
+                    child_process.pid,
+                    std::io::Error::last_os_error()
+                );
+                break;
+            } else if wait_result > 0 {
+                if libc::WIFSIGNALED(status) || libc::WIFSTOPPED(status) || libc::WIFEXITED(status)
+                {
+                    break;
+                }
+            } else {
+                unsafe {
+                    if SHUTDOWN_REQUESTED.load(Ordering::Relaxed) {
+                        debug!(
+                            "(PID={}) Waiting for child {} to exit. Status: {}. Wait Result: {}",
+                            libc::getpid(),
+                            child_process.pid,
+                            status,
+                            wait_result
+                        );
+                        sleep(shutdown_timeout.as_secs() as u32 + 1);
+                    }
+                };
+            }
+        }
+    }
+}
+
+impl RackServerConfig {
+    fn from_args(args: &[Value]) -> Result<Self, Error> {
+        let scan_args: Args<(), (), (), (), RHash, ()> = scan_args(args)?;
+
+        let args: KwArgs<
+            (Value,),
+            (
+                Option<String>,
+                Option<u16>,
+                Option<u16>,
+                Option<u16>,
+                Option<u16>,
+                Option<String>,
+                Option<String>,
+                Option<f64>,
+                Option<String>,
+            ),
+            (),
+        > = get_kwargs(
+            filter_keywords(
+                scan_args.keywords,
+                &[
+                    "app",
+                    "host",
+                    "port",
+                    "http_port",
+                    "workers",
+                    "threads",
+                    "cert_path",
+                    "key_path",
+                    "shutdown_timeout",
+                    "script_name",
+                ],
+            ),
+            &["app"],
+            &[
+                "host",
+                "port",
+                "http_port",
+                "workers",
+                "threads",
+                "cert_path",
+                "key_path",
+                "shutdown_timeout",
+                "script_name",
+            ],
+        )?;
+
+        let args2: KwArgs<(), (Option<Proc>, Option<Proc>), ()> = get_kwargs(
+            filter_keywords(scan_args.keywords, &["before_fork", "after_fork"]),
+            &[],
+            &["before_fork", "after_fork"],
+        )?;
+
+        let ruby = Ruby::get().unwrap();
+        let host = args.optional.0.unwrap_or("127.0.0.1".to_owned());
+        let port = args.optional.1.unwrap_or(3000);
+        let http_port = args.optional.2;
+        let workers = args.optional.3.unwrap_or(1);
+        let threads = args.optional.4.unwrap_or(1);
+        let cert_path = args.optional.5;
+        let key_path = args.optional.6;
+        let shutdown_timeout =
+            Duration::from_millis((args.optional.7.unwrap_or(5.0) * 1000.0) as u64);
+        let script_name = args.optional.8.unwrap_or("/".to_owned());
+
+        let app = args.required.0;
+        let handler: Value = app.funcall("method", (*ID_CALL,)).unwrap();
+        ruby.get_inner(&OSPREY)
+            .ivar_set("@handler", handler)
+            .unwrap();
+        ruby.get_inner(&WORK_QUEUE)
+            .funcall::<&str, (), Value>("clear", ())
+            .ok();
+        Ok(Self {
+            host,
+            port,
+            http_port,
+            workers,
+            threads,
+            cert_path,
+            key_path,
+            shutdown_timeout,
+            script_name,
+            before_fork: args2.optional.0,
+            after_fork: args2.optional.1,
+        })
+    }
+}
+/// Standard Magnus init
+#[magnus::init]
+fn init(ruby: &magnus::Ruby) -> Result<(), Error> {
+    SimpleLogger::new().env().init().unwrap();
+
+    ruby.get_inner(&OSPREY)
+        .define_singleton_method("start", function!(start_server, -1))?;
+
+    define_collector(ruby)?;
+    define_request_info(&ruby)?;
+
+    Ok(())
+}
+
+// Mapping functions for requests and responses
+#[inline]
+async fn map_hyper_request(
+    parts: hyper::http::request::Parts,
+    peer_addr: SocketAddr,
+    script_name: String,
+    stream_fd: i32,
+) -> (RackRequest, oneshot::Receiver<RackResponse>) {
+    let (sender, receiver) = oneshot::channel();
+
+    let headers: HashMap<String, String> = parts
+        .headers
+        .iter()
+        .map(|(k, v)| (k.to_string(), v.to_str().unwrap_or("").to_string()))
+        .collect();
+
+    let protocol = headers
+        .get("upgrade")
+        .and_then(|value| {
+            Some(
+                value
+                    .split(',')
+                    .map(|s| s.trim().to_string())
+                    .collect::<Vec<_>>(),
+            )
+        })
+        .or_else(|| {
+            headers.get("protocol").map(|value| {
+                value
+                    .split(',')
+                    .map(|s| s.trim().to_string())
+                    .collect::<Vec<_>>()
+            })
+        })
+        .unwrap_or_else(|| vec!["http".to_string()]);
+
+    unsafe {
+        debug!("(PID={}) peer_adr: {:?}", libc::getpid(), peer_addr);
+        debug!(
+            "(PID={}) host header: {:?}",
+            libc::getpid(),
+            headers.get("host").unwrap_or(&"".to_string())
+        );
+    };
+    let scheme = parts.uri.scheme_str().unwrap_or("http").to_string();
+    let host = parts
+        .uri
+        .host()
+        .unwrap_or(headers.get("host").unwrap_or(&"".to_string()))
+        .to_string();
+    let port = host
+        .split(':')
+        .nth(1)
+        .unwrap_or(if &scheme == "https" { "443" } else { "80" })
+        .parse::<i32>()
+        .unwrap();
+
+    let query_string = parts.uri.query().unwrap_or("").to_string();
+    (
+        RackRequest(RefCell::new(Some(RackRequestInner {
+            path: parts.uri.path().to_string(),
+            method: parts.method.to_string(),
+            version: format!("{:?}", parts.version),
+            remote_addr: peer_addr.ip().to_string(),
+            script_name,
+            scheme,
+            host,
+            port,
+            protocol,
+            query_string,
+            headers,
+            stream_fd,
+            sender: Arc::new(Mutex::new(Some(sender))),
+        }))),
+        receiver,
+    )
+}
+
+use hyper::body::{Frame, SizeHint};
+use std::task::{Context, Poll};
+use tokio::{
+    io::{AsyncBufReadExt, AsyncReadExt, BufReader},
+    sync::mpsc,
+};
+
+#[derive(Debug)]
+pub struct HijackedStreamingBody {
+    rx: mpsc::Receiver<Result<Bytes, io::Error>>,
+    done: bool,
+}
+
+impl hyper::body::Body for HijackedStreamingBody {
+    type Data = Bytes;
+    type Error = Infallible;
+
+    fn poll_frame(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>> {
+        if self.done {
+            return Poll::Ready(None);
+        }
+
+        match Pin::new(&mut self.rx).poll_recv(cx) {
+            Poll::Ready(Some(Ok(bytes))) => {
+                let frame = Frame::data(bytes);
+                Poll::Ready(Some(Ok(frame)))
+            }
+            Poll::Ready(Some(Err(e))) => {
+                self.done = true;
+                Poll::Ready(None)
+            }
+            Poll::Ready(None) => Poll::Ready(None),
+            Poll::Pending => Poll::Pending,
+        }
+    }
+    fn is_end_stream(&self) -> bool {
+        false // rely on the channel closing
+    }
+
+    fn size_hint(&self) -> SizeHint {
+        SizeHint::default()
+    }
+}
+
+// ─── A HELPER TO PARSE THE HTTP/1.1 RESPONSE ───────────────────────────────
+
+// Given a buffered reader reading from the hijacked connection, read until the header section
+// is complete (i.e. until "\r\n\r\n" is encountered), and then return the header lines and any
+// bytes that already belong to the body.
+async fn read_response_headers<R>(reader: &mut R) -> io::Result<(Vec<String>, Vec<u8>)>
+where
+    R: AsyncBufReadExt + Unpin,
+{
+    let mut headers_buf = Vec::new();
+    // Read until we have the header terminator.
+    loop {
+        let mut line = String::new();
+        let n = reader.read_line(&mut line).await?;
+        if n == 0 {
+            // EOF reached unexpectedly.
+            break;
+        }
+        headers_buf.extend_from_slice(line.as_bytes());
+        if headers_buf.ends_with(b"\r\n\r\n") || headers_buf.ends_with(b"\n\n") {
+            break;
+        }
+    }
+    // Split the headers from any already-read part of the body.
+    let header_body_split = b"\r\n\r\n";
+    if let Some(pos) = headers_buf
+        .windows(header_body_split.len())
+        .position(|window| window == header_body_split)
+    {
+        let header_lines = &headers_buf[..pos];
+        let remaining = headers_buf[(pos + header_body_split.len())..].to_vec();
+        // Split the header lines into strings.
+        let headers = String::from_utf8_lossy(header_lines)
+            .lines()
+            .map(|s| s.to_string())
+            .collect::<Vec<_>>();
+        Ok((headers, remaining))
+    } else {
+        // If not found, return all as headers and no body data.
+        let headers = String::from_utf8_lossy(&headers_buf)
+            .lines()
+            .map(|s| s.to_string())
+            .collect::<Vec<_>>();
+        Ok((headers, Vec::new()))
+    }
+}
+
+/// Given the raw header lines (from an HTTP/1.1 response), parse out the status and headers.
+///
+/// This is a very simplistic parser; you may wish to use a real HTTP parser.
+fn parse_status_and_headers(lines: &[String]) -> (StatusCode, HeaderMap) {
+    let mut status = StatusCode::OK;
+    let mut header_map = HeaderMap::new();
+
+    if let Some(first_line) = lines.first() {
+        // Expect a line like "HTTP/1.1 200 OK"
+        let parts: Vec<&str> = first_line.split_whitespace().collect();
+        if parts.len() >= 2 {
+            if let Ok(code) = parts[1].parse::<u16>() {
+                status = StatusCode::from_u16(code).unwrap_or(StatusCode::OK);
+            }
+        }
+    }
+    for line in &lines[1..] {
+        if let Some((name, value)) = line.split_once(':') {
+            header_map.insert(
+                HeaderName::from_bytes(name.as_bytes()).unwrap(),
+                HeaderValue::from_bytes(value.as_bytes()).unwrap(),
+            );
+        }
+    }
+    (status, header_map)
+}
+// ─── THE HIJACK HANDLING FUNCTION ───────────────────────────────────────────
+
+async fn read_hijacked_headers(fd: i32) -> (HeaderMap, StatusCode, bool, Vec<u8>) {
+    let hijack_stream =
+        tokio::net::UnixStream::from_std(unsafe { UnixStream::from_raw_fd(fd) }).unwrap();
+    let mut reader = BufReader::new(hijack_stream);
+
+    // Read until blank line => that's the "HTTP/1.1 101\r\nUpg...\r\n\r\n"
+    let (header_lines, initial_body_bytes) = read_response_headers(&mut reader).await.unwrap();
+
+    // Parse them
+    let (status, hdrs) = parse_status_and_headers(&header_lines);
+    let requires_upgrade = status == StatusCode::SWITCHING_PROTOCOLS;
+
+    // Dont close the FD, we're going to use it later.
+    let _ = reader.into_inner().into_std().unwrap().into_raw_fd();
+
+    (hdrs, status, requires_upgrade, initial_body_bytes)
+}
+
+/// This function is called when rack_response.status == -1 (i.e. the app hijacked the stream).
+/// It takes the raw UnixStream (from the proxy side) and uses it to parse an HTTP/1.1 response
+/// written by the app. It then returns a Hyper Response that uses a streaming body.
+/// This function is called when `rack_response.status == -1`.
+/// We read the lines Ruby wrote over that hijacked FD, parse them,
+/// and build a streaming response. But if Ruby’s lines say `101`,
+/// we do not close the connection until Ruby closes its socket.
+async fn handle_hijacked_response(
+    hijack_stream_fd: i32,
+    parts: hyper::http::request::Parts,
+) -> Result<Response<BoxBody<Bytes, Infallible>>, hyper::Error> {
+    // We read the headers from the raw stream (in HTTP/1.1 format)
+    // and will either upgrade the connection or use the body as a streaming body.
+    let (headers, status, requires_upgrade, initial_body_bytes) =
+        read_hijacked_headers(hijack_stream_fd).await;
+
+    let hijack_stream =
+        tokio::net::UnixStream::from_std(unsafe { UnixStream::from_raw_fd(hijack_stream_fd) })
+            .unwrap();
+
+    let mut response = if requires_upgrade {
+        tokio::spawn(async move {
+            let mut req = Request::from_parts(parts, Empty::<Bytes>::new());
+            match hyper::upgrade::on(&mut req).await {
+                Ok(upgraded) => {
+                    two_way_bridge(upgraded, hijack_stream)
+                        .await
+                        .expect("Error in creating two way bridge");
+                }
+                Err(e) => eprintln!("upgrade error: {:?}", e),
+            }
+        });
+        Response::new(BoxBody::new(Empty::new()))
+    } else {
+        let (tx, rx) = mpsc::channel::<Result<Bytes, io::Error>>(16);
+        if !initial_body_bytes.is_empty() {
+            let _ = tx.send(Ok(Bytes::from(initial_body_bytes))).await;
+        }
+
+        tokio::spawn(async move {
+            let mut reader = BufReader::new(hijack_stream);
+            let mut buf = [0u8; 1024];
+            loop {
+                match reader.read(&mut buf).await {
+                    Ok(0) => {
+                        info!("Hijacked socket closed. EOF");
+                        break;
+                    }
+                    Ok(n) => {
+                        // Forward chunk
+                        if tx
+                            .send(Ok(Bytes::copy_from_slice(&buf[..n])))
+                            .await
+                            .is_err()
+                        {
+                            info!("Client side dropped the channel");
+                            break;
+                        }
+                    }
+                    Err(e) => {
+                        info!("Read error: {:?}", e);
+                        let _ = tx.send(Err(e)).await;
+                        break;
+                    }
+                }
+            }
+        });
+        Response::new(BoxBody::new(HijackedStreamingBody { rx, done: false }))
+    };
+    *response.status_mut() = status;
+    *response.headers_mut() = headers;
+    Ok(response)
+}