itsi-server 0.1.1 → 0.1.13

data/ext/itsi_server/Cargo.toml

@@ -10,20 +10,80 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-magnus = { version = "0.7.1", features = ["bytes"] }
-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.23"
-bytes = "1.3"
-rcgen = { version = "0.13.2", features = ["x509-parser", "pem"] }
+async-compression = { version = "0.4.21", features = [
+  "tokio",
+  "zstd",
+  "brotli",
+  "deflate",
+  "gzip",
+] }
+async-channel = "2.3.1"
+async-trait = "0.1.87"
 base64 = "0.22.1"
+bytes = "1.3"
+chrono = "0.4.35"
+crossbeam = "0.8.4"
+dashmap = "6.1.0"
+derive_more = { version = "2.0.1", features = ["debug"] }
+dirs = "6.0.0"
+either = "1.15.0"
+fnv = "1.0.7"
+fs2 = "0.4.3"
+futures = "0.3.31"
+globset = "0.4.16"
+hmac = "0.12.1"
+http = "1.3.1"
 http-body-util = "0.1.2"
+httpdate = "1.0.3"
+httparse = "1.10.1"
 hyper = { version = "1.5.0", features = ["full", "server", "http1", "http2"] }
-tokio = { version = "1", features = ["full"] }
+hyper-staticfile = "0.10.1"
 hyper-util = { version = "0.1.10", features = ["full"] }
-derive_more = { version = "2.0.1", features = ["debug"] }
-http = "1.2.0"
+itsi_error = { path = "../itsi_error" }
+itsi_rb_helpers = { path = "../itsi_rb_helpers" }
+itsi_tracing = { path = "../itsi_tracing" }
+jwt-simple = "0.12.12"
+magnus = { version = "0.7.1", features = ["bytes", "rb-sys"] }
+moka = { version = "0.12.10", features = ["sync"] }
+notify = { version = "8.0.0" }
+nix = { version = "0.29.0", features = [
+  "socket",
+  "uio",
+  "signal",
+  "fs",
+  "process",
+] }
+num_cpus = "1.16.0"
+parking_lot = "0.12.3"
+pin-project = "1.1.9"
+rand = "0.9.0"
+rb-sys = "0.9.111"
+rcgen = { version = "0.13.2", features = ["x509-parser", "pem"] }
+regex = "1.11.1"
+reqwest = { version = "0.12.15", features = ["stream"] }
+ring = "0.17.14"
+route-recognizer = "0.3.1"
+redis = { version = "0.29.2", features = [
+  "tokio-comp",
+  "r2d2",
+  "tokio-rustls-comp",
+  "connection-manager",
+] }
+rustls = "0.23.23"
+rustls-pemfile = "2.2.0"
+serde = "1.0.219"
+serde_json = "1.0.140"
+serde_magnus = "0.9.0"
+sha2 = "0.10.8"
+socket2 = "0.5.8"
+sysinfo = "0.33.1"
+tempfile = "3.18.0"
+tokio = { version = "1.44.1", features = ["full"] }
+tokio-rustls = "0.26.2"
+tokio-rustls-acme = "0.6.0"
+tokio-stream = "0.1.17"
+tokio-util = "0.7.13"
+tracing = "0.1.41"
+url = "2.5.4"
+uuid = "1.16.0"
+md5 = "0.7.0"

data/ext/itsi_server/extconf.rb

@@ -3,4 +3,4 @@
 require "mkmf"
 require "rb_sys/mkmf"
 
-create_rust_makefile("itsi_server/itsi_server")
+create_rust_makefile("itsi/server/itsi_server")

data/ext/itsi_server/src/env.rs

@@ -0,0 +1,43 @@
+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/ext/itsi_server/src/lib.rs

