itsi 0.1.11 → 0.1.12

data/{gems/server/ext/itsi_server/src/request/itsi_request.rs → crates/itsi_server/src/ruby_types/itsi_http_request.rs}

@@ -1,58 +1,49 @@
-use crate::{
-    body_proxy::{
-        big_bytes::BigBytes,
-        itsi_body_proxy::{ItsiBody, ItsiBodyProxy},
-    },
-    response::itsi_response::ItsiResponse,
-    server::{
-        itsi_server::{RequestJob, Server},
-        listener::{ListenerInfo, SockAddr},
-        serve_strategy::single_mode::RunningPhase,
-    },
-};
-use bytes::Bytes;
 use derive_more::Debug;
 use futures::StreamExt;
-use http::{request::Parts, HeaderValue, Response, StatusCode};
+use http::{request::Parts, Response, StatusCode, Version};
 use http_body_util::{combinators::BoxBody, BodyExt, Empty};
-use hyper::{body::Incoming, Request};
 use itsi_error::from::CLIENT_CONNECTION_CLOSED;
-use itsi_rb_helpers::print_rb_backtrace;
+use itsi_rb_helpers::{print_rb_backtrace, HeapValue};
 use itsi_tracing::{debug, error};
 use magnus::{
+    block::Proc,
     error::{ErrorType, Result as MagnusResult},
     Error,
 };
 use magnus::{
-    value::{LazyId, Opaque, ReprValue},
-    RClass, Ruby, Value,
+    value::{LazyId, ReprValue},
+    Ruby, Value,
+};
+use std::{fmt, io::Write, sync::Arc, time::Instant};
+use tokio::sync::mpsc::{self};
+
+use super::{
+    itsi_body_proxy::{big_bytes::BigBytes, ItsiBody, ItsiBodyProxy},
+    itsi_http_response::ItsiHttpResponse,
 };
