itsi-server 0.1.1 → 0.1.2

data/ext/itsi_server/src/body_proxy/itsi_body_proxy.rs

@@ -0,0 +1,122 @@
+use super::big_bytes::BigBytes;
+use bytes::Bytes;
+use futures::executor::block_on;
+use http_body_util::{BodyDataStream, BodyExt};
+use hyper::body::Incoming;
+use magnus::{error::Result as MagnusResult, scan_args, IntoValue, RString, Ruby, Value};
+use parking_lot::Mutex;
+use std::sync::{
+    atomic::{self, AtomicBool},
+    Arc,
+};
+use tokio_stream::StreamExt;
+
+#[magnus::wrap(class = "Itsi::BodyProxy", free_immediately, size)]
+#[derive(Debug, Clone)]
+pub struct ItsiBodyProxy {
+    pub incoming: Arc<Mutex<BodyDataStream<Incoming>>>,
+    pub closed: Arc<AtomicBool>,
+    pub buf: Arc<Mutex<Vec<u8>>>,
+}
+
+pub enum ItsiBody {
+    Buffered(BigBytes),
+    Stream(ItsiBodyProxy),
+}
+
+impl ItsiBody {
+    pub fn into_value(&self) -> Value {
+        match self {
+            ItsiBody::Buffered(bytes) => bytes.as_value(),
+            ItsiBody::Stream(proxy) => proxy.clone().into_value(),
+        }
+    }
+}
+impl ItsiBodyProxy {
+    pub fn new(incoming: Incoming) -> Self {
+        ItsiBodyProxy {
+            incoming: Arc::new(Mutex::new(incoming.into_data_stream())),
+            closed: Arc::new(AtomicBool::new(false)),
+            buf: Arc::new(Mutex::new(vec![])),
+        }
+    }
+    /// Read up to the next line-break OR EOF
+    pub fn gets(&self) -> MagnusResult<Option<Bytes>> {
+        self.verify_open()?;
+        let mut stream = self.incoming.lock();
+        let mut buf = self.buf.lock();
+        while !buf.contains(&b'\n') {
+            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),
+                    )
+                })?;
+                buf.extend_from_slice(&chunk);
+            } else {
+                break;
+            }
+        }
+        if let Some(pos) = buf.iter().position(|&x| x == b'\n') {
+            let line = buf.drain(..=pos).collect::<Vec<u8>>();
+            Ok(Some(line.into()))
+        } else if !buf.is_empty() {
+            let line = buf.drain(..).collect::<Vec<u8>>();
+            Ok(Some(line.into()))
+        } else {
+            Ok(None)
+        }
+    }
+
+    pub fn read(&self, args: &[Value]) -> MagnusResult<Option<RString>> {
+        self.verify_open()?;
+        let scanned =
+            scan_args::scan_args::<(), (Option<usize>, Option<RString>), (), (), (), ()>(args)?;
+        let (length, mut buffer) = scanned.optional;
+        let mut stream = self.incoming.lock();
+        let mut buf = self.buf.lock();
+
+        while length.is_none_or(|target_length| buf.len() < target_length) {
+            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),
+                    )
+                })?;
+                buf.extend_from_slice(&chunk);
+            } else if length.is_some() {
+                return Ok(None);
+            } else {
+                break;
+            }
+        }
+        let output_string = buffer.take().unwrap_or(RString::buf_new(buf.len()));
+        output_string.cat(buf.clone());
+        buf.clear();
+        Ok(Some(output_string))
+    }
+
+    /// Equivalent to calling gets and yielding it, until we reach EOF
+    pub fn each(ruby: &Ruby, rbself: &Self) -> MagnusResult<()> {
+        let proc = ruby.block_proc()?;
+        while let Some(str) = rbself.gets()? {
+            proc.call::<_, Value>((str,))?;
+        }
+        Ok(())
+    }
+
+    fn verify_open(&self) -> MagnusResult<()> {
+        if self.closed.load(atomic::Ordering::SeqCst) {
+            return Err(magnus::Error::new(
+                magnus::exception::exception(),
+                "Body stream is closed",
+            ));
+        }
+        Ok(())
+    }
+    pub fn close(&self) {
+        self.closed.store(true, atomic::Ordering::SeqCst);
+    }
+}

data/ext/itsi_server/src/body_proxy/mod.rs

@@ -0,0 +1,2 @@
+pub mod big_bytes;
+pub mod itsi_body_proxy;

data/ext/itsi_server/src/lib.rs

@@ -1,11 +1,14 @@
+use body_proxy::itsi_body_proxy::ItsiBodyProxy;
 use magnus::{error::Result, function, method, value::Lazy, Module, Object, RClass, RModule, Ruby};
 use request::itsi_request::ItsiRequest;
