itsi 0.1.9 → 0.1.12

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

@@ -1,305 +0,0 @@
-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_body_util::{combinators::BoxBody, BodyExt, Empty};
-use hyper::{body::Incoming, Request};
-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");
-
-#[derive(Debug)]
-#[magnus::wrap(class = "Itsi::Request", free_immediately, size)]
-pub struct ItsiRequest {
-    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 start: Instant,
-    pub content_type: String,
-}
-
-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 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 is_json(&self) -> bool {
-        self.content_type.eq("application/json")
-    }
-
-    pub fn is_html(&self) -> bool {
-        self.content_type.eq("text/html")
-    }
-
-    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());
-
-        Ok(())
-    }
-
-    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();
-
-            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<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;
-
-        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<ListenerInfo>,
-    ) -> (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,
-                    parts
-                        .headers
-                        .get("Accept")
-                        .unwrap_or(&HeaderValue::from_static("text/html"))
-                        .to_str()
-                        .unwrap()
-                        .to_string(),
-                ),
-                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(),
-                parts,
-            },
-            response_channel.1,
-        )
-    }
-
-    pub(crate) fn path(&self) -> MagnusResult<&str> {
-        Ok(self
-            .parts
-            .uri
-            .path()
-            .strip_prefix(&self.server.script_name)
-            .unwrap_or(self.parts.uri.path()))
-    }
-
-    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 method(&self) -> MagnusResult<&str> {
-        Ok(self.parts.method.as_str())
-    }
-
-    pub(crate) fn version(&self) -> MagnusResult<&str> {
-        Ok(&self.version)
-    }
-
-    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<String> {
-        Ok(self
-            .parts
-            .uri
-            .host()
-            .map(|host| host.to_string())
-            .unwrap_or_else(|| self.listener.host.clone()))
-    }
-
-    pub(crate) fn scheme(&self) -> MagnusResult<String> {
-        Ok(self
-            .parts
-            .uri
-            .scheme()
-            .map(|scheme| scheme.to_string())
-            .unwrap_or_else(|| self.listener.scheme.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 remote_addr(&self) -> MagnusResult<&str> {
-        Ok(&self.remote_addr)
-    }
-
-    pub(crate) fn port(&self) -> MagnusResult<u16> {
-        Ok(self.parts.uri.port_u16().unwrap_or(self.listener.port))
-    }
-
-    pub(crate) fn body(&self) -> MagnusResult<Value> {
-        Ok(self.body.into_value())
-    }
-
-    pub(crate) fn response(&self) -> MagnusResult<ItsiResponse> {
-        Ok(self.response.clone())
-    }
-}

data/crates/itsi_server/src/request/mod.rs

@@ -1 +0,0 @@
-pub mod itsi_request;

data/crates/itsi_server/src/response/mod.rs

@@ -1 +0,0 @@
-pub mod itsi_response;

data/crates/itsi_server/src/server/itsi_server.rs

@@ -1,294 +0,0 @@
-use super::{
-    bind::Bind,
-    listener::Listener,
-    serve_strategy::{cluster_mode::ClusterMode, single_mode::SingleMode},
-    signal::{
-        clear_signal_handlers, reset_signal_handlers, send_shutdown_event, SIGNAL_HANDLER_CHANNEL,
-    },
-};
-use crate::{request::itsi_request::ItsiRequest, server::serve_strategy::ServeStrategy};
-use derive_more::Debug;
-use itsi_rb_helpers::{call_without_gvl, HeapVal};
-use itsi_tracing::{error, run_silently};
-use magnus::{
-    block::Proc,
-    error::Result,
-    scan_args::{get_kwargs, scan_args, Args, KwArgs, ScanArgsKw, ScanArgsOpt, ScanArgsRequired},
-    value::{InnerValue, Opaque, ReprValue},
-    ArgList, RHash, Ruby, Symbol, Value,
-};
-use parking_lot::{Mutex, RwLock};
-use std::{cmp::max, ops::Deref, sync::Arc};
-use tracing::{info, instrument};
-
-static DEFAULT_BIND: &str = "http://localhost:3000";
-
-#[magnus::wrap(class = "Itsi::Server", free_immediately, size)]
-#[derive(Clone)]
-pub struct Server {
-    pub config: Arc<ServerConfig>,
-}
-
-impl Deref for Server {
-    type Target = ServerConfig;
-
-    fn deref(&self) -> &Self::Target {
-        &self.config
-    }
-}
-type AfterFork = Mutex<Arc<Option<Box<dyn Fn() + Send + Sync>>>>;
-
-#[derive(Debug)]
-pub struct ServerConfig {
-    #[debug(skip)]
-    pub app: HeapVal,
-    #[allow(unused)]
-    pub workers: u8,
-    #[allow(unused)]
-    pub threads: u8,
-    #[allow(unused)]
-    pub shutdown_timeout: f64,
-    pub script_name: String,
-    pub(crate) binds: Mutex<Vec<Bind>>,
-    #[debug(skip)]
-    pub before_fork: Mutex<Option<Box<dyn FnOnce() + Send + Sync>>>,
-    #[debug(skip)]
-    pub after_fork: AfterFork,
-    pub scheduler_class: Option<String>,
-    pub stream_body: Option<bool>,
-    pub worker_memory_limit: Option<u64>,
-    #[debug(skip)]
-    pub(crate) strategy: RwLock<Option<ServeStrategy>>,
-    pub silence: bool,
-}
-
-#[derive(Debug)]
-pub enum RequestJob {
-    ProcessRequest(ItsiRequest),
-    Shutdown,
-}
-
-// Define your helper function.
-// Here P, A, C correspond to the types for the first tuple, second tuple, and extra parameters respectively.
-fn extract_args<Req, Opt, Splat>(
-    scan_args: &Args<(), (), (), (), RHash, ()>,
-    primaries: &[&str],
-    rest: &[&str],
-) -> Result<KwArgs<Req, Opt, Splat>>
-where
-    Req: ScanArgsRequired,
-    Opt: ScanArgsOpt,
-    Splat: ScanArgsKw,
-{
-    // Combine the primary and rest names into one Vec of Symbols.
-    let symbols: Vec<Symbol> = primaries
-        .iter()
-        .chain(rest.iter())
-        .map(|&name| Symbol::new(name))
-        .collect();
-
-    // Call the "slice" function with the combined symbols.
-    let hash = scan_args
-        .keywords
-        .funcall::<_, _, RHash>("slice", symbols.into_arg_list_with(&Ruby::get().unwrap()))
-        .unwrap();
-
-    // Finally, call get_kwargs with the original name slices.
-    get_kwargs(hash, primaries, rest)
-}
-
-impl Server {
-    #[instrument(
-        name = "Itsi",
-        parent=None,
-        skip(args),
-        fields(workers = 1, threads = 1, shutdown_timeout = 5)
-    )]
-    pub fn new(args: &[Value]) -> Result<Self> {
-        let scan_args: Args<(), (), (), (), RHash, ()> = scan_args(args)?;
-
-        type Args1 = KwArgs<
-            (Value,),
-            (
-                // Workers
-                Option<u8>,
-                // Threads
-                Option<u8>,
-                // Shutdown Timeout
-                Option<f64>,
-                // Script Name
-                Option<String>,
-                // Binds
-                Option<Vec<String>>,
-                // Stream Body
-                Option<bool>,
-            ),
-            (),
-        >;
-
-        type Args2 = KwArgs<
-            (),
-            (
-                // Before Fork
-                Option<Proc>,
-                // After Fork
-                Option<Proc>,
-                // Scheduler Class
-                Option<String>,
-                // Worker Memory Limit
-                Option<u64>,
-                // Silence
-                Option<bool>,
-            ),
-            (),
-        >;
-
-        let args1: Args1 = extract_args(
-            &scan_args,
-            &["app"],
-            &[
-                "workers",
-                "threads",
-                "shutdown_timeout",
-                "script_name",
-                "binds",
-                "stream_body",
-            ],
-        )?;
-
-        let args2: Args2 = extract_args(
-            &scan_args,
-            &[],
-            &[
-                "before_fork",
-                "after_fork",
-                "scheduler_class",
-                "worker_memory_limit",
-                "silence",
-            ],
-        )?;
-
-        let config = ServerConfig {
-            app: HeapVal::from(args1.required.0),
-            workers: max(args1.optional.0.unwrap_or(1), 1),
-            threads: max(args1.optional.1.unwrap_or(1), 1),
-            shutdown_timeout: args1.optional.2.unwrap_or(5.0),
-            script_name: args1.optional.3.unwrap_or("".to_string()),
-            binds: Mutex::new(
-                args1
-                    .optional
-                    .4
-                    .unwrap_or_else(|| vec![DEFAULT_BIND.to_string()])
-                    .into_iter()
-                    .map(|s| s.parse())
-                    .collect::<itsi_error::Result<Vec<Bind>>>()?,
-            ),
-            stream_body: args1.optional.5,
-            before_fork: Mutex::new(args2.optional.0.map(|p| {
-                let opaque_proc = Opaque::from(p);
-                Box::new(move || {
-                    opaque_proc
-                        .get_inner_with(&Ruby::get().unwrap())
-                        .call::<_, Value>(())
-                        .unwrap();
-                }) as Box<dyn FnOnce() + Send + Sync>
-            })),
-            after_fork: Mutex::new(Arc::new(args2.optional.1.map(|p| {
-                let opaque_proc = Opaque::from(p);
-                Box::new(move || {
-                    opaque_proc
-                        .get_inner_with(&Ruby::get().unwrap())
-                        .call::<_, Value>(())
-                        .unwrap();
-                }) as Box<dyn Fn() + Send + Sync>
-            }))),
-            scheduler_class: args2.optional.2.clone(),
-            worker_memory_limit: args2.optional.3,
-            silence: args2.optional.4.is_some_and(|s| s),
-            strategy: RwLock::new(None),
-        };
-
-        if !config.silence {
-            if let Some(scheduler_class) = args2.optional.2 {
-                info!(scheduler_class, fiber_scheduler = true);
-            } else {
-                info!(fiber_scheduler = false);
-            }
-        }
-
-        Ok(Server {
-            config: Arc::new(config),
-        })
-    }
-
-    #[instrument(name = "Bind", skip_all, fields(binds=format!("{:?}", self.config.binds.lock())))]
-    pub(crate) fn build_listeners(&self) -> Result<Arc<Vec<Arc<Listener>>>> {
-        let listeners = self
-            .config
-            .binds
-            .lock()
-            .iter()
-            .cloned()
-            .map(Listener::try_from)
-            .collect::<std::result::Result<Vec<Listener>, _>>()?
-            .into_iter()
-            .map(Arc::new)
-            .collect::<Vec<_>>();
-        info!("Bound {:?} listeners", listeners.len());
-        Ok(Arc::new(listeners))
-    }
-
-    pub(crate) fn build_strategy(self, listeners: Arc<Vec<Arc<Listener>>>) -> Result<()> {
-        let server = Arc::new(self);
-        let server_clone = server.clone();
-
-        let strategy = if server.config.workers == 1 {
-            ServeStrategy::Single(Arc::new(SingleMode::new(
-                server,
-                listeners,
-                SIGNAL_HANDLER_CHANNEL.0.clone(),
-            )?))
-        } else {
-            ServeStrategy::Cluster(Arc::new(ClusterMode::new(
-                server,
-                listeners,
-                SIGNAL_HANDLER_CHANNEL.0.clone(),
-            )))
-        };
-
-        *server_clone.strategy.write() = Some(strategy);
-        Ok(())
-    }
-
-    pub fn stop(&self) -> Result<()> {
-        send_shutdown_event();
-        Ok(())
-    }
-
-    pub fn start(&self) -> Result<()> {
-        if self.silence {
-            run_silently(|| self.build_and_run_strategy())
-        } else {
-            self.build_and_run_strategy()
-        }
-    }
-
-    fn build_and_run_strategy(&self) -> Result<()> {
-        reset_signal_handlers();
-        let rself = self.clone();
-        let listeners = self.build_listeners()?;
-        let listeners_clone = listeners.clone();
-        call_without_gvl(move || -> Result<()> {
-            rself.clone().build_strategy(listeners_clone)?;
-            if let Err(e) = rself.clone().strategy.read().as_ref().unwrap().run() {
-                error!("Error running server: {}", e);
-                rself.strategy.read().as_ref().unwrap().stop()?;
-            }
-            Ok(())
-        })?;
-        clear_signal_handlers();
-        self.strategy.write().take();
-        info!("Server stopped");
-        Ok(())
-    }
-}