itsi-server 0.2.15 → 0.2.17

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;
@@ -126,12 +126,12 @@ impl ItsiGrpcCall {
         nonblocking: bool,
     ) -> itsi_error::Result<HttpResponse> {
         let (request, mut receiver) = ItsiGrpcCall::new(hyper_request, context).await;
-        let shutdown_channel = context.service.shutdown_channel.clone();
+        let shutdown_channel = context.service.shutdown_receiver.clone();
         let response_stream = request.stream.clone();
         let sender = if nonblocking {
             &context.nonblocking_sender
         } else {
-            &context.sender
+            &context.job_sender
         };
         match sender
             .send(RequestJob::ProcessGrpcRequest(request, app))
@@ -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,36 +182,42 @@ 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_channel.clone();
-                let response = request.response.clone();
+            Ok((request, receiver)) => {
                 let sender = if nonblocking {
                     &context.nonblocking_sender
                 } else {
-                    &context.sender
+                    &context.job_sender
                 };
                 match sender.try_send(RequestJob::ProcessHttpRequest(request, app)) {
                     Err(err) => match err {
-                        async_channel::TrySendError::Full(_) => {
-                            Ok(SERVICE_UNAVAILABLE_RESPONSE
-                                .to_http_response(context.accept.clone())
+                        async_channel::TrySendError::Full(_) => Ok(SERVICE_UNAVAILABLE_RESPONSE
+                            .to_http_response(context.accept)
+                            .await),
+                        async_channel::TrySendError::Closed(_) => {
+                            error!("Channel closed while sending request job");
+                            Ok(INTERNAL_SERVER_ERROR_RESPONSE
+                                .to_http_response(context.accept)
                                 .await)
                         }
-                        async_channel::TrySendError::Closed(err) => {
-                            error!("Error occurred: {:?}", err);
+                    },
+                    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.clone())
+                                .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),
-                    },
                 }
             }
             Err(err_resp) => Ok(err_resp),
@@ -219,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();
@@ -230,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;
                         }
@@ -240,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,
         ))
     }
 
@@ -309,7 +331,7 @@ impl ItsiHttpRequest {
             .parts
             .uri
             .host()
-            .unwrap_or_else(|| &self.context.listener.host))
+            .unwrap_or_else(|| &self.context.listener_info.host))
     }
 
     pub(crate) fn scheme(&self) -> MagnusResult<&str> {
@@ -318,7 +340,7 @@ impl ItsiHttpRequest {
             .uri
             .scheme()
             .map(|scheme| scheme.as_str())
-            .unwrap_or_else(|| &self.context.listener.scheme))
+            .unwrap_or_else(|| &self.context.listener_info.scheme))
     }
 
     pub(crate) fn headers(&self) -> MagnusResult<Vec<(&str, &str)>> {
@@ -330,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())
     }
@@ -354,7 +383,7 @@ impl ItsiHttpRequest {
             .parts
             .uri
             .port_u16()
-            .unwrap_or(self.context.listener.port))
+            .unwrap_or(self.context.listener_info.port))
     }
 
     pub(crate) fn body(&self) -> MagnusResult<Option<Value>> {