kino 0.5.0 → 0.7.0

data/ext/kino/src/request.rs

@@ -24,14 +24,10 @@ pub struct RequestCtx {
     pub local_addr: SocketAddr,
     pub https: bool,
     /// Request body, streamed from hyper through a bounded channel: hyper is
-    /// only polled as Ruby consumes, so inbound backpressure is free.
-    pub body_rx: flume::Receiver<Bytes>,
-    /// Set by the body forwarder when the body exceeded max_body_size: turns
-    /// the next read into an error instead of a (truncated) clean EOF.
-    pub body_overflow: Arc<std::sync::atomic::AtomicBool>,
-    /// Set by the body forwarder when the client stalled past the idle
-    /// deadline: the next read raises so the worker reclaims its slot.
-    pub body_timeout: Arc<std::sync::atomic::AtomicBool>,
+    /// only polled as Ruby consumes, so inbound backpressure is free. None
+    /// when no byte can ever arrive (most GETs): bodyless requests skip the
+    /// channel allocation entirely.
+    pub body_rx: Option<flume::Receiver<Bytes>>,
     /// When a frame is bigger than read_body's max_len, the rest waits here.
     pub leftover: Option<Bytes>,
     /// The owning worker slot (set at admit time, queue.rs); its interrupt
@@ -142,7 +138,10 @@ pub fn build_env(ruby: &Ruby, ctx: &RequestCtx) -> Result<RHash, Error> {
     use crate::env_strings;
 
     let s = env_strings::get();
-    let env = ruby.hash_new();
+    // Pre-sized: a dozen static keys plus one per header lands near 30
+    // entries, which a default Hash reaches only via the ar-to-st
+    // migration and a rehash per doubling.
+    let env = ruby.hash_new_capa(32);
     // Opaque -> live RString for this thread's Ruby handle.
     let live = |o: magnus::value::Opaque<RString>| ruby.get_inner(o);
 
@@ -163,6 +162,7 @@ pub fn build_env(ruby: &Ruby, ctx: &RequestCtx) -> Result<RHash, Error> {
     env.aset(live(s.query_string), query)?;
     let protocol = match ctx.version {
         http::Version::HTTP_10 => s.http10,
+        http::Version::HTTP_2 => s.http2,
         _ => s.http11,
     };
     env.aset(live(s.server_protocol), live(protocol))?;
@@ -183,37 +183,25 @@ pub fn build_env(ruby: &Ruby, ctx: &RequestCtx) -> Result<RHash, Error> {
         }
     }
 
-    // SERVER_NAME/PORT: prefer the Host header (HTTP/1.1 requires it),
-    // fall back to the accepted socket's local address.
-    let host_header = ctx.headers.get(http::header::HOST);
-    match host_header {
-        Some(host) => {
-            let local_port = ctx.local_addr.port();
-            env_strings::set_host_env(ruby, env, host.as_bytes(), || {
-                match std::str::from_utf8(host.as_bytes()) {
-                    Ok(h) => split_host_port(h, local_port),
-                    Err(_) => (
-                        String::from_utf8_lossy(host.as_bytes()).into_owned(),
-                        local_port,
-                    ),
-                }
-            })?;
-        }
-        None => {
-            let ip = ctx.local_addr.ip();
-            let port = ctx.local_addr.port();
-            env_strings::set_host_env(ruby, env, format!("\0{ip}:{port}").as_bytes(), || {
-                (ip.to_string(), port)
-            })?;
-        }
-    }
-
     for name in ctx.headers.keys() {
-        // Single-value fast path (the overwhelming majority).
+        let key = if *name == http::header::CONTENT_TYPE {
+            live(s.content_type)
+        } else if *name == http::header::CONTENT_LENGTH {
+            live(s.content_length)
+        } else {
+            match s.header_names.get(name.as_str()) {
+                Some(cached) => live(*cached),
+                None => ruby.str_new(&env_strings::cgi_name(name.as_str())),
+            }
+        };
+
+        // Single-value fast path (the overwhelming majority); the value
+        // cache turns low-cardinality repeats (UA, accept-*, sec-ch-*)
+        // into a lookup of one frozen string instead of an allocation.
         let mut values = ctx.headers.get_all(name).iter();
         let first = values.next().map(|v| v.as_bytes()).unwrap_or(b"");
-        let value = match values.next() {
-            None => ruby.str_from_slice(first),
+        match values.next() {
+            None => env_strings::set_value_env(ruby, env, key, name.as_str(), first)?,
             Some(second) => {
                 let sep: &[u8] = if name == http::header::COOKIE {
                     b"; "
@@ -230,30 +218,63 @@ pub fn build_env(ruby: &Ruby, ctx: &RequestCtx) -> Result<RHash, Error> {
                     joined.extend_from_slice(sep);
                     joined.extend_from_slice(v.as_bytes());
                 }
-                ruby.str_from_slice(&joined)
+                env.aset(key, ruby.str_from_slice(&joined))?;
             }
-        };
+        }
+    }
 
-        let key = if *name == http::header::CONTENT_TYPE {
-            live(s.content_type)
-        } else if *name == http::header::CONTENT_LENGTH {
-            live(s.content_length)
-        } else {
-            match s.header_names.get(name.as_str()) {
-                Some(cached) => live(*cached),
-                None => ruby.str_new(&env_strings::cgi_name(name.as_str())),
+    // SERVER_NAME/SERVER_PORT/HTTP_HOST, best source first: the request
+    // URI's authority (every h2 request via :authority; also h1
+    // absolute-form, where it beats Host per RFC 9112), then the Host
+    // header (HTTP/1.1 requires it), then the accepted socket's local
+    // address. Runs after the header loop so an authority-derived
+    // HTTP_HOST wins over a literal host header a proxy forwarded.
+    if let Some(authority) = ctx.uri.authority() {
+        let local_port = ctx.local_addr.port();
+        env_strings::set_authority_env(ruby, env, authority.as_str(), || {
+            (
+                authority.host().to_string(),
+                authority.port_u16().unwrap_or(local_port),
+            )
+        })?;
+    } else {
+        match ctx.headers.get(http::header::HOST) {
+            Some(host) => {
+                let local_port = ctx.local_addr.port();
+                env_strings::set_host_env(
+                    ruby,
+                    env,
+                    host.as_bytes(),
+                    || match std::str::from_utf8(host.as_bytes()) {
+                        Ok(h) => split_host_port(h, local_port),
+                        Err(_) => (
+                            String::from_utf8_lossy(host.as_bytes()).into_owned(),
+                            local_port,
+                        ),
+                    },
+                )?;
             }
-        };
-        env.aset(key, value)?;
+            None => {
+                let ip = ctx.local_addr.ip();
+                let port = ctx.local_addr.port();
+                env_strings::set_host_env(ruby, env, format!("\0{ip}:{port}").as_bytes(), || {
+                    (ip.to_string(), port)
+                })?;
+            }
+        }
     }
 
     Ok(env)
 }
 
-/// Bodyless requests get their channel sender dropped at accept time, so
-/// "disconnected and empty" means no byte can ever arrive.
+/// Bodyless requests carry no channel at all; a present channel that is
+/// disconnected and empty (EOF already reached) also has nothing left.
 fn body_possible(ctx: &RequestCtx) -> bool {
-    ctx.leftover.is_some() || !(ctx.body_rx.is_empty() && ctx.body_rx.is_disconnected())
+    ctx.leftover.is_some()
+        || ctx
+            .body_rx
+            .as_ref()
+            .is_some_and(|rx| !(rx.is_empty() && rx.is_disconnected()))
 }
 
 /// Complete response in one shot: status, the Rack headers Hash (iterated
@@ -307,7 +328,9 @@ impl Request {
         let mut chunk = match ctx.leftover.take() {
             Some(bytes) => bytes,
             None => {
-                let body_rx = ctx.body_rx.clone();
+                let Some(body_rx) = ctx.body_rx.clone() else {
+                    return Ok(None); // bodyless request: EOF from the start
+                };
                 let outcome = block_on(&ctx.slot, || {
                     match body_rx.recv_timeout(crate::queue::TICK) {
                         Ok(bytes) => Some(Some(bytes)),
@@ -320,13 +343,12 @@ impl Request {
                     Some(None) => {
                         // Disconnected: a clean EOF, unless the forwarder
                         // abandoned the body (too large, or the client stalled).
-                        if ctx.body_overflow.load(std::sync::atomic::Ordering::Relaxed) {
-                            return Err(body_too_large_error(ruby));
-                        }
-                        if ctx.body_timeout.load(std::sync::atomic::Ordering::Relaxed) {
-                            return Err(body_timeout_error(ruby));
-                        }
-                        return Ok(None); // EOF
+                        use crate::response::BodyAbandon;
+                        return match ctx.responder.body_abandoned() {
+                            Some(BodyAbandon::Oversize) => Err(body_too_large_error(ruby)),
+                            Some(BodyAbandon::TimedOut) => Err(body_timeout_error(ruby)),
+                            None => Ok(None), // EOF
+                        };
                     }
                     None => return Err(interrupted_error(ruby)),
                 }
@@ -335,8 +357,39 @@ impl Request {
 
         if chunk.len() > max_len {
             ctx.leftover = Some(chunk.split_off(max_len));
+            return Ok(Some(ruby.str_from_slice(&chunk)));
         }
-        Ok(Some(ruby.str_from_slice(&chunk)))
+
+        // Greedy drain: whatever the forwarder has already queued rides
+        // out in this same crossing, up to max_len. A body arriving as
+        // small DATA frames (HTTP/2 caps them at 16 KB unless negotiated
+        // higher) then costs one GVL round-trip and one Ruby string, not
+        // one per frame. Non-blocking: a chunk that has not arrived yet
+        // is next call's business, as are EOF and abandonment (try_recv's
+        // Disconnected included; the recv above maps them to errors).
+        let mut assembled: Option<RString> = None;
+        if let Some(body_rx) = ctx.body_rx.clone() {
+            let mut total = chunk.len();
+            while total < max_len {
+                let Ok(mut more) = body_rx.try_recv() else {
+                    break;
+                };
+                if more.len() > max_len - total {
+                    ctx.leftover = Some(more.split_off(max_len - total));
+                }
+                total += more.len();
+                let out = *assembled.get_or_insert_with(|| {
+                    let out = ruby.str_buf_new(max_len);
+                    out.cat(&chunk[..]);
+                    out
+                });
+                out.cat(&more[..]);
+            }
+        }
+        Ok(Some(match assembled {
+            Some(out) => out,
+            None => ruby.str_from_slice(&chunk),
+        }))
     }
 
     /// Start a streaming response: head goes out now, chunks follow via
@@ -439,7 +492,7 @@ fn coerce_str(value: Value) -> Result<RString, Error> {
     }
 }
 
-fn split_host_port(host: &str, default_port: u16) -> (String, u16) {
+pub(crate) fn split_host_port(host: &str, default_port: u16) -> (String, u16) {
     match host.rsplit_once(':') {
         Some((name, port)) if !name.is_empty() => match port.parse() {
             Ok(p) => (name.to_string(), p),
@@ -453,7 +506,6 @@ fn split_host_port(host: &str, default_port: u16) -> (String, u16) {
 /// fires the Drop-500 backstop into a dropped receiver, which is a no-op.
 #[cfg(test)]
 pub fn test_ctx() -> crate::registry::BoxedCtx {
-    let (_body_tx, body_rx) = flume::bounded(1);
     let (head_tx, _head_rx) = tokio::sync::oneshot::channel();
     Box::new(RequestCtx {
         method: http::Method::GET,
@@ -463,9 +515,7 @@ pub fn test_ctx() -> crate::registry::BoxedCtx {
         remote_addr: "127.0.0.1:40000".parse().expect("static addr"),
         local_addr: "127.0.0.1:9292".parse().expect("static addr"),
         https: false,
-        body_rx,
-        body_overflow: Arc::new(std::sync::atomic::AtomicBool::new(false)),
-        body_timeout: Arc::new(std::sync::atomic::AtomicBool::new(false)),
+        body_rx: None,
         leftover: None,
         slot: None,
         pin_slab: Arc::new(crate::pin::PinSlab::new()),
@@ -511,10 +561,34 @@ mod tests {
         assert_eq!(split_host_port(":8080", 80), (":8080".into(), 80));
     }
 
+    #[test]
+    fn authority_host_port_derivation() {
+        // The same derivation build_env applies to a URI authority (the
+        // h2 :authority pseudo-header): http::uri does the split, the
+        // socket's local port fills a missing port.
+        let with_port: http::Uri = "https://example.com:8443/x".parse().expect("uri");
+        let authority = with_port.authority().expect("authority");
+        assert_eq!(authority.host(), "example.com");
+        assert_eq!(authority.port_u16(), Some(8443));
+        assert_eq!(authority.as_str(), "example.com:8443");
+
+        let bare: http::Uri = "https://example.com/x".parse().expect("uri");
+        let authority = bare.authority().expect("authority");
+        assert_eq!(authority.host(), "example.com");
+        assert_eq!(authority.port_u16().unwrap_or(9292), 9292);
+
+        // Bracketed IPv6: host() keeps the brackets, matching the h1
+        // split_host_port convention for SERVER_NAME.
+        let v6: http::Uri = "https://[::1]:8443/x".parse().expect("uri");
+        let authority = v6.authority().expect("authority");
+        assert_eq!(authority.host(), "[::1]");
+        assert_eq!(authority.port_u16(), Some(8443));
+        assert_eq!(authority.as_str(), "[::1]:8443");
+    }
+
     #[test]
     fn body_possible_reflects_channel_and_leftover_state() {
-        // test_ctx drops its sender immediately: disconnected + empty = no
-        // byte can ever arrive.
+        // test_ctx carries no channel: bodyless by construction.
         let ctx = test_ctx();
         assert!(!body_possible(&ctx));
 
@@ -526,16 +600,23 @@ mod tests {
         // A live sender means bytes may still arrive.
         let (body_tx, body_rx) = flume::bounded(1);
         let mut ctx = test_ctx();
-        ctx.body_rx = body_rx;
+        ctx.body_rx = Some(body_rx);
         assert!(body_possible(&ctx));
         drop(body_tx);
 
+        // A dropped sender with nothing queued: EOF already reached.
+        let (body_tx, body_rx) = flume::bounded::<bytes::Bytes>(1);
+        drop(body_tx);
+        let mut ctx = test_ctx();
+        ctx.body_rx = Some(body_rx);
+        assert!(!body_possible(&ctx));
+
         // Disconnected but with a queued chunk: still readable.
         let (body_tx, body_rx) = flume::bounded(1);
         body_tx.send(bytes::Bytes::from_static(b"x")).unwrap();
         drop(body_tx);
         let mut ctx = test_ctx();
-        ctx.body_rx = body_rx;
+        ctx.body_rx = Some(body_rx);
         assert!(body_possible(&ctx));
     }
 }

data/ext/kino/src/response.rs

@@ -10,21 +10,35 @@
 //! makes `write_chunk` block in Ruby, with the GVL released.
 
 use std::io;
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
 
 use bytes::Bytes;
-use http_body_util::{combinators::BoxBody, BodyExt, Full, StreamBody};
+use http_body_util::{Either, Full, StreamBody};
 use parking_lot::Mutex;
 
 pub type BodyFrame = hyper::body::Frame<Bytes>;
 pub type FrameResult = Result<BodyFrame, io::Error>;
-pub type ResponseBody = BoxBody<Bytes, io::Error>;
+/// Both response shapes as one concrete type: no per-response Box or
+/// vtable, unlike BoxBody. Either erases the two error types itself.
+pub type ResponseBody =
+    Either<Full<Bytes>, StreamBody<flume::r#async::RecvStream<'static, FrameResult>>>;
 pub type HyperResponse = hyper::Response<ResponseBody>;
 
 const STREAM_BUFFER: usize = 8;
 
+/// Why the body forwarder stopped pulling a request body: read_body turns
+/// these into raised errors instead of a (truncated) clean EOF.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum BodyAbandon {
+    Oversize,
+    TimedOut,
+}
+
 pub struct Responder {
     responded: AtomicBool,
+    /// The forwarder's abandonment flag rides in the one per-request shared
+    /// allocation rather than its own Arc. 0 = none, 1/2 = BodyAbandon.
+    body_abandoned: AtomicU8,
     head_tx: Mutex<Option<tokio::sync::oneshot::Sender<HyperResponse>>>,
     body_tx: Mutex<Option<flume::Sender<FrameResult>>>,
 }
@@ -33,11 +47,31 @@ impl Responder {
     pub fn new(head_tx: tokio::sync::oneshot::Sender<HyperResponse>) -> Self {
         Responder {
             responded: AtomicBool::new(false),
+            body_abandoned: AtomicU8::new(0),
             head_tx: Mutex::new(Some(head_tx)),
             body_tx: Mutex::new(None),
         }
     }
 
+    /// Record why the body forwarder gave up; the store happens before the
+    /// sender drops, so a reader that saw Disconnected sees the flag too.
+    pub fn abandon_body(&self, why: BodyAbandon) {
+        let code = match why {
+            BodyAbandon::Oversize => 1,
+            BodyAbandon::TimedOut => 2,
+        };
+        self.body_abandoned.store(code, Ordering::Relaxed);
+    }
+
+    /// Whether (and why) the forwarder abandoned the request body.
+    pub fn body_abandoned(&self) -> Option<BodyAbandon> {
+        match self.body_abandoned.load(Ordering::Relaxed) {
+            1 => Some(BodyAbandon::Oversize),
+            2 => Some(BodyAbandon::TimedOut),
+            _ => None,
+        }
+    }
+
     /// Claim the right to respond. First caller wins; everyone else gets None.
     fn claim(&self) -> Option<tokio::sync::oneshot::Sender<HyperResponse>> {
         if self.responded.swap(true, Ordering::SeqCst) {
@@ -65,7 +99,7 @@ impl Responder {
             return Ok(false);
         };
         let (body_tx, body_rx) = flume::bounded::<FrameResult>(STREAM_BUFFER);
-        let response = builder.body(StreamBody::new(body_rx.into_stream()).boxed())?;
+        let response = builder.body(Either::Right(StreamBody::new(body_rx.into_stream())))?;
         *self.body_tx.lock() = Some(body_tx);
         let _ = tx.send(response);
         Ok(true)
@@ -98,7 +132,7 @@ impl Responder {
 }
 
 pub fn full_body(bytes: Bytes) -> ResponseBody {
-    Full::new(bytes).map_err(|never| match never {}).boxed()
+    Either::Left(Full::new(bytes))
 }
 
 /// Canned plain-text response, built entirely on the Rust side (used for