itsi-server 0.2.16 → 0.2.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dacff69074fbea9c3b26f533549c9f1b8cf2bb369f8ef15346180fbfac81b4e6
-  data.tar.gz: cd0d38e8ac1be9114281d7a28ab1ea5d6d9394dff87b7a17c7fb259eee0a1dbe
+  metadata.gz: b8c75e7602b936f8ca0140844efef4617149bcd9228826e93cecec3673cba14e
+  data.tar.gz: ec9f4ba2c83ab3a0e6683ca7cce2e029f0c62224db9ba3a058caffc30be01504
 SHA512:
-  metadata.gz: 5464271b5aa30ba1c02addbd365fc1a7891b357dbb2ef4c02f5f9b26048714c77011ba60a2a82abc2da843bb3e7dbe253105b4ae0e49eeea12b028a2cf6f0cef
-  data.tar.gz: 88ecd2101bfc629d0d198c14877f9dfdc6cb104a6978712f2f16c3dfb3cc00fa4aeb4cf4e164884af90e175c879b501565c973549c8189e9e5a5a991df1e87bb
+  metadata.gz: 9d2f60a69e5cf77986802f15c6168b27a74525fbfa2a8470e9fc28ab3e4f9ff7481ec372099298edb474ab9e7e5da555e6b295422ba3b2e2529cb83ff6a38ff4
+  data.tar.gz: 8c833ed1c2da13fd48b5895d334bd548bd651218ec9be952190f45b2b455745240276e090e5a5a621155e73cb8e39a9859437412af04741d7d8cb357e2a0da28

data/Cargo.lock

