itsi-scheduler 0.1.5 → 0.1.14

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

@@ -0,0 +1,216 @@
+use std::{collections::HashMap, sync::Arc};
+
+use crate::server::{
+    byte_frame::ByteFrame, serve_strategy::single_mode::RunningPhase, types::HttpResponse,
+};
+use bytes::Bytes;
+use derive_more::Debug;
+use futures::{executor::block_on, stream::unfold};
+use http::{
+    header::{HeaderName, HeaderValue, CONTENT_TYPE},
+    HeaderMap, Response,
+};
+use http_body_util::{combinators::BoxBody, BodyDataStream, BodyExt, Empty, Full, StreamBody};
+use hyper::body::{Frame, Incoming};
+use magnus::error::Result as MagnusResult;
+use parking_lot::Mutex;
+use tokio::sync::{
+    mpsc::{Receiver, Sender},
+    oneshot, watch,
+};
+use tokio_stream::{wrappers::ReceiverStream, StreamExt};
+use tracing::{error, info, warn};
+
+#[derive(Debug, Clone)]
+#[magnus::wrap(class = "Itsi::GrpcStream", free_immediately, size)]
+pub struct ItsiGrpcStream {
+    pub inner: Arc<Mutex<ItsiGrpcStreamInner>>,
+}
+
+#[derive(Debug)]
+pub struct ItsiGrpcStreamInner {
+    pub body: BodyDataStream<Incoming>,
+    pub buf: Vec<u8>,
+    pub response_sender: Sender<ByteFrame>,
+    pub response: Option<HttpResponse>,
+    trailer_tx: oneshot::Sender<HeaderMap>,
+    trailer_rx: Option<oneshot::Receiver<HeaderMap>>,
+}
+
+impl ItsiGrpcStreamInner {
+    pub fn read(&mut self, bytes: usize) -> MagnusResult<Bytes> {
+        let stream = &mut self.body;
+        let buf = &mut self.buf;
+        let mut result = Vec::with_capacity(bytes);
+
+        info!("Entering read with {:?}. Current buf is {:?}", bytes, buf);
+
+        // First, use any data already in the buffer
+        if !buf.is_empty() {
+            let remaining = bytes.min(buf.len());
+            result.extend_from_slice(&buf[..remaining]);
+            buf.drain(..remaining);
+        }
+
+        while result.len() < bytes {
+            if let Some(chunk) = block_on(stream.next()) {
+                let chunk = chunk.map_err(|err| {
+                    magnus::Error::new(
+                        magnus::exception::exception(),
+                        format!("Error reading body {:?}", err),
+                    )
+                })?;
+                let remaining = bytes - result.len();
+                if chunk.len() > remaining {
+                    result.extend_from_slice(&chunk[..remaining]);
+                    buf.extend_from_slice(&chunk[remaining..]);
+                } else {
+                    result.extend_from_slice(&chunk);
+                }
+            } else {
+                break;
+            }
+        }
+
+        Ok(result.into())
+    }
+
+    pub fn write(&mut self, bytes: Bytes) -> MagnusResult<()> {
+        self.response_sender
+            .blocking_send(ByteFrame::Data(bytes))
+            .map_err(|err| {
+                magnus::Error::new(
+                    magnus::exception::exception(),
+                    format!("Error writing body {:?}", err),
+                )
+            })?;
+        Ok(())
+    }
+
+    pub fn flush(&mut self) -> MagnusResult<()> {
+        Ok(())
+    }
+
+    pub fn send_trailers(&mut self, trailers: HashMap<String, String>) -> MagnusResult<()> {
+        let mut header_map = HeaderMap::new();
+        for (key, value) in trailers {
+            if let (Ok(hn), Ok(hv)) = (key.parse::<HeaderName>(), value.parse::<HeaderValue>()) {
+                header_map.insert(hn, hv);
+            }
+        }
+        let trailer_tx = std::mem::replace(&mut self.trailer_tx, oneshot::channel().0);
+        trailer_tx.send(header_map).map_err(|err| {
+            magnus::Error::new(
+                magnus::exception::exception(),
+                format!("Error sending trailers {:?}", err),
+            )
+        })?;
+        self.response_sender
+            .blocking_send(ByteFrame::Empty)
+            .map_err(|err| {
+                magnus::Error::new(
+                    magnus::exception::exception(),
+                    format!("Error flushing {:?}", err),
+                )
+            })?;
+        Ok(())
+    }
+}
+
+impl ItsiGrpcStream {
+    pub fn new(response_sender: Sender<ByteFrame>, body: BodyDataStream<Incoming>) -> Self {
+        let (trailer_tx, trailer_rx) = oneshot::channel::<HeaderMap>();
+        ItsiGrpcStream {
+            inner: Arc::new(Mutex::new(ItsiGrpcStreamInner {
+                body,
+                buf: Vec::new(),
+                response_sender,
+                response: Some(Response::new(BoxBody::new(Empty::new()))),
+                trailer_tx,
+                trailer_rx: Some(trailer_rx),
+            })),
+        }
+    }
+
+    pub fn read(&self, bytes: usize) -> MagnusResult<Bytes> {
+        self.inner.lock().read(bytes)
+    }
+
+    pub fn write(&self, bytes: Bytes) -> MagnusResult<()> {
+        self.inner.lock().write(bytes)
+    }
+
+    pub fn flush(&self) -> MagnusResult<()> {
+        self.inner.lock().flush()
+    }
+
+    pub fn send_trailers(&self, trailers: HashMap<String, String>) -> MagnusResult<()> {
+        self.inner.lock().send_trailers(trailers)
+    }
+
+    pub async fn build_response(
+        &self,
+        first_frame: ByteFrame,
+        receiver: Receiver<ByteFrame>,
+        shutdown_rx: watch::Receiver<RunningPhase>,
+    ) -> HttpResponse {
+        let mut response = self.inner.lock().response.take().unwrap();
+        let rx = self.inner.lock().trailer_rx.take().unwrap();
+        response
+            .headers_mut()
+            .append(CONTENT_TYPE, "application/grpc".parse().unwrap());
+        *response.body_mut() = if matches!(first_frame, ByteFrame::Empty) {
+            BoxBody::new(Empty::new())
+        } else if matches!(first_frame, ByteFrame::End(_)) {
+            BoxBody::new(Full::new(first_frame.into()))
+        } else {
+            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() {
+                        return None;
+                    }
+                    loop {
+                        tokio::select! {
+                            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 None;
+                                }
+                              }
+                            },
+                            _ = shutdown_rx.changed() => {
+                                match *shutdown_rx.borrow() {
+                                    RunningPhase::ShutdownPending => {
+                                        warn!("Disconnecting streaming client.");
+                                        return None;
+                                    },
+                                    _ => continue,
+                                }
+                            }
+                        }
+                    }
+                },
+            );
+
+            let combined_stream = initial_frame.chain(frame_stream);
+            BoxBody::new(StreamBody::new(combined_stream))
+        }
+        .with_trailers(async move {
+            match rx.await {
+                Ok(trailers) => Some(Ok(trailers)),
+                Err(_err) => None,
+            }
+        })
+        .boxed();
+        response
+    }
+
+    pub fn internal_server_error(&self, message: String) {
+        error!(message);
+    }
+}

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