-use std::{convert::Infallible, fmt, io::Write, sync::Arc, time::Instant};
-use tokio::sync::{
-    mpsc::{self},
-    watch,
+use crate::server::{
+    byte_frame::ByteFrame,
+    itsi_service::RequestContext,
+    request_job::RequestJob,
+    types::{HttpRequest, HttpResponse},
 };
-static ID_CALL: LazyId = LazyId::new("call");
+
 static ID_MESSAGE: LazyId = LazyId::new("message");
 
 #[derive(Debug)]
-#[magnus::wrap(class = "Itsi::Request", free_immediately, size)]
-pub struct ItsiRequest {
+#[magnus::wrap(class = "Itsi::HttpRequest", free_immediately, size)]
+pub struct ItsiHttpRequest {
     pub parts: Parts,
     #[debug(skip)]
     pub body: ItsiBody,
-    pub remote_addr: String,
-    pub version: String,
-    #[debug(skip)]
-    pub(crate) listener: Arc<ListenerInfo>,
-    #[debug(skip)]
-    pub server: Arc<Server>,
-    pub response: ItsiResponse,
+    pub version: Version,
+    pub response: ItsiHttpResponse,
     pub start: Instant,
-    pub content_type: String,
+    #[debug(skip)]
+    pub context: RequestContext,
 }
 
-impl fmt::Display for ItsiRequest {
+impl fmt::Display for ItsiHttpRequest {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
             f,
@@ -64,7 +55,7 @@ impl fmt::Display for ItsiRequest {
     }
 }
 
-impl ItsiRequest {
+impl ItsiHttpRequest {
     pub fn is_connection_closed_err(ruby: &Ruby, err: &Error) -> bool {
         match err.error_type() {
             ErrorType::Jump(_) => false,
@@ -82,35 +73,32 @@ impl ItsiRequest {
             }
         }
     }
+    fn content_type_str(&self) -> &str {
+        self.parts
+            .headers
+            .get("Content-Type")
+            .and_then(|hv| hv.to_str().ok())
+            .unwrap_or("application/x-www-form-urlencoded")
+    }
 
     pub fn is_json(&self) -> bool {
-        self.content_type.eq("application/json")
+        self.content_type_str() == "application/json"
     }
 
     pub fn is_html(&self) -> bool {
-        self.content_type.eq("text/html")
+        self.content_type_str() == "text/html"
     }
 
-    pub fn process(
-        self,
-        ruby: &Ruby,
-        server: RClass,
-        app: Opaque<Value>,
-    ) -> magnus::error::Result<()> {
-        let req = format!("{}", self);
+    pub fn process(self, ruby: &Ruby, app_proc: Arc<HeapValue<Proc>>) -> magnus::error::Result<()> {
         let response = self.response.clone();
-        let start = self.start;
-        debug!("{} Started", req);
-        let result = server.funcall::<_, _, Value>(*ID_CALL, (app, self));
+        let result = app_proc.call::<_, Value>((self,));
         if let Err(err) = result {
             Self::internal_error(ruby, response, err);
         }
-        debug!("{} Finished in {:?}", req, start.elapsed());
-
         Ok(())
     }
 
-    pub fn internal_error(ruby: &Ruby, response: ItsiResponse, err: Error) {
+    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();
@@ -127,17 +115,18 @@ impl ItsiRequest {
     }
 
     pub(crate) async fn process_request(
-        hyper_request: Request<Incoming>,
-        sender: async_channel::Sender<RequestJob>,
-        server: Arc<Server>,
-        listener: Arc<ListenerInfo>,
-        addr: SockAddr,
-        shutdown_rx: watch::Receiver<RunningPhase>,
-    ) -> itsi_error::Result<Response<BoxBody<Bytes, Infallible>>> {
-        let (request, mut receiver) = ItsiRequest::new(hyper_request, addr, server, listener).await;
-
+        app: Arc<HeapValue<Proc>>,
+        hyper_request: HttpRequest,
+        context: &RequestContext,
+    ) -> itsi_error::Result<HttpResponse> {
+        let (request, mut receiver) = ItsiHttpRequest::new(hyper_request, context).await;
+        let shutdown_channel = context.service.shutdown_channel.clone();
         let response = request.response.clone();
-        match sender.send(RequestJob::ProcessRequest(request)).await {
+        match context
+            .sender
+            .send(RequestJob::ProcessHttpRequest(request, app))
+            .await
+        {
             Err(err) => {
                 error!("Error occurred: {}", err);
                 let mut response = Response::new(BoxBody::new(Empty::new()));
@@ -145,20 +134,22 @@ impl ItsiRequest {
                 Ok(response)
             }
             _ => match receiver.recv().await {
-                Some(first_frame) => Ok(response.build(first_frame, receiver, shutdown_rx).await),
-                None => Ok(response.build(None, receiver, shutdown_rx).await),
+                Some(first_frame) => Ok(response
+                    .build(first_frame, receiver, shutdown_channel)
+                    .await),
+                None => Ok(response
+                    .build(ByteFrame::Empty, receiver, shutdown_channel)
+                    .await),
             },
         }
     }
 
     pub(crate) async fn new(
-        request: Request<Incoming>,
-        sock_addr: SockAddr,
-        server: Arc<Server>,
-        listener: Arc<ListenerInfo>,
-    ) -> (ItsiRequest, mpsc::Receiver<Option<Bytes>>) {
+        request: HttpRequest,
+        context: &RequestContext,
+    ) -> (ItsiHttpRequest, mpsc::Receiver<ByteFrame>) {
         let (parts, body) = request.into_parts();
-        let body = if server.stream_body.is_some_and(|f| f) {
+        let body = if context.server_params.streamable_body {
             ItsiBody::Stream(ItsiBodyProxy::new(body))
         } else {
             let mut body_bytes = BigBytes::new();
@@ -169,35 +160,14 @@ impl ItsiRequest {
             }
             ItsiBody::Buffered(body_bytes)
         };
-        let response_channel = mpsc::channel::<Option<Bytes>>(100);
+        let response_channel = mpsc::channel::<ByteFrame>(100);
         (
             Self {
-                remote_addr: sock_addr.to_string(),
-                body,
-                server,
-                listener,
-                version: format!("{:?}", &parts.version),
-                response: ItsiResponse::new(
-                    parts.clone(),
-                    response_channel.0,
-                    parts
-                        .headers
-                        .get("Accept")
-                        .unwrap_or(&HeaderValue::from_static("text/html"))
-                        .to_str()
-                        .unwrap()
-                        .to_string(),
-                ),
+                context: context.clone(),
+                version: parts.version,
+                response: ItsiHttpResponse::new(parts.clone(), response_channel.0),
                 start: Instant::now(),
-                content_type: parts
-                    .headers
-                    .get("Content-Type")
-                    .unwrap_or(&HeaderValue::from_static(
-                        "application/x-www-form-urlencoded",
-                    ))
-                    .to_str()
-                    .unwrap()
-                    .to_string(),
+                body,
                 parts,
             },
             response_channel.1,
@@ -209,12 +179,12 @@ impl ItsiRequest {
             .parts
             .uri
             .path()
-            .strip_prefix(&self.server.script_name)
+            .strip_prefix(&self.context.server_params.script_name)
             .unwrap_or(self.parts.uri.path()))
     }
 
     pub(crate) fn script_name(&self) -> MagnusResult<&str> {
-        Ok(&self.server.script_name)
+        Ok(&self.context.server_params.script_name)
     }
 
     pub(crate) fn query_string(&self) -> MagnusResult<&str> {
@@ -226,7 +196,14 @@ impl ItsiRequest {
     }
 
     pub(crate) fn version(&self) -> MagnusResult<&str> {
-        Ok(&self.version)
+        Ok(match self.version {
+            Version::HTTP_09 => "HTTP/0.9",
+            Version::HTTP_10 => "HTTP/1.0",
+            Version::HTTP_11 => "HTTP/1.1",
+            Version::HTTP_2 => "HTTP/2.0",
+            Version::HTTP_3 => "HTTP/3.0",
+            _ => "HTTP/Unknown",
+        })
     }
 
     pub(crate) fn rack_protocol(&self) -> MagnusResult<Vec<&str>> {
@@ -246,53 +223,60 @@ impl ItsiRequest {
             .unwrap_or_else(|| vec!["http"]))
     }
 
-    pub(crate) fn host(&self) -> MagnusResult<String> {
+    pub(crate) fn host(&self) -> MagnusResult<&str> {
         Ok(self
             .parts
             .uri
             .host()
-            .map(|host| host.to_string())
-            .unwrap_or_else(|| self.listener.host.clone()))
+            .unwrap_or_else(|| &self.context.listener.host))
     }
 
-    pub(crate) fn scheme(&self) -> MagnusResult<String> {
+    pub(crate) fn scheme(&self) -> MagnusResult<&str> {
         Ok(self
             .parts
             .uri
             .scheme()
-            .map(|scheme| scheme.to_string())
-            .unwrap_or_else(|| self.listener.scheme.clone()))
+            .map(|scheme| scheme.as_str())
+            .unwrap_or_else(|| &self.context.listener.scheme))
     }
 
-    pub(crate) fn headers(&self) -> MagnusResult<Vec<(String, &str)>> {
+    pub(crate) fn headers(&self) -> MagnusResult<Vec<(&str, &str)>> {
         Ok(self
             .parts
             .headers
             .iter()
-            .map(|(hn, hv)| {
-                let key = match hn.as_str() {
-                    "content-length" => "CONTENT_LENGTH".to_string(),
-                    "content-type" => "CONTENT_TYPE".to_string(),
-                    _ => format!("HTTP_{}", hn.as_str().to_uppercase().replace("-", "_")),
-                };
-                (key, hv.to_str().unwrap_or(""))
-            })
-            .collect())
+            .map(|(hn, hv)| (hn.as_str(), hv.to_str().unwrap_or("")))
+            .collect::<Vec<(&str, &str)>>())
+    }
+
+    pub fn header(&self, name: String) -> MagnusResult<Option<Vec<&str>>> {
+        let result: Vec<&str> = self
+            .parts
+            .headers
+            .get_all(&name)
+            .iter()
+            .filter_map(|value| value.to_str().ok())
+            .collect();
+        Ok(Some(result))
     }
 
     pub(crate) fn remote_addr(&self) -> MagnusResult<&str> {
-        Ok(&self.remote_addr)
+        Ok(&self.context.addr)
     }
 
     pub(crate) fn port(&self) -> MagnusResult<u16> {
-        Ok(self.parts.uri.port_u16().unwrap_or(self.listener.port))
+        Ok(self
+            .parts
+            .uri
+            .port_u16()
+            .unwrap_or(self.context.listener.port))
     }
 
-    pub(crate) fn body(&self) -> MagnusResult<Value> {
+    pub(crate) fn body(&self) -> MagnusResult<Option<Value>> {
         Ok(self.body.into_value())
     }
 
-    pub(crate) fn response(&self) -> MagnusResult<ItsiResponse> {
+    pub(crate) fn response(&self) -> MagnusResult<ItsiHttpResponse> {
         Ok(self.response.clone())
     }
 }

data/crates/itsi_server/src/{response/itsi_response.rs → ruby_types/itsi_http_response.rs}

@@ -13,7 +13,7 @@ use itsi_tracing::error;
 use magnus::error::Result as MagnusResult;
 use parking_lot::RwLock;
 use std::{
-    convert::Infallible,
+    collections::HashMap,
     io,
     os::{fd::FromRawFd, unix::net::UnixStream},
     str::FromStr,
@@ -31,31 +31,32 @@ use tokio_stream::wrappers::ReceiverStream;
 use tokio_util::io::ReaderStream;
 use tracing::warn;
 
-use crate::server::serve_strategy::single_mode::RunningPhase;
+use crate::server::{
+    byte_frame::ByteFrame, serve_strategy::single_mode::RunningPhase, types::HttpResponse,
+};
 
-#[magnus::wrap(class = "Itsi::Response", free_immediately, size)]
+#[magnus::wrap(class = "Itsi::HttpResponse", free_immediately, size)]
 #[derive(Debug, Clone)]
-pub struct ItsiResponse {
+pub struct ItsiHttpResponse {
     pub data: Arc<ResponseData>,
-    pub accept: String,
 }
 
 #[derive(Debug)]
 pub struct ResponseData {
-    pub response: RwLock<Option<Response<BoxBody<Bytes, Infallible>>>>,
-    pub response_writer: RwLock<Option<mpsc::Sender<Option<Bytes>>>>,
+    pub response: RwLock<Option<HttpResponse>>,
+    pub response_writer: RwLock<Option<mpsc::Sender<ByteFrame>>>,
     pub response_buffer: RwLock<BytesMut>,
     pub hijacked_socket: RwLock<Option<UnixStream>>,
     pub parts: Parts,
 }
 
-impl ItsiResponse {
+impl ItsiHttpResponse {
     pub async fn build(
         &self,
-        first_frame: Option<Bytes>,
-        receiver: mpsc::Receiver<Option<Bytes>>,
+        first_frame: ByteFrame,
+        receiver: mpsc::Receiver<ByteFrame>,
         shutdown_rx: watch::Receiver<RunningPhase>,
-    ) -> Response<BoxBody<Bytes, Infallible>> {
+    ) -> HttpResponse {
         if self.is_hijacked() {
             return match self.process_hijacked_response().await {
                 Ok(result) => result,
@@ -65,14 +66,13 @@ impl ItsiResponse {
                 }
             };
         }
-
         let mut response = self.data.response.write().take().unwrap();
-        *response.body_mut() = if first_frame.is_none() {
+        *response.body_mut() = if matches!(first_frame, ByteFrame::Empty) {
             BoxBody::new(Empty::new())
-        } else if receiver.is_closed() && receiver.is_empty() {
-            BoxBody::new(Full::new(first_frame.unwrap()))
+        } else if matches!(first_frame, ByteFrame::End(_)) {
+            BoxBody::new(Full::new(first_frame.into()))
         } else {
-            let initial_frame = tokio_stream::once(Ok(Frame::data(first_frame.unwrap())));
+            let initial_frame = tokio_stream::once(Ok(Frame::data(Bytes::from(first_frame))));
             let frame_stream = unfold(
                 (ReceiverStream::new(receiver), shutdown_rx),
                 |(mut receiver, mut shutdown_rx)| async move {
@@ -82,13 +82,14 @@ impl ItsiResponse {
                     loop {
                         tokio::select! {
                             maybe_bytes = receiver.next() => {
-                                if let Some(bytes) = maybe_bytes {
-                                    // We assume `bytes` is Some(Bytes) here.
-                                    return Some((Ok(Frame::data(bytes.unwrap())), (receiver, shutdown_rx)));
-                                } else {
-                                    // Receiver closed, end the stream.
-                                    return None;
+                              match maybe_bytes {
+                                Some(ByteFrame::Data(bytes)) | Some(ByteFrame::End(bytes)) => {
+                                  return Some((Ok(Frame::data(bytes)), (receiver, shutdown_rx)));
                                 }
+                                _ => {
+                                  return None;
+                                }
+                              }
                             },
                             _ = shutdown_rx.changed() => {
                                 match *shutdown_rx.borrow() {
@@ -184,7 +185,7 @@ impl ItsiResponse {
         Ok((headers, status, requires_upgrade, reader))
     }
 
-    pub async fn process_hijacked_response(&self) -> Result<Response<BoxBody<Bytes, Infallible>>> {
+    pub async fn process_hijacked_response(&self) -> Result<HttpResponse> {
         let (headers, status, requires_upgrade, reader) = self.read_hijacked_headers().await?;
         let mut response = if requires_upgrade {
             let parts = self.data.parts.clone();
@@ -261,28 +262,31 @@ impl ItsiResponse {
         }
     }
 
-    pub fn send_frame(&self, frame: Bytes) -> MagnusResult<usize> {
-        self.send_frame_into(frame, &self.data.response_writer)
+    pub fn send_frame(&self, frame: Bytes) -> MagnusResult<()> {
+        self.send_frame_into(ByteFrame::Data(frame), &self.data.response_writer)
     }
 
-    pub fn send_and_close(&self, frame: Bytes) -> MagnusResult<usize> {
-        let result = self.send_frame_into(frame, &self.data.response_writer);
+    pub fn recv_frame(&self) {
+        // not implemented
+    }
+
+    pub fn send_and_close(&self, frame: Bytes) -> MagnusResult<()> {
+        let result = self.send_frame_into(ByteFrame::End(frame), &self.data.response_writer);
         self.data.response_writer.write().take();
         result
     }
 
     pub fn send_frame_into(
         &self,
-        frame: Bytes,
-        writer: &RwLock<Option<mpsc::Sender<Option<Bytes>>>>,
-    ) -> MagnusResult<usize> {
+        frame: ByteFrame,
+        writer: &RwLock<Option<mpsc::Sender<ByteFrame>>>,
+    ) -> MagnusResult<()> {
         if let Some(writer) = writer.write().as_ref() {
-            writer
-                .blocking_send(Some(frame))
-                .map_err(|_| itsi_error::ItsiError::ClientConnectionClosed)
-                .ok();
+            return Ok(writer
+                .blocking_send(frame)
+                .map_err(|_| itsi_error::ItsiError::ClientConnectionClosed)?);
         }
-        Ok(0)
+        Ok(())
     }
 
     pub fn is_hijacked(&self) -> bool {
@@ -293,20 +297,28 @@ impl ItsiResponse {
         self.data.response_writer.write().take();
         Ok(true)
     }
+    fn accept_str(&self) -> &str {
+        self.data
+            .parts
+            .headers
+            .get("Content-Type")
+            .and_then(|hv| hv.to_str().ok()) // handle invalid utf-8
+            .unwrap_or("application/x-www-form-urlencoded")
+    }
 
     pub fn is_html(&self) -> bool {
-        self.accept.starts_with("text/html")
+        self.accept_str().starts_with("text/html")
     }
 
     pub fn is_json(&self) -> bool {
-        self.accept.starts_with("application/json")
+        self.accept_str().starts_with("application/json")
     }
 
     pub fn close_read(&self) -> MagnusResult<bool> {
         Ok(true)
     }
 
-    pub fn new(parts: Parts, response_writer: mpsc::Sender<Option<Bytes>>, accept: String) -> Self {
+    pub fn new(parts: Parts, response_writer: mpsc::Sender<ByteFrame>) -> Self {
         Self {
             data: Arc::new(ResponseData {
                 response: RwLock::new(Some(Response::new(BoxBody::new(Empty::new())))),
@@ -315,7 +327,6 @@ impl ItsiResponse {
                 hijacked_socket: RwLock::new(None),
                 parts,
             }),
-            accept,
         }
     }
 
@@ -330,6 +341,26 @@ impl ItsiResponse {
         Ok(())
     }
 
+    pub fn add_headers(&self, headers: HashMap<Bytes, Vec<Bytes>>) -> MagnusResult<()> {
+        if let Some(ref mut resp) = *self.data.response.write() {
+            let headers_mut = resp.headers_mut();
+            for (name, values) in headers {
+                let header_name = HeaderName::from_bytes(&name).map_err(|e| {
+                    itsi_error::ItsiError::InvalidInput(format!(
+                        "Invalid header name {:?}: {:?}",
+                        name, e
+                    ))
+                })?;
+                for value in values {
+                    let header_value = unsafe { HeaderValue::from_maybe_shared_unchecked(value) };
+                    headers_mut.insert(&header_name, header_value);
+                }
+            }
+        }
+
+        Ok(())
+    }
+
     pub fn set_status(&self, status: u16) -> MagnusResult<()> {
         if let Some(ref mut resp) = *self.data.response.write() {
             *resp.status_mut() = StatusCode::from_u16(status).map_err(|e| {
@@ -348,8 +379,8 @@ impl ItsiResponse {
         *self.data.hijacked_socket.write() = Some(stream);
         if let Some(writer) = self.data.response_writer.write().as_ref() {
             writer
-                .blocking_send(None)
-                .map_err(|_| itsi_error::ItsiError::ClientConnectionClosed)?;
+                .blocking_send(ByteFrame::Empty)
+                .map_err(|_| itsi_error::ItsiError::ClientConnectionClosed)?
         }
         self.close();
         Ok(())