itsi-scheduler 0.2.16 → 0.2.18

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

@@ -1,4 +1,4 @@
-use super::file_watcher::{self};
+use super::file_watcher::{self, WatcherCommand};
 use crate::{
     ruby_types::ITSI_SERVER_CONFIG,
     server::{
@@ -9,7 +9,7 @@ use crate::{
 use derive_more::Debug;
 use itsi_error::ItsiError;
 use itsi_rb_helpers::{call_with_gvl, print_rb_backtrace, HeapValue};
-use itsi_tracing::{set_format, set_level, set_target, set_target_filters};
+use itsi_tracing::{error, set_format, set_level, set_target, set_target_filters};
 use magnus::{
     block::Proc,
     error::Result,
@@ -18,12 +18,12 @@ use magnus::{
 };
 use nix::{
     fcntl::{fcntl, FcntlArg, FdFlag},
-    unistd::{close, dup},
+    unistd::dup,
 };
 use parking_lot::{Mutex, RwLock};
 use std::{
     collections::HashMap,
-    os::fd::{AsRawFd, OwnedFd, RawFd},
+    os::fd::RawFd,
     path::PathBuf,
     str::FromStr,
     sync::{
@@ -32,7 +32,7 @@ use std::{
     },
     time::Duration,
 };
-use tracing::{debug, error};
+use tracing::debug;
 static DEFAULT_BIND: &str = "http://localhost:3000";
 static ID_BUILD_CONFIG: LazyId = LazyId::new("build_config");
 static ID_RELOAD_EXEC: LazyId = LazyId::new("reload_exec");
@@ -44,7 +44,7 @@ pub struct ItsiServerConfig {
     pub itsi_config_proc: Arc<Option<HeapValue<Proc>>>,
     #[debug(skip)]
     pub server_params: Arc<RwLock<Arc<ServerParams>>>,
-    pub watcher_fd: Arc<Option<OwnedFd>>,
+    pub watcher_fd: Arc<Option<file_watcher::WatcherPipes>>,
 }
 
 #[derive(Debug)]
@@ -72,13 +72,19 @@ pub struct ServerParams {
     pub ruby_thread_request_backlog_size: Option<usize>,
     pub middleware_loader: HeapValue<Proc>,
     pub middleware: OnceLock<MiddlewareSet>,
+    pub pipeline_flush: bool,
+    pub writev: Option<bool>,
+    pub max_concurrent_streams: Option<u32>,
+    pub max_local_error_reset_streams: Option<usize>,
+    pub max_header_list_size: u32,
+    pub max_send_buf_size: usize,
     pub binds: Vec<Bind>,
     #[debug(skip)]
     pub(crate) listeners: Mutex<Vec<Listener>>,
     listener_info: Mutex<HashMap<String, i32>>,
     pub itsi_server_token_preference: ItsiServerTokenPreference,
     pub preloaded: AtomicBool,
-    socket_opts: SocketOpts,
+    pub socket_opts: SocketOpts,
     preexisting_listeners: Option<String>,
 }
 
@@ -178,19 +184,19 @@ impl ServerParams {
     }
 
     fn from_rb_hash(rb_param_hash: RHash) -> Result<ServerParams> {
+        let num_cpus = num_cpus::get_physical() as u8;
         let workers = rb_param_hash
             .fetch::<_, Option<u8>>("workers")?
-            .unwrap_or(num_cpus::get() as u8);
+            .unwrap_or(num_cpus);
         let worker_memory_limit: Option<u64> = rb_param_hash.fetch("worker_memory_limit")?;
         let silence: bool = rb_param_hash.fetch("silence")?;
         let multithreaded_reactor: bool = rb_param_hash
             .fetch::<_, Option<bool>>("multithreaded_reactor")?
-            .unwrap_or(workers == 1);
+            .unwrap_or(workers <= (num_cpus / 3));
         let pin_worker_cores: bool = rb_param_hash
             .fetch::<_, Option<bool>>("pin_worker_cores")?
-            .unwrap_or(true);
+            .unwrap_or(false);
         let shutdown_timeout: f64 = rb_param_hash.fetch("shutdown_timeout")?;
-
         let hooks: Option<RHash> = rb_param_hash.fetch("hooks")?;
         let hooks = hooks
             .map(|rhash| -> Result<HashMap<String, HeapValue<Proc>>> {
@@ -281,6 +287,14 @@ impl ServerParams {
             set_target_filters(target_filters);
         }
 
+        let pipeline_flush: bool = rb_param_hash.fetch("pipeline_flush")?;
+        let writev: Option<bool> = rb_param_hash.fetch("writev")?;
+        let max_concurrent_streams: Option<u32> = rb_param_hash.fetch("max_concurrent_streams")?;
+        let max_local_error_reset_streams: Option<usize> =
+            rb_param_hash.fetch("max_local_error_reset_streams")?;
+        let max_header_list_size: u32 = rb_param_hash.fetch("max_header_list_size")?;
+        let max_send_buf_size: usize = rb_param_hash.fetch("max_send_buf_size")?;
+
         let binds: Option<Vec<String>> = rb_param_hash.fetch("binds")?;
         let binds = binds
             .unwrap_or_else(|| vec![DEFAULT_BIND.to_string()])
@@ -322,6 +336,12 @@ impl ServerParams {
             scheduler_class,
             ruby_thread_request_backlog_size,
             oob_gc_responses_threshold,
+            pipeline_flush,
+            writev,
+            max_concurrent_streams,
+            max_local_error_reset_streams,
+            max_header_list_size,
+            max_send_buf_size,
             binds,
             itsi_server_token_preference,
             socket_opts,
@@ -422,6 +442,10 @@ impl ItsiServerConfig {
         }
     }
 
+    pub fn use_reuse_port_load_balancing(&self) -> bool {
+        cfg!(target_os = "linux") && self.server_params.read().socket_opts.reuse_port
+    }
+
     /// Reload
     pub fn reload(self: Arc<Self>, cluster_worker: bool) -> Result<bool> {
         let server_params = call_with_gvl(|ruby| {
@@ -437,7 +461,8 @@ impl ItsiServerConfig {
         let requires_exec = if !is_single_mode && !server_params.preload {
             // In cluster mode children are cycled during a reload
             // and if preload is disabled, will get a clean memory slate,
-            // so we don't need to exec.
+            // so we don't need to exec. We do need to rebind our listeners here.
+            server_params.setup_listeners()?;
             false
         } else {
             // In non-cluster mode, or when preloading is enabled, we shouldn't try to
@@ -532,6 +557,9 @@ impl ItsiServerConfig {
     }
 
     pub fn dup_fds(self: &Arc<Self>) -> Result<()> {
+        // Ensure the watcher is already stopped before duplicating file descriptors
+        // to prevent race conditions between closing the watcher FD and duplicating socket FDs
+
         let binding = self.server_params.read();
         let mut listener_info_guard = binding.listener_info.lock();
         let dupped_fd_map = listener_info_guard
@@ -557,8 +585,10 @@ impl ItsiServerConfig {
     }
 
     pub fn stop_watcher(self: &Arc<Self>) -> Result<()> {
-        if let Some(r_fd) = self.watcher_fd.as_ref() {
-            close(r_fd.as_raw_fd()).ok();
+        if let Some(pipes) = self.watcher_fd.as_ref() {
+            // Send explicit stop command to the watcher process
+            file_watcher::send_watcher_command(&pipes.write_fd, WatcherCommand::Stop)?;
+            // We don't close the pipes here - they'll be closed when the WatcherPipes is dropped
         }
         Ok(())
     }
@@ -573,8 +603,24 @@ impl ItsiServerConfig {
     pub async fn check_config(&self) -> bool {
         if let Some(errors) = self.get_config_errors().await {
             Self::print_config_errors(errors);
+            // Notify watcher that config check failed
+            if let Some(pipes) = self.watcher_fd.as_ref() {
+                if let Err(e) =
+                    file_watcher::send_watcher_command(&pipes.write_fd, WatcherCommand::ConfigError)
+                {
+                    error!("Failed to notify watcher of config error: {}", e);
+                }
+            }
             return false;
         }
+        // If we reach here, the config is valid
+        if let Some(pipes) = self.watcher_fd.as_ref() {
+            if let Err(e) =
+                file_watcher::send_watcher_command(&pipes.write_fd, WatcherCommand::Continue)
+            {
+                error!("Failed to notify watcher to continue: {}", e);
+            }
+        }
         true
     }
 
@@ -588,7 +634,8 @@ impl ItsiServerConfig {
                     )
                 })?;
 
-        self.stop_watcher()?;
+        // Make sure we're not calling stop_watcher here to avoid double-stopping
+        // The watcher should be stopped earlier in the restart sequence
         call_with_gvl(|ruby| -> Result<()> {
             ruby.get_inner_ref(&ITSI_SERVER_CONFIG)
                 .funcall::<_, _, Value>(*ID_RELOAD_EXEC, (listener_json,))?;

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

@@ -64,7 +64,7 @@ impl ItsiServer {
         Ok(if server_config.server_params.read().workers > 1 {
             ServeStrategy::Cluster(Arc::new(ClusterMode::new(server_config.clone())))
         } else {
-            ServeStrategy::Single(Arc::new(SingleMode::new(server_config.clone())?))
+            ServeStrategy::Single(Arc::new(SingleMode::new(server_config.clone(), 0)?))
         })
     }
 

data/ext/itsi_server/src/server/binds/listener.rs

@@ -9,7 +9,7 @@ use super::bind_protocol::BindProtocol;
 use super::tls::ItsiTlsAcceptor;
 use itsi_error::{ItsiError, Result};
 use itsi_tracing::info;
-use socket2::{Domain, Protocol, Socket, Type};
+use socket2::{Domain, Protocol, SockRef, Socket, Type};
 use std::fmt::Display;
 use std::net::{IpAddr, SocketAddr, TcpListener};
 use std::os::fd::{AsRawFd, FromRawFd, RawFd};
@@ -274,15 +274,53 @@ impl Display for Listener {
 }
 
 impl Listener {
-    pub fn into_tokio_listener(self) -> TokioListener {
+    pub fn rebind_listener(listener: TcpListener) -> TcpListener {
+        let sock = SockRef::from(&listener);
+        let (reuse_address, reuse_port) = (
+            sock.reuse_address().unwrap_or(true),
+            sock.reuse_port().unwrap_or(true),
+        );
+
+        if !reuse_address || !reuse_port {
+            return listener;
+        }
+
+        let (ip, port) = sock
+            .local_addr()
+            .unwrap()
+            .as_socket()
+            .map(|addr| (addr.ip(), addr.port()))
+            .unwrap();
+
+        let socket_opts = SocketOpts {
+            reuse_address: sock.reuse_address().unwrap_or(true), // default: true
+            reuse_port: sock.reuse_port().unwrap_or(false),      // default: false
+            nodelay: sock.nodelay().unwrap_or(false),            // default: false
+            recv_buffer_size: sock.recv_buffer_size().unwrap_or(0),
+            send_buffer_size: sock.send_buffer_size().unwrap_or(0),
+            listen_backlog: 1024, // cannot query – pick sane default
+        };
+
+        connect_tcp_socket(ip, port, &socket_opts).unwrap()
+    }
+
+    pub fn into_tokio_listener(self, should_rebind: bool) -> TokioListener {
         match self {
-            Listener::Tcp(listener) => {
+            Listener::Tcp(mut listener) => {
+                if should_rebind {
+                    listener = Listener::rebind_listener(listener);
+                }
                 TokioListener::Tcp(TokioTcpListener::from_std(listener).unwrap())
             }
-            Listener::TcpTls((listener, acceptor)) => TokioListener::TcpTls(
-                TokioTcpListener::from_std(listener).unwrap(),
-                acceptor.clone(),
-            ),
+            Listener::TcpTls((mut listener, acceptor)) => {
+                if should_rebind {
+                    listener = Listener::rebind_listener(listener);
+                }
+                TokioListener::TcpTls(
+                    TokioTcpListener::from_std(listener).unwrap(),
+                    acceptor.clone(),
+                )
+            }
             Listener::Unix(listener) => {
                 TokioListener::Unix(TokioUnixListener::from_std(listener).unwrap())
             }

data/ext/itsi_server/src/server/frame_stream.rs

@@ -0,0 +1,142 @@
+use bytes::{Bytes, BytesMut};
+use futures::Stream;
+use std::convert::Infallible;
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use std::time::Duration;
+use tokio::sync::mpsc::Receiver;
+use tokio::sync::watch;
+use tokio::time::{sleep, Sleep};
+
+use super::serve_strategy::single_mode::RunningPhase;
+
+#[derive(Debug)]
+pub struct FrameStream {
+    receiver: Receiver<Bytes>,
+    shutdown_rx: watch::Receiver<RunningPhase>,
+    drained: bool,
+}
+
+impl FrameStream {
+    pub fn new(receiver: Receiver<Bytes>, shutdown_rx: watch::Receiver<RunningPhase>) -> Self {
+        Self {
+            receiver,
+            shutdown_rx,
+            drained: false,
+        }
+    }
+}
+
+impl Stream for FrameStream {
+    type Item = Result<Bytes, Infallible>;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let this = self.get_mut();
+
+        if this.drained {
+            return Poll::Ready(None);
+        }
+
+        match Pin::new(&mut this.receiver).poll_recv(cx) {
+            Poll::Ready(Some(bytes)) => Poll::Ready(Some(Ok(bytes))),
+            Poll::Ready(None) => {
+                this.drained = true;
+                Poll::Ready(None)
+            }
+            Poll::Pending => {
+                if this.shutdown_rx.has_changed().unwrap_or(false)
+                    && *this.shutdown_rx.borrow() == RunningPhase::ShutdownPending
+                {
+                    while let Ok(bytes) = this.receiver.try_recv() {
+                        return Poll::Ready(Some(Ok(bytes)));
+                    }
+                    this.drained = true;
+                    return Poll::Ready(None);
+                }
+
+                Poll::Pending
+            }
+        }
+    }
+}
+
+/// BufferedStream wraps a stream of Bytes and coalesces chunks into a larger buffer,
+/// flushing either after `max_flush_bytes` is reached or `max_flush_interval` elapses.
+pub struct BufferedStream<S> {
+    inner: S,
+    buffer: BytesMut,
+    max_flush_bytes: usize,
+    max_flush_interval: Duration,
+    flush_deadline: Option<Pin<Box<Sleep>>>,
+}
+
+impl<S> BufferedStream<S> {
+    pub fn new(inner: S, max_flush_bytes: usize, max_flush_interval: Duration) -> Self {
+        Self {
+            inner,
+            buffer: BytesMut::with_capacity(max_flush_bytes),
+            max_flush_bytes,
+            max_flush_interval,
+            flush_deadline: None,
+        }
+    }
+}
+
+impl<S> Stream for BufferedStream<S>
+where
+    S: Stream<Item = Result<Bytes, Infallible>> + Unpin,
+{
+    type Item = Result<Bytes, Infallible>;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let this = self.get_mut();
+
+        loop {
+            // Flush on timer if needed
+            if let Some(deadline) = &mut this.flush_deadline {
+                if Pin::new(deadline).poll(cx).is_ready() && !this.buffer.is_empty() {
+                    let flushed = this.buffer.split().freeze();
+                    this.flush_deadline = None;
+                    return Poll::Ready(Some(Ok(flushed)));
+                }
+            }
+
+            match Pin::new(&mut this.inner).poll_next(cx) {
+                Poll::Ready(Some(Ok(bytes))) => {
+                    this.buffer.extend_from_slice(&bytes);
+
+                    if bytes.is_empty() || this.buffer.len() >= this.max_flush_bytes {
+                        let flushed = this.buffer.split().freeze();
+                        this.flush_deadline = None;
+                        return Poll::Ready(Some(Ok(flushed)));
+                    }
+
+                    if this.flush_deadline.is_none() {
+                        this.flush_deadline = Some(Box::pin(sleep(this.max_flush_interval)));
+                    }
+                }
+                Poll::Ready(None) => {
+                    if this.buffer.is_empty() {
+                        return Poll::Ready(None);
+                    } else {
+                        let flushed = this.buffer.split().freeze();
+                        this.flush_deadline = None;
+                        return Poll::Ready(Some(Ok(flushed)));
+                    }
+                }
+                Poll::Pending => {
+                    if let Some(deadline) = &mut this.flush_deadline {
+                        let deadline = deadline.as_mut();
+                        if deadline.poll(cx).is_ready() && !this.buffer.is_empty() {
+                            let flushed = this.buffer.split().freeze();
+                            this.flush_deadline = None;
+                            return Poll::Ready(Some(Ok(flushed)));
+                        }
+                    }
+                    return Poll::Pending;
+                }
+            }
+        }
+    }
+}

data/ext/itsi_server/src/server/http_message_types.rs

@@ -1,13 +1,146 @@
-use std::convert::Infallible;
-
 use bytes::Bytes;
-use http::{Request, Response};
-use http_body_util::combinators::BoxBody;
-use hyper::body::Incoming;
+use core::fmt;
+use futures::Stream;
+use futures_util::TryStreamExt;
+use http::Request;
+use http_body_util::{combinators::WithTrailers, BodyExt, Either, Empty, Full, StreamBody};
+use hyper::body::{Body, Frame, Incoming, SizeHint};
+use std::{
+    convert::Infallible,
+    pin::Pin,
+    task::{Context, Poll},
+};
 
 use super::size_limited_incoming::SizeLimitedIncoming;
 
-pub type HttpResponse = Response<BoxBody<Bytes, Infallible>>;
+type Inner = Either<Full<Bytes>, Empty<Bytes>>;
+
+type BoxStream =
+    Pin<Box<dyn Stream<Item = Result<Frame<Bytes>, Infallible>> + Send + Sync + 'static>>;
+
+pub struct PlainBody(Either<StreamBody<BoxStream>, Inner>);
+
+impl fmt::Debug for PlainBody {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self.0 {
+            Either::Left(_) => f.write_str("PlainBody::Stream(..)"),
+            Either::Right(inner) => match inner {
+                Either::Left(full) => f.debug_tuple("PlainBody::Full").field(full).finish(),
+                Either::Right(_) => f.write_str("PlainBody::Empty"),
+            },
+        }
+    }
+}
+type DynErr = Box<dyn std::error::Error + Send + Sync>;
+
+impl Body for PlainBody {
+    type Data = Bytes;
+    type Error = DynErr;
+
+    fn poll_frame(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>> {
+        unsafe { self.map_unchecked_mut(|s| &mut s.0) }.poll_frame(cx)
+    }
+
+    fn size_hint(&self) -> SizeHint {
+        self.0.size_hint()
+    }
+}
+
+impl PlainBody {
+    fn stream<S>(s: S) -> Self
+    where
+        S: Stream<Item = Result<Bytes, Infallible>> + Send + Sync + 'static,
+    {
+        let boxed: BoxStream = Box::pin(s.map_ok(Frame::data));
+        Self(Either::Left(StreamBody::new(boxed)))
+    }
+
+    fn full(bytes: Bytes) -> Self {
+        Self(Either::Right(Either::Left(Full::new(bytes))))
+    }
+
+    fn empty() -> Self {
+        Self(Either::Right(Either::Right(Empty::new())))
+    }
+}
+
+type BoxTrailers = Pin<
+    Box<dyn std::future::Future<Output = Option<Result<http::HeaderMap, DynErr>>> + Send + Sync>,
+>;
+
+pub enum HttpBody {
+    Plain(PlainBody),
+    WithT(WithTrailers<PlainBody, BoxTrailers>),
+}
+
+impl fmt::Debug for HttpBody {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            HttpBody::Plain(b) => f.debug_tuple("HttpBody::Plain").field(b).finish(),
+            HttpBody::WithT(_) => f.write_str("HttpBody::WithT(..)"),
+        }
+    }
+}
+
+impl Body for HttpBody {
+    type Data = Bytes;
+    type Error = DynErr;
+
+    fn poll_frame(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>> {
+        unsafe {
+            match self.get_unchecked_mut() {
+                HttpBody::Plain(b) => Pin::new_unchecked(b).poll_frame(cx),
+                HttpBody::WithT(b) => Pin::new_unchecked(b).poll_frame(cx),
+            }
+        }
+    }
+
+    fn size_hint(&self) -> SizeHint {
+        match self {
+            HttpBody::Plain(b) => b.size_hint(),
+            HttpBody::WithT(b) => b.size_hint(),
+        }
+    }
+}
+
+impl HttpBody {
+    pub fn stream<S>(s: S) -> Self
+    where
+        S: Stream<Item = Result<Bytes, Infallible>> + Send + Sync + 'static,
+    {
+        HttpBody::Plain(PlainBody::stream(s))
+    }
+
+    pub fn full(bytes: Bytes) -> Self {
+        HttpBody::Plain(PlainBody::full(bytes))
+    }
+
+    pub fn empty() -> Self {
+        HttpBody::Plain(PlainBody::empty())
+    }
+
+    pub fn with_trailers<Fut>(self, fut: Fut) -> Self
+    where
+        Fut: std::future::Future<Output = Option<Result<http::HeaderMap, DynErr>>>
+            + Send
+            + Sync
+            + 'static,
+    {
+        let boxed: BoxTrailers = Box::pin(fut);
+        match self {
+            HttpBody::Plain(p) => HttpBody::WithT(p.with_trailers(boxed)),
+            already @ HttpBody::WithT(_) => already,
+        }
+    }
+}
+
+pub type HttpResponse = http::Response<HttpBody>;
 pub type HttpRequest = Request<SizeLimitedIncoming<Incoming>>;
 
 pub trait ConversionExt {
@@ -64,7 +197,7 @@ impl PathExt for str {
         if self == "/" {
             self
         } else {
-            self.trim_end_matches("/")
+            self.trim_end_matches('/')
         }
     }
 }
@@ -91,7 +224,7 @@ impl RequestExt for HttpRequest {
     fn query_param(&self, query_name: &str) -> Option<&str> {
         self.uri()
             .query()
-            .and_then(|query| query.split('&').find(|param| param.starts_with(query_name)))
-            .map(|param| param.split('=').nth(1).unwrap_or(""))
+            .and_then(|q| q.split('&').find(|p| p.starts_with(query_name)))
+            .map(|p| p.split('=').nth(1).unwrap_or(""))
     }
 }

data/ext/itsi_server/src/server/io_stream.rs

@@ -2,6 +2,7 @@ use pin_project::pin_project;
 use tokio::net::{TcpStream, UnixStream};
 use tokio_rustls::server::TlsStream;
 
+use std::io::{self, IoSlice};
 use std::os::unix::io::{AsRawFd, RawFd};
 use std::pin::Pin;
 use std::task::{Context, Poll};
@@ -34,12 +35,12 @@ pub enum IoStream {
 }
 
 impl IoStream {
-    pub fn addr(&self) -> SockAddr {
+    pub fn addr(&self) -> String {
         match self {
-            IoStream::Tcp { addr, .. } => addr.clone(),
-            IoStream::TcpTls { addr, .. } => addr.clone(),
-            IoStream::Unix { addr, .. } => addr.clone(),
-            IoStream::UnixTls { addr, .. } => addr.clone(),
+            IoStream::Tcp { addr, .. } => addr.to_string(),
+            IoStream::TcpTls { addr, .. } => addr.to_string(),
+            IoStream::Unix { addr, .. } => addr.to_string(),
+            IoStream::UnixTls { addr, .. } => addr.to_string(),
         }
     }
 }
@@ -90,6 +91,28 @@ impl AsyncWrite for IoStream {
             IoStreamEnumProj::UnixTls { stream, .. } => stream.poll_shutdown(cx),
         }
     }
+
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        match self.project() {
+            IoStreamEnumProj::Tcp { stream, .. } => stream.poll_write_vectored(cx, bufs),
+            IoStreamEnumProj::TcpTls { stream, .. } => stream.poll_write_vectored(cx, bufs),
+            IoStreamEnumProj::Unix { stream, .. } => stream.poll_write_vectored(cx, bufs),
+            IoStreamEnumProj::UnixTls { stream, .. } => stream.poll_write_vectored(cx, bufs),
+        }
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        match self {
+            IoStream::Tcp { stream, .. } => stream.is_write_vectored(),
+            IoStream::TcpTls { stream, .. } => stream.is_write_vectored(),
+            IoStream::Unix { stream, .. } => stream.is_write_vectored(),
+            IoStream::UnixTls { stream, .. } => stream.is_write_vectored(),
+        }
+    }
 }
 
 impl AsRawFd for IoStream {

data/ext/itsi_server/src/server/lifecycle_event.rs

@@ -1,4 +1,4 @@
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum LifecycleEvent {
     Start,
     Shutdown,

data/ext/itsi_server/src/server/middleware_stack/middlewares/auth_basic.rs

@@ -3,7 +3,6 @@ use base64::{engine::general_purpose, Engine};
 use bytes::Bytes;
 use either::Either;
 use http::{Response, StatusCode};
-use http_body_util::{combinators::BoxBody, Full};
 use magnus::error::Result;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -11,7 +10,7 @@ use std::str;
 use tracing::debug;
 
 use crate::{
-    server::http_message_types::{HttpRequest, HttpResponse, RequestExt},
+    server::http_message_types::{HttpBody, HttpRequest, HttpResponse, RequestExt},
     services::{itsi_http_service::HttpRequestContext, password_hasher::verify_password_hash},
 };
 
@@ -34,7 +33,7 @@ impl AuthBasic {
                 "WWW-Authenticate",
                 format!("Basic realm=\"{}\"", self.realm),
             )
-            .body(BoxBody::new(Full::new(Bytes::from("Unauthorized"))))
+            .body(HttpBody::full(Bytes::from("Unauthorized")))
             .unwrap()
     }
 }