@@ -1,57 +1,49 @@
-use crate::{
-    body_proxy::{
-        big_bytes::BigBytes,
-        itsi_body_proxy::{ItsiBody, ItsiBodyProxy},
-    },
-    response::itsi_response::ItsiResponse,
-    server::{
-        itsi_server::{RequestJob, Server},
-        listener::{SockAddr, TokioListener},
-        serve_strategy::single_mode::RunningPhase,
-    },
-};
-use bytes::Bytes;
 use derive_more::Debug;
 use futures::StreamExt;
-use http::{request::Parts, 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, 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");
-static ID_BACKTRACE: LazyId = LazyId::new("backtrace");
 
 #[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<TokioListener>,
-    #[debug(skip)]
-    pub server: Arc<Server>,
-    pub response: ItsiResponse,
+    pub version: Version,
+    pub response: ItsiHttpResponse,
     pub start: Instant,
+    #[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,
@@ -63,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,
@@ -81,39 +73,37 @@ 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_str() == "application/json"
+    }
 
-    pub fn process(
-        self,
-        ruby: &Ruby,
-        server: RClass,
-        app: Opaque<Value>,
-    ) -> magnus::error::Result<()> {
-        let req = format!("{}", self);
+    pub fn is_html(&self) -> bool {
+        self.content_type_str() == "text/html"
+    }
+
+    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();
         } else if let Some(rb_err) = err.value() {
-            let backtrace = rb_err
-                .funcall::<_, _, Vec<String>>(*ID_BACKTRACE, ())
-                .unwrap_or_default();
-
-            error!("Error occurred in Handler: {:?}", rb_err);
-            for line in backtrace {
-                error!("{}", line);
-            }
+            print_rb_backtrace(rb_err);
             response.internal_server_error(err.to_string());
         } else {
             response.internal_server_error(err.to_string());
@@ -125,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<TokioListener>,
-        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()));
@@ -143,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<TokioListener>,
-    ) -> (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();
@@ -167,16 +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),
+                context: context.clone(),
+                version: parts.version,
+                response: ItsiHttpResponse::new(parts.clone(), response_channel.0),
                 start: Instant::now(),
+                body,
                 parts,
             },
             response_channel.1,
@@ -188,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> {
@@ -205,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>> {
@@ -225,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()))
+            .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()))
+            .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())
     }
 }