itsi-scheduler 0.1.5 → 0.1.19

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

@@ -0,0 +1,345 @@
+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 itsi_error::CLIENT_CONNECTION_CLOSED;
+use itsi_rb_helpers::{print_rb_backtrace, HeapValue};
+use itsi_tracing::{debug, error};
+use magnus::{
+    block::Proc,
+    error::{ErrorType, Result as MagnusResult},
+    Error, RHash, Symbol,
+};
+use magnus::{
+    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 crate::{
+    server::{
+        byte_frame::ByteFrame,
+        http_message_types::{HttpRequest, HttpResponse},
+        request_job::RequestJob,
+        size_limited_incoming::MaxBodySizeReached,
+    },
+    services::itsi_http_service::HttpRequestContext,
+};
+
+static ID_MESSAGE: LazyId = LazyId::new("message");
+
+#[derive(Debug)]
+#[magnus::wrap(class = "Itsi::HttpRequest", free_immediately, size)]
+pub struct ItsiHttpRequest {
+    pub parts: Parts,
+    #[debug(skip)]
+    pub body: ItsiBody,
+    pub version: Version,
+    pub response: ItsiHttpResponse,
+    pub start: Instant,
+    #[debug(skip)]
+    pub context: HttpRequestContext,
+    pub script_name: String,
+}
+
+impl fmt::Display for ItsiHttpRequest {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{} {} {}",
+            self.version().unwrap(),
+            self.method().unwrap(),
+            self.path().unwrap()
+        )
+    }
+}
+
+impl ItsiHttpRequest {
+    pub fn is_connection_closed_err(ruby: &Ruby, err: &Error) -> bool {
+        match err.error_type() {
+            ErrorType::Jump(_) => false,
+            ErrorType::Error(_, _) => false,
+            ErrorType::Exception(exception) => {
+                exception.is_kind_of(ruby.exception_eof_error())
+                    && err
+                        .value()
+                        .map(|v| {
+                            v.funcall::<_, _, String>(*ID_MESSAGE, ())
+                                .unwrap_or("".to_string())
+                                .eq(CLIENT_CONNECTION_CLOSED)
+                        })
+                        .unwrap_or(false)
+            }
+        }
+    }
+    pub 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_str() == "application/json"
+    }
+
+    pub fn url_params(&self) -> magnus::error::Result<RHash> {
+        let captures = self
+            .context
+            .matching_pattern
+            .as_ref()
+            .and_then(|re| re.captures(self.parts.uri.path()));
+        if let Some(caps) = &captures {
+            let re = self.context.matching_pattern.as_ref().unwrap();
+            let params = RHash::with_capacity(caps.len());
+            for (i, group_name) in re.capture_names().enumerate().skip(1) {
+                if let Some(name) = group_name {
+                    if let Some(m) = caps.get(i) {
+                        // Insert into the hash: key is the group name, value is the match.
+                        params.aset(Symbol::new(name), m.as_str())?;
+                    }
+                }
+            }
+            Ok(params)
+        } else {
+            Ok(RHash::new())
+        }
+    }
+
+    pub fn is_html(&self) -> bool {
+        self.content_type_str() == "text/html"
+    }
+
+    pub fn is_url_encoded(&self) -> bool {
+        self.content_type_str() == "application/x-www-form-urlencoded"
+    }
+
+    pub fn is_multipart(&self) -> bool {
+        self.content_type_str().starts_with("multipart/form-data")
+    }
+
+    pub fn content_length(&self) -> Option<u64> {
+        self.parts
+            .headers
+            .get(CONTENT_LENGTH)
+            .and_then(|hv| hv.to_str().ok())
+            .and_then(|s| s.parse().ok())
+    }
+
+    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 {
+            Self::internal_error(ruby, response, err);
+        }
+        Ok(())
+    }
+
+    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();
+        } else if let Some(rb_err) = err.value() {
+            print_rb_backtrace(rb_err);
+            response.internal_server_error(err.to_string());
+        } else {
+            response.internal_server_error(err.to_string());
+        }
+    }
+
+    pub fn error(self, message: String) {
+        self.response.internal_server_error(message);
+    }
+
+    pub(crate) async fn process_request(
+        app: Arc<HeapValue<Proc>>,
+        hyper_request: HttpRequest,
+        context: &HttpRequestContext,
+        script_name: String,
+        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();
+                let sender = if nonblocking {
+                    &context.nonblocking_sender
+                } else {
+                    &context.sender
+                };
+                match sender
+                    .send(RequestJob::ProcessHttpRequest(request, app))
+                    .await
+                {
+                    Err(err) => {
+                        error!("Error occurred: {}", err);
+                        let mut response = Response::new(BoxBody::new(Empty::new()));
+                        *response.status_mut() = StatusCode::BAD_REQUEST;
+                        Ok(response)
+                    }
+                    _ => 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),
+        }
+    }
+
+    pub(crate) async fn new(
+        request: HttpRequest,
+        context: &HttpRequestContext,
+        script_name: String,
+    ) -> Result<(ItsiHttpRequest, mpsc::Receiver<ByteFrame>), HttpResponse> {
+        let (parts, body) = request.into_parts();
+        let body = if context.server_params.streamable_body {
+            ItsiBody::Stream(ItsiBodyProxy::new(body))
+        } else {
+            let mut body_bytes = BigBytes::new();
+            let mut stream = body.into_data_stream();
+            while let Some(chunk) = stream.next().await {
+                match chunk {
+                    Ok(byte_array) => body_bytes.write_all(&byte_array).unwrap(),
+                    Err(e) => {
+                        let mut err_resp = Response::new(BoxBody::new(Empty::new()));
+                        if e.downcast_ref::<MaxBodySizeReached>().is_some() {
+                            *err_resp.status_mut() = StatusCode::PAYLOAD_TOO_LARGE;
+                        }
+                        return Err(err_resp);
+                    }
+                }
+            }
+            ItsiBody::Buffered(body_bytes)
+        };
+        let response_channel = mpsc::channel::<ByteFrame>(100);
+        Ok((
+            Self {
+                context: context.clone(),
+                version: parts.version,
+                response: ItsiHttpResponse::new(parts.clone(), response_channel.0),
+                start: Instant::now(),
+                script_name,
+                body,
+                parts,
+            },
+            response_channel.1,
+        ))
+    }
+
+    pub(crate) fn path(&self) -> MagnusResult<&str> {
+        Ok(self
+            .parts
+            .uri
+            .path()
+            .strip_prefix(&self.script_name)
+            .unwrap_or(self.parts.uri.path()))
+    }
+
+    pub(crate) fn script_name(&self) -> MagnusResult<&str> {
+        Ok(&self.script_name)
+    }
+
+    pub(crate) fn query_string(&self) -> MagnusResult<&str> {
+        Ok(self.parts.uri.query().unwrap_or(""))
+    }
+
+    pub(crate) fn method(&self) -> MagnusResult<&str> {
+        Ok(self.parts.method.as_str())
+    }
+
+    pub(crate) fn version(&self) -> MagnusResult<&str> {
+        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>> {
+        Ok(self
+            .parts
+            .headers
+            .get("upgrade")
+            .or_else(|| self.parts.headers.get("protocol"))
+            .map(|value| {
+                value
+                    .to_str()
+                    .unwrap_or("")
+                    .split(',')
+                    .map(|s| s.trim())
+                    .collect::<Vec<&str>>()
+            })
+            .unwrap_or_else(|| vec!["http"]))
+    }
+
+    pub(crate) fn host(&self) -> MagnusResult<&str> {
+        Ok(self
+            .parts
+            .uri
+            .host()
+            .unwrap_or_else(|| &self.context.listener.host))
+    }
+
+    pub(crate) fn scheme(&self) -> MagnusResult<&str> {
+        Ok(self
+            .parts
+            .uri
+            .scheme()
+            .map(|scheme| scheme.as_str())
+            .unwrap_or_else(|| &self.context.listener.scheme))
+    }
+
+    pub(crate) fn headers(&self) -> MagnusResult<Vec<(&str, &str)>> {
+        Ok(self
+            .parts
+            .headers
+            .iter()
+            .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.context.addr)
+    }
+
+    pub(crate) fn port(&self) -> MagnusResult<u16> {
+        Ok(self
+            .parts
+            .uri
+            .port_u16()
+            .unwrap_or(self.context.listener.port))
+    }
+
+    pub(crate) fn body(&self) -> MagnusResult<Option<Value>> {
+        Ok(self.body.into_value())
+    }
+
+    pub(crate) fn response(&self) -> MagnusResult<ItsiHttpResponse> {
+        Ok(self.response.clone())
+    }
+}

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

