itsi 0.1.9 → 0.1.12

data/gems/server/ext/itsi_server/Cargo.toml

@@ -1,47 +0,0 @@
-[package]
-name = "itsi-server"
-version = "0.1.0"
-edition = "2021"
-authors = ["Wouter Coppieters <wc@pico.net.nz>"]
-license = "MIT"
-publish = false
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-magnus = { version = "0.7.1", features = ["bytes", "rb-sys"] }
-itsi_tracing = { path = "../itsi_tracing" }
-itsi_rb_helpers = { path = "../itsi_rb_helpers" }
-itsi_error = { path = "../itsi_error" }
-socket2 = "0.5.8"
-parking_lot = "0.12.3"
-rustls-pemfile = "2.2.0"
-tokio-rustls = "0.26.2"
-bytes = "1.3"
-tokio-rustls-acme = "0.6.0"
-rcgen = { version = "0.13.2", features = ["x509-parser", "pem"] }
-base64 = "0.22.1"
-http-body-util = "0.1.2"
-hyper = { version = "1.5.0", features = ["full", "server", "http1", "http2"] }
-tokio = { version = "1", features = ["full"] }
-hyper-util = { version = "0.1.10", features = ["full"] }
-derive_more = { version = "2.0.1", features = ["debug"] }
-http = "1.3.1"
-crossbeam = "0.8.4"
-futures = "0.3.31"
-nix = { version = "0.29.0", features = ["socket", "uio", "signal"] }
-pin-project = "1.1.9"
-rb-sys = "0.9.111"
-tracing = "0.1.41"
-tokio-util = "0.7.13"
-tokio-stream = "0.1.17"
-httparse = "1.10.1"
-async-channel = "2.3.1"
-tempfile = "3.18.0"
-sysinfo = "0.33.1"
-rustls = "0.23.23"
-fs2 = "0.4.3"
-ring = "0.17.14"
-async-trait = "0.1.87"
-dirs = "6.0.0"

data/gems/server/ext/itsi_server/extconf.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-require "mkmf"
-require "rb_sys/mkmf"
-
-create_rust_makefile("itsi/server/itsi_server")

data/gems/server/ext/itsi_server/src/body_proxy/big_bytes.rs

@@ -1,104 +0,0 @@
-use bytes::Bytes;
-use magnus::{IntoValue, Ruby, Value};
-use std::io::{Result as IoResult, Write};
-use std::path::PathBuf;
-use tempfile::NamedTempFile;
-
-const THRESHOLD: usize = 1024 * 1024; // 1 MB
-
-/// An container that holds data in memory if it’s small, or in a temporary file on disk if it exceeds THRESHOLD.
-/// Used for providing Rack input data.
-pub enum BigBytes {
-    InMemory(Vec<u8>),
-    OnDisk(NamedTempFile),
-}
-
-/// The result type for reading the contents of a `BigBytes` value.
-pub enum BigBytesReadResult {
-    /// When the data is stored in memory, returns the cached bytes.
-    InMemory(Vec<u8>),
-    /// When the data is stored on disk, returns the path to the temporary file.
-    OnDisk(PathBuf),
-}
-
-impl BigBytes {
-    /// Creates a new, empty BigBytes instance (initially in memory).
-    pub fn new() -> Self {
-        BigBytes::InMemory(Vec::new())
-    }
-
-    /// Reads the entire contents that have been written.
-    ///
-    /// - If stored in memory, returns a clone of the bytes.
-    /// - If stored on disk, returns the file path of the temporary file.
-    pub fn read(&self) -> IoResult<BigBytesReadResult> {
-        match self {
-            BigBytes::InMemory(vec) => Ok(BigBytesReadResult::InMemory(vec.clone())),
-            BigBytes::OnDisk(temp_file) => {
-                // Flush to be safe, then return the file path.
-                temp_file.as_file().sync_all()?;
-                Ok(BigBytesReadResult::OnDisk(temp_file.path().to_path_buf()))
-            }
-        }
-    }
-
-    pub fn as_value(&self) -> Value {
-        match self {
-            BigBytes::InMemory(bytes) => {
-                let bytes = Bytes::from(bytes.to_owned());
-                bytes.into_value()
-            }
-            BigBytes::OnDisk(path) => {
-                let ruby = Ruby::get().unwrap();
-                let rarray = ruby.ary_new();
-                rarray.push(path.path().to_str().unwrap().into_value()).ok();
-                rarray.into_value()
-            }
-        }
-    }
-}
-
-impl Drop for BigBytes {
-    fn drop(&mut self) {
-        match self {
-            BigBytes::InMemory(_) => {}
-            BigBytes::OnDisk(path) => {
-                let _ = std::fs::remove_file(path);
-            }
-        }
-    }
-}
-
-impl Default for BigBytes {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Write for BigBytes {
-    fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
-        match self {
-            BigBytes::InMemory(vec) => {
-                // Check if writing the new bytes would exceed the threshold.
-                if vec.len() + buf.len() > THRESHOLD {
-                    let mut tmp = NamedTempFile::new()?;
-                    tmp.write_all(vec)?;
-                    tmp.write_all(buf)?;
-                    *self = BigBytes::OnDisk(tmp);
-                    Ok(buf.len())
-                } else {
-                    vec.extend_from_slice(buf);
-                    Ok(buf.len())
-                }
-            }
-            BigBytes::OnDisk(tmp_file) => tmp_file.write(buf),
-        }
-    }
-
-    fn flush(&mut self) -> IoResult<()> {
-        match self {
-            BigBytes::InMemory(_) => Ok(()),
-            BigBytes::OnDisk(tmp_file) => tmp_file.flush(),
-        }
-    }
-}

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

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