@@ -1644,7 +1644,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "itsi-server"
-version = "0.2.16"
+version = "0.2.17"
 dependencies = [
  "argon2",
  "async-channel",
@@ -1660,6 +1660,7 @@ dependencies = [
  "either",
  "fs2",
  "futures",
+ "futures-util",
  "globset",
  "http 1.3.1",
  "http-body-util",
@@ -1695,6 +1696,7 @@ dependencies = [
  "serde_magnus",
  "sha-crypt",
  "sha2",
+ "smallvec",
  "socket2",
  "sysinfo",
  "tempfile",

data/exe/itsi

@@ -164,7 +164,12 @@ if ENV['COMP_LINE'] || ARGV.include?('--completion')
   exit
 end
 
-parser.parse!
+begin
+  parser.parse!
+rescue StandardError => e
+  puts e.message
+  exit
+end
 
 case (command = ARGV.shift)
 when *COMMANDS.keys

data/ext/itsi_acme/Cargo.toml

@@ -2,7 +2,7 @@
 name = "itsi_acme"
 version = "0.1.0"
 authors = [
-  "wouterkem <wc@pico.net.nz>",
+  "wouterken <wc@pico.net.nz>",
   "dignifiedquire <me@dignifiedquire.com>",
   "Florian Uekermann <florian@uekermann.me>",
 ]

data/ext/itsi_scheduler/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "itsi-scheduler"
-version = "0.2.16"
+version = "0.2.17"
 edition = "2021"
 authors = ["Wouter Coppieters <wc@pico.net.nz>"]
 license = "MIT"

data/ext/itsi_server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "itsi-server"
-version = "0.2.16"
+version = "0.2.17"
 edition = "2021"
 authors = ["Wouter Coppieters <wc@pico.net.nz>"]
 license = "MIT"
@@ -90,3 +90,5 @@ argon2 = "0.5.3"
 core_affinity = "0.8.3"
 memchr = "2.7.4"
 quick_cache = "0.6.13"
+smallvec = "1.15.0"
+futures-util = "0.3.31"

data/ext/itsi_server/src/lib.rs

@@ -58,6 +58,7 @@ fn init(ruby: &Ruby) -> Result<()> {
     request.define_method("rack_protocol", method!(ItsiHttpRequest::rack_protocol, 0))?;
     request.define_method("host", method!(ItsiHttpRequest::host, 0))?;
     request.define_method("headers", method!(ItsiHttpRequest::headers, 0))?;
+    request.define_method("each_header", method!(ItsiHttpRequest::each_header, 0))?;
     request.define_method("uri", method!(ItsiHttpRequest::uri, 0))?;
     request.define_method("header", method!(ItsiHttpRequest::header, 1))?;
     request.define_method("[]", method!(ItsiHttpRequest::header, 1))?;
@@ -71,6 +72,7 @@ fn init(ruby: &Ruby) -> Result<()> {
     request.define_method("url_encoded?", method!(ItsiHttpRequest::is_url_encoded, 0))?;
     request.define_method("multipart?", method!(ItsiHttpRequest::is_multipart, 0))?;
     request.define_method("url_params", method!(ItsiHttpRequest::url_params, 0))?;
+    request.define_method("server_error", method!(ItsiHttpRequest::error, 1))?;
 
     let body_proxy = ruby.get_inner(&ITSI_BODY_PROXY);
     body_proxy.define_method("gets", method!(ItsiBodyProxy::gets, 0))?;
@@ -80,6 +82,10 @@ fn init(ruby: &Ruby) -> Result<()> {
 
     let response = ruby.get_inner(&ITSI_RESPONSE);
     response.define_method("[]=", method!(ItsiHttpResponse::add_header, 2))?;
+    response.define_method(
+        "reserve_headers",
+        method!(ItsiHttpResponse::reserve_headers, 1),
+    )?;
     response.define_method("add_header", method!(ItsiHttpResponse::add_header, 2))?;
     response.define_method("add_headers", method!(ItsiHttpResponse::add_headers, 1))?;
     response.define_method("status=", method!(ItsiHttpResponse::set_status, 1))?;
@@ -87,7 +93,6 @@ fn init(ruby: &Ruby) -> Result<()> {
     response.define_method("<<", method!(ItsiHttpResponse::send_frame, 1))?;
     response.define_method("write", method!(ItsiHttpResponse::send_frame, 1))?;
     response.define_method("read", method!(ItsiHttpResponse::recv_frame, 0))?;
-    response.define_method("flush", method!(ItsiHttpResponse::flush, 0))?;
     response.define_method("closed?", method!(ItsiHttpResponse::is_closed, 0))?;
     response.define_method(
         "send_and_close",

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

@@ -25,6 +25,7 @@ pub struct ItsiBodyProxy {
 pub enum ItsiBody {
     Buffered(BigBytes),
     Stream(ItsiBodyProxy),
+    Empty,
 }
 
 impl ItsiBody {
@@ -32,6 +33,7 @@ impl ItsiBody {
         match self {
             ItsiBody::Buffered(bytes) => bytes.as_value(),
             ItsiBody::Stream(proxy) => Some(proxy.clone().into_value()),
+            ItsiBody::Empty => None,
         }
     }
 }

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

@@ -1,6 +1,6 @@
 use super::itsi_grpc_response_stream::ItsiGrpcResponseStream;
 use crate::prelude::*;
-use crate::server::http_message_types::{HttpRequest, HttpResponse};
+use crate::server::http_message_types::{HttpBody, HttpRequest, HttpResponse};
 use crate::server::{byte_frame::ByteFrame, request_job::RequestJob};
 use crate::services::itsi_http_service::HttpRequestContext;
 use async_compression::futures::bufread::{GzipDecoder, GzipEncoder, ZlibDecoder, ZlibEncoder};
@@ -8,7 +8,7 @@ use bytes::Bytes;
 use derive_more::Debug;
 use futures::{executor::block_on, io::Cursor, AsyncReadExt};
 use http::{request::Parts, Response, StatusCode};
-use http_body_util::{combinators::BoxBody, BodyExt, Empty};
+use http_body_util::BodyExt;
 use itsi_error::CLIENT_CONNECTION_CLOSED;
 use itsi_rb_helpers::{print_rb_backtrace, HeapValue};
 use itsi_tracing::debug;
@@ -139,7 +139,7 @@ impl ItsiGrpcCall {
         {
             Err(err) => {
                 error!("Error occurred: {}", err);
-                let mut response = Response::new(BoxBody::new(Empty::new()));
+                let mut response = Response::new(HttpBody::empty());
                 *response.status_mut() = StatusCode::BAD_REQUEST;
                 Ok(response)
             }
@@ -147,7 +147,7 @@ impl ItsiGrpcCall {
                 Some(first_frame) => Ok(response_stream
                     .build_response(first_frame, receiver, shutdown_channel)
                     .await),
-                None => Ok(Response::new(BoxBody::new(Empty::new()))),
+                None => Ok(Response::new(HttpBody::empty())),
             },
         }
     }

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

@@ -1,6 +1,6 @@
 use super::itsi_grpc_call::CompressionAlgorithm;
 use crate::prelude::*;
-use crate::server::http_message_types::HttpResponse;
+use crate::server::http_message_types::{HttpBody, HttpResponse};
 use crate::server::size_limited_incoming::SizeLimitedIncoming;
 use crate::server::{byte_frame::ByteFrame, serve_strategy::single_mode::RunningPhase};
 use bytes::Bytes;
@@ -11,8 +11,8 @@ use http::{
     header::{HeaderName, HeaderValue},
     HeaderMap, Response,
 };
-use http_body_util::{combinators::BoxBody, BodyDataStream, BodyExt, Empty, Full, StreamBody};
-use hyper::body::{Frame, Incoming};
+use http_body_util::BodyDataStream;
+use hyper::body::Incoming;
 use magnus::error::Result as MagnusResult;
 use nix::unistd::pipe;
 use parking_lot::Mutex;
@@ -161,7 +161,7 @@ impl ItsiGrpcResponseStream {
                 response_headers,
                 incoming_reader: Some(pipe_read),
                 response_sender,
-                response: Some(Response::new(BoxBody::new(Empty::new()))),
+                response: Some(Response::new(HttpBody::empty())),
                 trailer_tx,
                 trailer_rx: Some(trailer_rx),
             })),
@@ -207,12 +207,12 @@ impl ItsiGrpcResponseStream {
         let rx = self.inner.lock().trailer_rx.take().unwrap();
         *response.version_mut() = Version::HTTP_2;
         *response.headers_mut() = self.inner.lock().response_headers.clone();
-        *response.body_mut() = if matches!(first_frame, ByteFrame::Empty) {
-            BoxBody::new(Empty::new())
+        let body_with_trailers = if matches!(first_frame, ByteFrame::Empty) {
+            HttpBody::empty()
         } else if matches!(first_frame, ByteFrame::End(_)) {
-            BoxBody::new(Full::new(first_frame.into()))
+            HttpBody::full(first_frame.into())
         } else {
-            let initial_frame = tokio_stream::once(Ok(Frame::data(Bytes::from(first_frame))));
+            let initial_frame = tokio_stream::once(Ok(Bytes::from(first_frame)));
             let frame_stream = unfold(
                 (ReceiverStream::new(receiver), shutdown_rx),
                 |(mut receiver, mut shutdown_rx)| async move {
@@ -224,7 +224,7 @@ impl ItsiGrpcResponseStream {
                             maybe_bytes = receiver.next() => {
                               match maybe_bytes {
                                 Some(ByteFrame::Data(bytes)) | Some(ByteFrame::End(bytes)) => {
-                                  return Some((Ok(Frame::data(bytes)), (receiver, shutdown_rx)));
+                                  return Some((Ok(bytes), (receiver, shutdown_rx)));
                                 }
                                 _ => {
                                   return None;
@@ -234,7 +234,7 @@ impl ItsiGrpcResponseStream {
                             _ = shutdown_rx.changed() => {
                                 match *shutdown_rx.borrow() {
                                     RunningPhase::ShutdownPending => {
-                                        warn!("Disconnecting streaming client.");
+                                        debug!("Disconnecting streaming client.");
                                         return None;
                                     },
                                     _ => continue,
@@ -246,15 +246,16 @@ impl ItsiGrpcResponseStream {
             );
 
             let combined_stream = initial_frame.chain(frame_stream);
-            BoxBody::new(StreamBody::new(combined_stream))
+            HttpBody::stream(combined_stream)
         }
         .with_trailers(async move {
             match rx.await {
                 Ok(trailers) => Some(Ok(trailers)),
                 Err(_err) => None,
             }
-        })
-        .boxed();
+        });
+
+        *response.body_mut() = body_with_trailers;
         response
     }
 

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

@@ -1,31 +1,30 @@
 use derive_more::Debug;
 use futures::StreamExt;
-use http::{header::CONTENT_LENGTH, request::Parts, Response, StatusCode, Version};
-use http_body_util::{combinators::BoxBody, BodyExt, Empty};
+use http::{header::CONTENT_LENGTH, request::Parts, HeaderValue, Response, StatusCode, Version};
+use http_body_util::BodyExt;
 use itsi_error::CLIENT_CONNECTION_CLOSED;
-use itsi_rb_helpers::{print_rb_backtrace, HeapValue};
-use itsi_tracing::{debug, error};
+use itsi_rb_helpers::{funcall_no_ret, print_rb_backtrace, HeapValue};
+use itsi_tracing::debug;
 use magnus::{
-    block::Proc,
+    block::{yield_values, Proc},
     error::{ErrorType, Result as MagnusResult},
-    Error, RHash, Symbol,
+    Error, IntoValue, RHash, Symbol,
 };
 use magnus::{
     value::{LazyId, ReprValue},
     Ruby, Value,
 };
 use std::{fmt, io::Write, sync::Arc, time::Instant};
-use tokio::sync::mpsc::{self};
+use tracing::error;
 
 use super::{
     itsi_body_proxy::{big_bytes::BigBytes, ItsiBody, ItsiBodyProxy},
-    itsi_http_response::ItsiHttpResponse,
+    itsi_http_response::{ItsiHttpResponse, ResponseFrame},
 };
 use crate::{
     default_responses::{INTERNAL_SERVER_ERROR_RESPONSE, SERVICE_UNAVAILABLE_RESPONSE},
     server::{
-        byte_frame::ByteFrame,
-        http_message_types::{HttpRequest, HttpResponse},
+        http_message_types::{HttpBody, HttpRequest, HttpResponse},
         request_job::RequestJob,
         size_limited_incoming::MaxBodySizeReached,
     },
@@ -33,11 +32,13 @@ use crate::{
 };
 
 static ID_MESSAGE: LazyId = LazyId::new("message");
+static ID_CALL: LazyId = LazyId::new("call");
+static ZERO_HEADER_VALUE: HeaderValue = HeaderValue::from_static("0");
 
 #[derive(Debug)]
 #[magnus::wrap(class = "Itsi::HttpRequest", free_immediately, size)]
 pub struct ItsiHttpRequest {
-    pub parts: Parts,
+    pub parts: Arc<Parts>,
     #[debug(skip)]
     pub body: ItsiBody,
     pub version: Version,
@@ -148,8 +149,10 @@ impl ItsiHttpRequest {
 
     pub fn process(self, ruby: &Ruby, app_proc: Arc<HeapValue<Proc>>) -> magnus::error::Result<()> {
         let response = self.response.clone();
-        let result = app_proc.call::<_, Value>((self,));
-        if let Err(err) = result {
+
+        if let Err(err) =
+            funcall_no_ret(app_proc.as_value(), *ID_CALL, [self.into_value_with(ruby)])
+        {
             Self::internal_error(ruby, response, err);
         }
         Ok(())
@@ -158,7 +161,7 @@ impl ItsiHttpRequest {
     pub fn internal_error(ruby: &Ruby, response: ItsiHttpResponse, err: Error) {
         if Self::is_connection_closed_err(ruby, &err) {
             debug!("Connection closed by client");
-            response.close();
+            response.close().ok();
         } else if let Some(rb_err) = err.value() {
             print_rb_backtrace(rb_err);
             response.internal_server_error(err.to_string());
@@ -167,7 +170,7 @@ impl ItsiHttpRequest {
         }
     }
 
-    pub fn error(self, message: String) {
+    pub fn error(&self, message: String) {
         self.response.internal_server_error(message);
     }
 
@@ -179,9 +182,7 @@ impl ItsiHttpRequest {
         nonblocking: bool,
     ) -> itsi_error::Result<HttpResponse> {
         match ItsiHttpRequest::new(hyper_request, context, script_name).await {
-            Ok((request, mut receiver)) => {
-                let shutdown_channel = context.service.shutdown_receiver.clone();
-                let response = request.response.clone();
+            Ok((request, receiver)) => {
                 let sender = if nonblocking {
                     &context.nonblocking_sender
                 } else {
@@ -192,20 +193,30 @@ impl ItsiHttpRequest {
                         async_channel::TrySendError::Full(_) => Ok(SERVICE_UNAVAILABLE_RESPONSE
                             .to_http_response(context.accept)
                             .await),
-                        async_channel::TrySendError::Closed(err) => {
-                            error!("Error occurred: {:?}", err);
+                        async_channel::TrySendError::Closed(_) => {
+                            error!("Channel closed while sending request job");
                             Ok(INTERNAL_SERVER_ERROR_RESPONSE
                                 .to_http_response(context.accept)
                                 .await)
                         }
                     },
-                    _ => match receiver.recv().await {
-                        Some(first_frame) => Ok(response
-                            .build(first_frame, receiver, shutdown_channel)
-                            .await),
-                        None => Ok(response
-                            .build(ByteFrame::Empty, receiver, shutdown_channel)
-                            .await),
+                    Ok(_) => match receiver.await {
+                        Ok(ResponseFrame::HttpResponse(response)) => Ok(response),
+                        Ok(ResponseFrame::HijackedResponse(response)) => {
+                            match response.process_hijacked_response().await {
+                                Ok(result) => Ok(result),
+                                Err(e) => {
+                                    error!("Error processing hijacked response: {}", e);
+                                    Ok(Response::new(HttpBody::empty()))
+                                }
+                            }
+                        }
+                        Err(_) => {
+                            error!("Failed to receive response from receiver");
+                            Ok(INTERNAL_SERVER_ERROR_RESPONSE
+                                .to_http_response(context.accept)
+                                .await)
+                        }
                     },
                 }
             }
@@ -217,9 +228,18 @@ impl ItsiHttpRequest {
         request: HttpRequest,
         context: &HttpRequestContext,
         script_name: String,
-    ) -> Result<(ItsiHttpRequest, mpsc::Receiver<ByteFrame>), HttpResponse> {
+    ) -> Result<
+        (
+            ItsiHttpRequest,
+            tokio::sync::oneshot::Receiver<ResponseFrame>,
+        ),
+        HttpResponse,
+    > {
         let (parts, body) = request.into_parts();
-        let body = if context.server_params.streamable_body {
+        let parts = Arc::new(parts);
+        let body = if parts.headers.get(CONTENT_LENGTH) == Some(&ZERO_HEADER_VALUE) {
+            ItsiBody::Empty
+        } else if context.server_params.streamable_body {
             ItsiBody::Stream(ItsiBodyProxy::new(body))
         } else {
             let mut body_bytes = BigBytes::new();
@@ -228,7 +248,7 @@ impl ItsiHttpRequest {
                 match chunk {
                     Ok(byte_array) => body_bytes.write_all(&byte_array).unwrap(),
                     Err(e) => {
-                        let mut err_resp = Response::new(BoxBody::new(Empty::new()));
+                        let mut err_resp = Response::new(HttpBody::empty());
                         if e.downcast_ref::<MaxBodySizeReached>().is_some() {
                             *err_resp.status_mut() = StatusCode::PAYLOAD_TOO_LARGE;
                         }
@@ -238,18 +258,22 @@ impl ItsiHttpRequest {
             }
             ItsiBody::Buffered(body_bytes)
         };
-        let response_channel = mpsc::channel::<ByteFrame>(100);
+        let (sender, receiver) = tokio::sync::oneshot::channel::<ResponseFrame>();
         Ok((
             Self {
                 context: context.clone(),
                 version: parts.version,
-                response: ItsiHttpResponse::new(parts.clone(), response_channel.0),
+                response: ItsiHttpResponse::new(
+                    parts.clone(),
+                    sender,
+                    context.service.shutdown_receiver.clone(),
+                ),
                 start: Instant::now(),
                 script_name,
                 body,
                 parts,
             },
-            response_channel.1,
+            receiver,
         ))
     }
 
@@ -328,6 +352,13 @@ impl ItsiHttpRequest {
             .collect::<Vec<(&str, &str)>>())
     }
 
+    pub(crate) fn each_header(&self) -> MagnusResult<()> {
+        self.parts.headers.iter().for_each(|(hn, hv)| {
+            yield_values::<_, Value>((hn.as_str(), hv.to_str().unwrap_or(""))).ok();
+        });
+        Ok(())
+    }
+
     pub(crate) fn uri(&self) -> MagnusResult<String> {
         Ok(self.parts.uri.to_string())
     }