-use server::itsi_server::Server;
-use stream_writer::StreamWriter;
+use response::itsi_response::ItsiResponse;
+use server::{itsi_server::Server, signal::reset_signal_handlers};
+use tracing::*;
 
+pub mod body_proxy;
 pub mod request;
+pub mod response;
 pub mod server;
-pub mod stream_writer;
 
 pub static ITSI_MODULE: Lazy<RModule> = Lazy::new(|ruby| ruby.define_module("Itsi").unwrap());
 pub static ITSI_SERVER: Lazy<RClass> = Lazy::new(|ruby| {
@@ -18,18 +21,51 @@ pub static ITSI_REQUEST: Lazy<RClass> = Lazy::new(|ruby| {
         .define_class("Request", ruby.class_object())
         .unwrap()
 });
-pub static ITSI_STREAM_WRITER: Lazy<RClass> = Lazy::new(|ruby| {
+
+pub static ITSI_RESPONSE: Lazy<RClass> = Lazy::new(|ruby| {
+    ruby.get_inner(&ITSI_MODULE)
+        .define_class("Response", ruby.class_object())
+        .unwrap()
+});
+
+pub static ITSI_BODY_PROXY: Lazy<RClass> = Lazy::new(|ruby| {
+    ruby.get_inner(&ITSI_MODULE)
+        .define_class("BodyProxy", ruby.class_object())
+        .unwrap()
+});
+
+pub static ITSI_SERVER_SCHEDULER_TASK: Lazy<RClass> = Lazy::new(|ruby| {
     ruby.get_inner(&ITSI_MODULE)
-        .define_class("StreamWriter", ruby.class_object())
+        .define_class("ServerSchedulerTask", ruby.class_object())
         .unwrap()
 });
 
+pub fn log_debug(msg: String) {
+    debug!(msg);
+}
+pub fn log_info(msg: String) {
+    info!(msg);
+}
+pub fn log_warn(msg: String) {
+    warn!(msg);
+}
+pub fn log_error(msg: String) {
+    error!(msg);
+}
+
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<()> {
     itsi_tracing::init();
 
+    let itsi = ruby.get_inner(&ITSI_MODULE);
+    itsi.define_singleton_method("log_debug", function!(log_debug, 1))?;
+    itsi.define_singleton_method("log_info", function!(log_info, 1))?;
+    itsi.define_singleton_method("log_warn", function!(log_warn, 1))?;
+    itsi.define_singleton_method("log_error", function!(log_error, 1))?;
+
     let server = ruby.get_inner(&ITSI_SERVER);
     server.define_singleton_method("new", function!(Server::new, -1))?;
+    server.define_singleton_method("reset_signal_handlers", function!(reset_signal_handlers, 0))?;
     server.define_method("start", method!(Server::start, 0))?;
 
     let request = ruby.get_inner(&ITSI_REQUEST);
@@ -41,12 +77,27 @@ fn init(ruby: &Ruby) -> Result<()> {
     request.define_method("rack_protocol", method!(ItsiRequest::rack_protocol, 0))?;
     request.define_method("host", method!(ItsiRequest::host, 0))?;
     request.define_method("headers", method!(ItsiRequest::headers, 0))?;
+    request.define_method("scheme", method!(ItsiRequest::scheme, 0))?;
     request.define_method("remote_addr", method!(ItsiRequest::remote_addr, 0))?;
     request.define_method("port", method!(ItsiRequest::port, 0))?;
     request.define_method("body", method!(ItsiRequest::body, 0))?;
+    request.define_method("response", method!(ItsiRequest::response, 0))?;
+
+    let body_proxy = ruby.get_inner(&ITSI_BODY_PROXY);
+    body_proxy.define_method("gets", method!(ItsiBodyProxy::gets, 0))?;
+    body_proxy.define_method("each", method!(ItsiBodyProxy::each, 0))?;
+    body_proxy.define_method("read", method!(ItsiBodyProxy::read, -1))?;
+    body_proxy.define_method("close", method!(ItsiBodyProxy::close, 0))?;
 
-    let stream_writer = ruby.get_inner(&ITSI_STREAM_WRITER);
-    stream_writer.define_method("write", method!(StreamWriter::write, 1))?;
+    let response = ruby.get_inner(&ITSI_RESPONSE);
+    response.define_method("add_header", method!(ItsiResponse::add_header, 2))?;
+    response.define_method("status=", method!(ItsiResponse::set_status, 1))?;
+    response.define_method("send_frame", method!(ItsiResponse::send_frame, 1))?;
+    response.define_method("send_and_close", method!(ItsiResponse::send_and_close, 1))?;
+    response.define_method("close_write", method!(ItsiResponse::close_write, 0))?;
+    response.define_method("close_read", method!(ItsiResponse::close_read, 0))?;
+    response.define_method("close", method!(ItsiResponse::close, 0))?;
+    response.define_method("hijack", method!(ItsiResponse::hijack, 1))?;
 
     Ok(())
 }

data/ext/itsi_server/src/request/itsi_request.rs

@@ -1,143 +1,277 @@
-use std::{collections::HashMap, sync::Arc};
-
-use crate::server::listener::{Listener, SockAddr};
+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 http::request::Parts;
-use http_body_util::BodyExt;
+use derive_more::Debug;
+use futures::StreamExt;
+use http::{request::Parts, Response, StatusCode};
+use http_body_util::{combinators::BoxBody, BodyExt, Empty};
 use hyper::{body::Incoming, Request};
-use magnus::error::Result;
+use itsi_error::from::CLIENT_CONNECTION_CLOSED;
+use itsi_tracing::{debug, error};
+use magnus::{
+    error::{ErrorType, Result as MagnusResult},
+    Error,
+};
+use magnus::{
+    value::{LazyId, Opaque, ReprValue},
+    RClass, Ruby, Value,
+};
+use std::{convert::Infallible, fmt, io::Write, sync::Arc, time::Instant};
+use tokio::sync::{
+    mpsc::{self},
+    watch,
+};
+static ID_CALL: LazyId = LazyId::new("call");
+static ID_MESSAGE: LazyId = LazyId::new("message");
+static ID_BACKTRACE: LazyId = LazyId::new("backtrace");
 
-#[magnus::wrap(class = "Itsi::Request", free_immediately, size)]
 #[derive(Debug)]
+#[magnus::wrap(class = "Itsi::Request", free_immediately, size)]
 pub struct ItsiRequest {
-    pub path: String,
-    pub script_name: String,
-    pub query_string: String,
-    pub method: String,
-    pub version: String,
-    pub rack_protocol: Vec<String>,
-    pub host: String,
-    pub scheme: String,
-    pub headers: HashMap<String, String>,
-    pub remote_addr: String,
-    pub port: u16,
-    pub body: Bytes,
     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 start: Instant,
+}
+
+impl fmt::Display for ItsiRequest {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{} {} {}",
+            self.version().unwrap(),
+            self.method().unwrap(),
+            self.path().unwrap()
+        )
+    }
 }
 
 impl ItsiRequest {
-    pub(crate) async fn build_from(
-        request: Request<Incoming>,
-        sock_addr: SockAddr,
-        script_name: String,
-        listener: Arc<Listener>,
-    ) -> Self {
-        let (parts, body) = request.into_parts();
-        let method = parts.method.to_string();
-        let port = parts.uri.port_u16().unwrap_or(listener.port());
-        let query_string = parts.uri.query().unwrap_or("").to_string();
-        let rack_protocol = parts
-            .headers
-            .get("upgrade")
-            .or_else(|| parts.headers.get("protocol"))
-            .map(|value| {
-                value
-                    .to_str()
-                    .unwrap_or("")
-                    .split(',')
-                    .map(|s| s.trim().to_owned())
-                    .collect::<Vec<String>>()
-            })
-            .unwrap_or_else(|| vec!["http".to_string()]);
+    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)
+            }
+        }
+    }
 
-        let host = parts
-            .uri
-            .host()
-            .map(ToOwned::to_owned)
-            .unwrap_or_else(|| listener.host());
+    pub fn process(
+        self,
+        ruby: &Ruby,
+        server: RClass,
+        app: Opaque<Value>,
+    ) -> magnus::error::Result<()> {
+        let req = format!("{}", self);
+        let response = self.response.clone();
+        let start = self.start;
+        debug!("{} Started", req);
+        let result = server.funcall::<_, _, Value>(*ID_CALL, (app, self));
+        if let Err(err) = result {
+            Self::internal_error(ruby, response, err);
+        }
+        debug!("{} Finished in {:?}", req, start.elapsed());
 
-        let scheme = parts
-            .uri
-            .scheme()
-            .map(|s| s.to_string())
-            .unwrap_or_else(|| listener.scheme());
+        Ok(())
+    }
 
-        let headers = parts
-            .headers
-            .iter()
-            .map(|(k, v)| (k.to_string(), v.to_str().unwrap_or("").to_string()))
-            .collect();
+    pub fn internal_error(ruby: &Ruby, response: ItsiResponse, 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();
 
-        let path = parts
+            error!("Error occurred in Handler: {:?}", rb_err);
+            for line in backtrace {
+                error!("{}", line);
+            }
+            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(
+        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;
+
+        let response = request.response.clone();
+        match sender.send(RequestJob::ProcessRequest(request)).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_rx).await),
+                None => Ok(response.build(None, receiver, shutdown_rx).await),
+            },
+        }
+    }
+
+    pub(crate) async fn new(
+        request: Request<Incoming>,
+        sock_addr: SockAddr,
+        server: Arc<Server>,
+        listener: Arc<TokioListener>,
+    ) -> (ItsiRequest, mpsc::Receiver<Option<Bytes>>) {
+        let (parts, body) = request.into_parts();
+        let body = if server.stream_body.is_some_and(|f| f) {
+            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 {
+                let byte_array = chunk.unwrap().to_vec();
+                body_bytes.write_all(&byte_array).unwrap();
+            }
+            ItsiBody::Buffered(body_bytes)
+        };
+        let response_channel = mpsc::channel::<Option<Bytes>>(100);
+        (
+            Self {
+                remote_addr: sock_addr.to_string(),
+                body,
+                server,
+                listener,
+                version: format!("{:?}", &parts.version),
+                response: ItsiResponse::new(parts.clone(), response_channel.0),
+                start: Instant::now(),
+                parts,
+            },
+            response_channel.1,
+        )
+    }
+
+    pub(crate) fn path(&self) -> MagnusResult<&str> {
+        Ok(self
+            .parts
             .uri
             .path()
-            .strip_prefix(&script_name)
-            .unwrap_or(parts.uri.path())
-            .to_string();
-
-        let version = format!("{:?}", parts.version);
-        let body = body.collect().await.unwrap().to_bytes();
-
-        Self {
-            remote_addr: sock_addr.to_string(),
-            body,
-            parts,
-            script_name,
-            query_string,
-            method,
-            headers,
-            path,
-            version,
-            rack_protocol,
-            host,
-            scheme,
-            port,
-        }
+            .strip_prefix(&self.server.script_name)
+            .unwrap_or(self.parts.uri.path()))
     }