data/gems/server/ext/itsi_server/src/env.rs

@@ -1,43 +0,0 @@
-use std::{
-    env::{var, VarError},
-    path::PathBuf,
-    sync::LazyLock,
-};
-
-type StringVar = LazyLock<String>;
-type MaybeStringVar = LazyLock<Result<String, VarError>>;
-type PathVar = LazyLock<PathBuf>;
-
-/// ACME Configuration for auto-generating production certificates
-/// *ITSI_ACME_CACHE_DIR* - Directory to store cached certificates
-/// so that these are not regenerated every time the server starts
-pub static ITSI_ACME_CACHE_DIR: StringVar = LazyLock::new(|| {
-    var("ITSI_ACME_CACHE_DIR").unwrap_or_else(|_| "./.rustls_acme_cache".to_string())
-});
-
-/// *ITSI_ACME_CONTACT_EMAIL* - Contact Email address to provide to ACME server during certificate renewal
-pub static ITSI_ACME_CONTACT_EMAIL: MaybeStringVar =
-    LazyLock::new(|| var("ITSI_ACME_CONTACT_EMAIL"));
-
-/// *ITSI_ACME_CA_PEM_PATH* - Optional CA Pem path, used for testing with non-trusted CAs for certifcate generation.
-pub static ITSI_ACME_CA_PEM_PATH: MaybeStringVar = LazyLock::new(|| var("ITSI_ACME_CA_PEM_PATH"));
-
-/// *ITSI_ACME_DIRECTORY_URL* - Directory URL to use for ACME certificate generation.
-pub static ITSI_ACME_DIRECTORY_URL: StringVar = LazyLock::new(|| {
-    var("ITSI_ACME_DIRECTORY_URL")
-        .unwrap_or_else(|_| "https://acme-v02.api.letsencrypt.org/directory".to_string())
-});
-
-/// *ITSI_ACME_LOCK_FILE_NAME* - Name of the lock file used to prevent concurrent certificate generation.
-pub static ITSI_ACME_LOCK_FILE_NAME: StringVar =
-    LazyLock::new(|| var("ITSI_ACME_LOCK_FILE_NAME").unwrap_or(".acme.lock".to_string()));
-
-pub static ITSI_LOCAL_CA_DIR: PathVar = LazyLock::new(|| {
-    var("ITSI_LOCAL_CA_DIR")
-        .map(PathBuf::from)
-        .unwrap_or_else(|_| {
-            dirs::home_dir()
-                .expect("Failed to find HOME directory when initializing ITSI_LOCAL_CA_DIR")
-                .join(".itsi")
-        })
-});

data/gems/server/ext/itsi_server/src/lib.rs

@@ -1,112 +0,0 @@
-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 response::itsi_response::ItsiResponse;
-use server::{itsi_server::Server, signal::reset_signal_handlers};
-use tracing::*;
-
-pub mod body_proxy;
-pub mod env;
-pub mod request;
-pub mod response;
-pub mod server;
-
-pub static ITSI_MODULE: Lazy<RModule> = Lazy::new(|ruby| ruby.define_module("Itsi").unwrap());
-pub static ITSI_SERVER: Lazy<RClass> = Lazy::new(|ruby| {
-    ruby.get_inner(&ITSI_MODULE)
-        .define_class("Server", ruby.class_object())
-        .unwrap()
-});
-pub static ITSI_REQUEST: Lazy<RClass> = Lazy::new(|ruby| {
-    ruby.get_inner(&ITSI_MODULE)
-        .define_class("Request", ruby.class_object())
-        .unwrap()
-});
-
-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("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();
-    rustls::crypto::aws_lc_rs::default_provider()
-        .install_default()
-        .ok();
-
-    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))?;
-    server.define_method("stop", method!(Server::stop, 0))?;
-
-    let request = ruby.get_inner(&ITSI_REQUEST);
-    request.define_method("path", method!(ItsiRequest::path, 0))?;
-    request.define_method("script_name", method!(ItsiRequest::script_name, 0))?;
-    request.define_method("query_string", method!(ItsiRequest::query_string, 0))?;
-    request.define_method("method", method!(ItsiRequest::method, 0))?;
-    request.define_method("version", method!(ItsiRequest::version, 0))?;
-    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))?;
-    request.define_method("json?", method!(ItsiRequest::is_json, 0))?;
-    request.define_method("html?", method!(ItsiRequest::is_html, 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 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))?;
-    response.define_method("json?", method!(ItsiResponse::is_json, 0))?;
-    response.define_method("html?", method!(ItsiResponse::is_html, 0))?;
-
-    Ok(())
-}

data/gems/server/ext/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/gems/server/ext/itsi_server/src/request/mod.rs

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