@@ -1,52 +1,112 @@
-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;
-
-pub mod request;
+use magnus::{error::Result, function, method, Module, Object, Ruby};
+use ruby_types::{
+    itsi_body_proxy::ItsiBodyProxy, itsi_grpc_request::ItsiGrpcRequest,
+    itsi_grpc_stream::ItsiGrpcStream, itsi_http_request::ItsiHttpRequest,
+    itsi_http_response::ItsiHttpResponse, itsi_server::ItsiServer, ITSI_BODY_PROXY,
+    ITSI_GRPC_REQUEST, ITSI_GRPC_RESPONSE, ITSI_GRPC_STREAM, ITSI_MODULE, ITSI_REQUEST,
+    ITSI_RESPONSE, ITSI_SERVER,
+};
+use server::signal::reset_signal_handlers;
+use tracing::*;
+pub mod env;
+pub mod ruby_types;
 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| {
-    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_STREAM_WRITER: Lazy<RClass> = Lazy::new(|ruby| {
-    ruby.get_inner(&ITSI_MODULE)
-        .define_class("StreamWriter", ruby.class_object())
-        .unwrap()
-});
 
 #[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_method("start", method!(Server::start, 0))?;
+    server.define_singleton_method("new", function!(ItsiServer::new, 3))?;
+    server.define_singleton_method("reset_signal_handlers", function!(reset_signal_handlers, 0))?;
+    server.define_method("start", method!(ItsiServer::start, 0))?;
+    server.define_method("stop", method!(ItsiServer::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("remote_addr", method!(ItsiRequest::remote_addr, 0))?;
-    request.define_method("port", method!(ItsiRequest::port, 0))?;
-    request.define_method("body", method!(ItsiRequest::body, 0))?;
-
-    let stream_writer = ruby.get_inner(&ITSI_STREAM_WRITER);
-    stream_writer.define_method("write", method!(StreamWriter::write, 1))?;
+    request.define_method("path", method!(ItsiHttpRequest::path, 0))?;
+    request.define_method("script_name", method!(ItsiHttpRequest::script_name, 0))?;
+    request.define_method("query_string", method!(ItsiHttpRequest::query_string, 0))?;
+    request.define_method("method", method!(ItsiHttpRequest::method, 0))?;
+    request.define_method("version", method!(ItsiHttpRequest::version, 0))?;
+    request.define_method("rack_protocol", method!(ItsiHttpRequest::rack_protocol, 0))?;
+    request.define_method("host", method!(ItsiHttpRequest::host, 0))?;
+    request.define_method("headers", method!(ItsiHttpRequest::headers, 0))?;
+    request.define_method("header", method!(ItsiHttpRequest::header, 1))?;
+    request.define_method("[]", method!(ItsiHttpRequest::header, 1))?;
+    request.define_method("scheme", method!(ItsiHttpRequest::scheme, 0))?;
+    request.define_method("remote_addr", method!(ItsiHttpRequest::remote_addr, 0))?;
+    request.define_method("port", method!(ItsiHttpRequest::port, 0))?;
+    request.define_method("body", method!(ItsiHttpRequest::body, 0))?;
+    request.define_method("response", method!(ItsiHttpRequest::response, 0))?;
+    request.define_method("json?", method!(ItsiHttpRequest::is_json, 0))?;
+    request.define_method("html?", method!(ItsiHttpRequest::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("[]=", method!(ItsiHttpResponse::add_header, 2))?;
+    response.define_method("add_header", method!(ItsiHttpResponse::add_header, 2))?;
+    response.define_method("add_headers", method!(ItsiHttpResponse::add_headers, 1))?;
+    response.define_method("status=", method!(ItsiHttpResponse::set_status, 1))?;
+    response.define_method("send_frame", method!(ItsiHttpResponse::send_frame, 1))?;
+    response.define_method("<<", method!(ItsiHttpResponse::send_frame, 1))?;
+    response.define_method("write", method!(ItsiHttpResponse::send_frame, 1))?;
+    response.define_method("read", method!(ItsiHttpResponse::recv_frame, 0))?;
+    response.define_method(
+        "send_and_close",
+        method!(ItsiHttpResponse::send_and_close, 1),
+    )?;
+    response.define_method("close_write", method!(ItsiHttpResponse::close_write, 0))?;
+    response.define_method("close_read", method!(ItsiHttpResponse::close_read, 0))?;
+    response.define_method("close", method!(ItsiHttpResponse::close, 0))?;
+    response.define_method("hijack", method!(ItsiHttpResponse::hijack, 1))?;
+    response.define_method("json?", method!(ItsiHttpResponse::is_json, 0))?;
+    response.define_method("html?", method!(ItsiHttpResponse::is_html, 0))?;
+
+    let grpc_request = ruby.get_inner(&ITSI_GRPC_REQUEST);
+
+    grpc_request.define_method("service_name", method!(ItsiGrpcRequest::service_name, 0))?;
+    grpc_request.define_method("method_name", method!(ItsiGrpcRequest::method_name, 0))?;
+    grpc_request.define_method("stream", method!(ItsiGrpcRequest::stream, 0))?;
+    grpc_request.define_method("json?", method!(ItsiGrpcRequest::is_json, 0))?;
+    grpc_request.define_method(
+        "content_type",
+        method!(ItsiGrpcRequest::content_type_str, 0),
+    )?;
+
+    let grpc_stream = ruby.get_inner(&ITSI_GRPC_STREAM);
+    grpc_stream.define_method("read", method!(ItsiGrpcStream::read, 1))?;
+    grpc_stream.define_method("write", method!(ItsiGrpcStream::write, 1))?;
+    grpc_stream.define_method("flush", method!(ItsiGrpcStream::flush, 0))?;
+    grpc_stream.define_method("send_trailers", method!(ItsiGrpcStream::send_trailers, 1))?;
+
+    let _grpc_response = ruby.get_inner(&ITSI_GRPC_RESPONSE);
 
     Ok(())
 }
+
+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);
+}

data/ext/itsi_server/src/ruby_types/itsi_body_proxy/big_bytes.rs

@@ -0,0 +1,109 @@
+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
+
+/// A container that will hold 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())
+    }
+
+    /// Returns either the raw bytes, or the file path of the BigBytes
+    ///
+    /// - 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()))
+            }
+        }
+    }
+
+    /// Turn this into a value that can be used in Ruby.
+    pub fn as_value(&self) -> Option<Value> {
+        match self {
+            BigBytes::InMemory(bytes) => {
+                let bytes = Bytes::from(bytes.to_owned());
+                if bytes.is_empty() {
+                    None
+                } else {
+                    Some(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();
+                Some(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/ext/itsi_server/src/ruby_types/itsi_body_proxy/mod.rs

@@ -0,0 +1,141 @@
+pub mod big_bytes;
+use 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) -> Option<Value> {
+        match self {
+            ItsiBody::Buffered(bytes) => bytes.as_value(),
+            ItsiBody::Stream(proxy) => Some(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))
+    }
+
+    pub fn to_bytes(&self) -> MagnusResult<Vec<u8>> {
+        self.verify_open()?;
+        let mut stream = self.incoming.lock();
+        let mut buf = self.buf.lock();
+
+        while 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);
+        }
+
+        Ok(buf.clone())
+    }
+
+    /// 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);
+    }
+}