-}
 
-impl ItsiRequest {
-    pub(crate) fn path(&self) -> Result<String> {
-        Ok(self.path.clone())
+    pub(crate) fn script_name(&self) -> MagnusResult<&str> {
+        Ok(&self.server.script_name)
+    }
+
+    pub(crate) fn query_string(&self) -> MagnusResult<&str> {
+        Ok(self.parts.uri.query().unwrap_or(""))
     }
 
-    pub(crate) fn script_name(&self) -> Result<String> {
-        Ok(self.script_name.clone())
+    pub(crate) fn method(&self) -> MagnusResult<&str> {
+        Ok(self.parts.method.as_str())
     }
 
-    pub(crate) fn query_string(&self) -> Result<String> {
-        Ok(self.query_string.clone())
+    pub(crate) fn version(&self) -> MagnusResult<&str> {
+        Ok(&self.version)
     }
 
-    pub(crate) fn method(&self) -> Result<String> {
-        Ok(self.method.clone())
+    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 version(&self) -> Result<String> {
-        Ok(self.version.clone())
+    pub(crate) fn host(&self) -> MagnusResult<String> {
+        Ok(self
+            .parts
+            .uri
+            .host()
+            .map(|host| host.to_string())
+            .unwrap_or_else(|| self.listener.host()))
     }
 
-    pub(crate) fn rack_protocol(&self) -> Result<Vec<String>> {
-        Ok(self.rack_protocol.clone())
+    pub(crate) fn scheme(&self) -> MagnusResult<String> {
+        Ok(self
+            .parts
+            .uri
+            .scheme()
+            .map(|scheme| scheme.to_string())
+            .unwrap_or_else(|| self.listener.scheme()))
     }
 
-    pub(crate) fn host(&self) -> Result<String> {
-        Ok(self.host.clone())
+    pub(crate) fn headers(&self) -> MagnusResult<Vec<(String, &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())
     }
 
-    pub(crate) fn headers(&self) -> Result<HashMap<String, String>> {
-        Ok(self.headers.clone())
+    pub(crate) fn remote_addr(&self) -> MagnusResult<&str> {
+        Ok(&self.remote_addr)
     }
 
-    pub(crate) fn remote_addr(&self) -> Result<String> {
-        Ok(self.remote_addr.clone())
+    pub(crate) fn port(&self) -> MagnusResult<u16> {
+        Ok(self.parts.uri.port_u16().unwrap_or(self.listener.port()))
     }
 
-    pub(crate) fn port(&self) -> Result<u16> {
-        Ok(self.port)
+    pub(crate) fn body(&self) -> MagnusResult<Value> {
+        Ok(self.body.into_value())
     }
 
-    pub(crate) fn body(&self) -> Result<Bytes> {
-        Ok(self.body.clone())
+    pub(crate) fn response(&self) -> MagnusResult<ItsiResponse> {
+        Ok(self.response.clone())
     }
 }