@@ -2,8 +2,9 @@ use bytes::{Bytes, BytesMut};
 use derive_more::Debug;
 use futures::stream::{unfold, StreamExt};
 use http::{
-    header::TRANSFER_ENCODING, request::Parts, HeaderMap, HeaderName, HeaderValue, Request,
-    Response, StatusCode,
+    header::{ACCEPT, TRANSFER_ENCODING},
+    request::Parts,
+    HeaderMap, HeaderName, HeaderValue, Request, Response, StatusCode,
 };
 use http_body_util::{combinators::BoxBody, Empty, Full, StreamBody};
 use hyper::{body::Frame, upgrade::Upgraded};
@@ -13,7 +14,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,30 +32,33 @@ 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, http_message_types::HttpResponse,
+    serve_strategy::single_mode::RunningPhase,
+};
 
-#[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>,
 }
 
 #[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,
@@ -64,31 +68,30 @@ 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 {
                     if let RunningPhase::ShutdownPending = *shutdown_rx.borrow() {
-                        warn!("Disconnecting streaming client.");
                         return None;
                     }
                     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 +187,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,27 +264,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 recv_frame(&self) {
+        // not implemented
     }
 
-    pub fn send_and_close(&self, frame: Bytes) -> MagnusResult<usize> {
-        let result = self.send_frame_into(frame, &self.data.response_writer);
+    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)?;
+            return Ok(writer
+                .blocking_send(frame)
+                .map_err(|_| itsi_error::ItsiError::ClientConnectionClosed)?);
         }
-        Ok(0)
+        Ok(())
     }
 
     pub fn is_hijacked(&self) -> bool {
@@ -293,11 +300,28 @@ impl ItsiResponse {
         Ok(true)
     }
 
+    pub fn accept_str(&self) -> &str {
+        self.data
+            .parts
+            .headers
+            .get(ACCEPT)
+            .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_str().starts_with("text/html")
+    }
+
+    pub fn is_json(&self) -> bool {
+        self.accept_str().starts_with("application/json")
+    }
+
     pub fn close_read(&self) -> MagnusResult<bool> {
-        todo!();
+        Ok(true)
     }
 
-    pub fn new(parts: Parts, response_writer: mpsc::Sender<Option<Bytes>>) -> 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())))),
@@ -320,6 +344,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| {
@@ -338,8 +382,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(())