itsi 0.1.8 → 0.1.11

data/gems/scheduler/Cargo.lock

@@ -68,9 +68,9 @@ checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
 
 [[package]]
 name = "cc"
-version = "1.2.16"
+version = "1.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be714c154be609ec7f5dad223a33bf1482fff90472de28f7362806e6d4832b8c"
+checksum = "c736e259eea577f443d5c86c304f9f4ae0295c43f3ba05c21f1d66b5f06001af"
 dependencies = [
  "shlex",
 ]
@@ -186,9 +186,9 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.15"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
+checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674"
 
 [[package]]
 name = "itsi-scheduler"
@@ -507,9 +507,9 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.10"
+version = "0.5.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b8c0c260b63a8219631167be35e6a988e9554dbd323f8bd08439c8ed1302bd1"
+checksum = "82b568323e98e49e2a0899dcee453dd679fae22d69adf9b11dd508d1549b7e2f"
 dependencies = [
  "bitflags",
 ]
@@ -560,9 +560,9 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "ring"
-version = "0.17.11"
+version = "0.17.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da5349ae27d3887ca812fb375b45a4fbb36d8d12d2df394968cd86e35683fe73"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
 dependencies = [
  "cc",
  "cfg-if",
@@ -586,9 +586,9 @@ checksum = "917ce264624a4b4db1c364dcc35bfca9ded014d0a958cd47ad3e960e988ea51c"
 
 [[package]]
 name = "ryu"
-version = "1.0.20"
+version = "1.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
+checksum = "6ea1a2d0a644769cc99faa24c3ad26b379b786fe7c36fd3c546254801650e6dd"
 
 [[package]]
 name = "scopeguard"
@@ -624,9 +624,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.140"
+version = "1.0.139"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
+checksum = "44f86c3acccc9c65b153fe1b85a3be07fe5515274ec9f0653b4a0875731c72a6"
 dependencies = [
  "itoa",
  "memchr",

data/gems/scheduler/ext/itsi_rb_helpers/src/lib.rs

@@ -1,7 +1,8 @@
-use std::{os::raw::c_void, ptr::null_mut, sync::Arc};
+use std::{os::raw::c_void, ptr::null_mut};
 
 use magnus::{
     RArray, Ruby, Thread, Value,
+    block::Proc,
     rb_sys::FromRawValue,
     value::{LazyId, ReprValue},
 };
@@ -17,6 +18,7 @@ static ID_LIST: LazyId = LazyId::new("list");
 static ID_EQ: LazyId = LazyId::new("==");
 static ID_ALIVE: LazyId = LazyId::new("alive?");
 static ID_THREAD_VARIABLE_GET: LazyId = LazyId::new("thread_variable_get");
+static ID_BACKTRACE: LazyId = LazyId::new("backtrace");
 
 pub fn schedule_thread() {
     unsafe {
@@ -120,20 +122,30 @@ where
     *result_box
 }
 
-pub fn fork(after_fork: Arc<Option<impl Fn()>>) -> Option<i32> {
+pub fn fork(after_fork: Option<HeapValue<Proc>>) -> Option<i32> {
     let ruby = Ruby::get().unwrap();
     let fork_result = ruby
         .module_kernel()
         .funcall::<_, _, Option<i32>>(*ID_FORK, ())
         .unwrap();
     if fork_result.is_none() {
-        if let Some(f) = &*after_fork {
-            f()
+        if let Some(proc) = after_fork {
+            call_proc_and_log_errors(proc)
         }
     }
     fork_result
 }
 
+pub fn call_proc_and_log_errors(proc: HeapValue<Proc>) {
+    if let Err(e) = proc.call::<_, Value>(()) {
+        if let Some(value) = e.value() {
+            print_rb_backtrace(value);
+        } else {
+            eprintln!("Error occurred {:?}", e);
+        }
+    }
+}
+
 pub fn kill_threads<T>(threads: Vec<T>)
 where
     T: ReprValue,
@@ -176,3 +188,14 @@ pub fn terminate_non_fork_safe_threads() {
 
     kill_threads(non_fork_safe_threads);
 }
+
+pub fn print_rb_backtrace(rb_err: Value) {
+    let backtrace = rb_err
+        .funcall::<_, _, Vec<String>>(*ID_BACKTRACE, ())
+        .unwrap_or_default();
+
+    eprintln!("Ruby exception {:?}", rb_err);
+    for line in backtrace {
+        eprintln!("{}", line);
+    }
+}

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

@@ -24,7 +24,7 @@ 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"] }
+tokio = { version = "1.44.1", features = ["full"] }
 hyper-util = { version = "0.1.10", features = ["full"] }
 derive_more = { version = "2.0.1", features = ["debug"] }
 http = "1.3.1"
@@ -45,3 +45,6 @@ fs2 = "0.4.3"
 ring = "0.17.14"
 async-trait = "0.1.87"
 dirs = "6.0.0"
+regex = "1.11.1"
+route-recognizer = "0.3.1"
+fnv = "1.0.7"

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

@@ -1,5 +1,8 @@
 use body_proxy::itsi_body_proxy::ItsiBodyProxy;
-use magnus::{error::Result, function, method, value::Lazy, Module, Object, RClass, RModule, Ruby};
+use magnus::{
+    error::Result, function, method, value::Lazy, Module, Object, RClass, RHash, RModule, Ruby,
+};
+use regex::{Regex, RegexSet};
 use request::itsi_request::ItsiRequest;
 use response::itsi_response::ItsiResponse;
 use server::{itsi_server::Server, signal::reset_signal_handlers};
@@ -54,6 +57,70 @@ pub fn log_error(msg: String) {
     error!(msg);
 }
 
+const ROUTES: [&str; 39] = [
+    r"(?-u)^/organisations/(?<organisation_id>\d+)/users/(?<user_id>\d+)$",
+    r"(?-u)^/projects/(?<project_id>\d+)/tasks/(?<task_id>\d+)$",
+    r"(?-u)^/products/(?<product_id>\d+)(?:/reviews/(?<review_id>\d+))?$",
+    r"(?-u)^/orders/(?<order_id>\d+)/items(?:/(?<item_id>\d+))?$",
+    r"(?-u)^/posts/(?<post_id>\d+)/comments(?:/(?<comment_id>\d+))?$",
+    r"(?-u)^/teams/(?<team_id>\d+)(?:/members/(?<member_id>\d+))?$",
+    r"(?-u)^/categories/(?<category_id>\d+)/subcategories(?:/(?<subcategory_id>\d+))?$",
+    r"(?-u)^/departments/(?<department_id>\d+)/employees/(?<employee_id>\d+)$",
+    r"(?-u)^/events/(?<event_id>\d+)(?:/sessions/(?<session_id>\d+))?$",
+    r"(?-u)^/invoices/(?<invoice_id>\d+)/payments(?:/(?<payment_id>\d+))?$",
+    r"(?-u)^/tickets/(?<ticket_id>\d+)(?:/responses/(?<response_id>\d+))?$",
+    r"(?-u)^/forums/(?<forum_id>\d+)(?:/threads/(?<thread_id>\d+))?$",
+    r"(?-u)^/subscriptions/(?<subscription_id>\d+)/plans(?:/(?<plan_id>\d+))?$",
+    r"(?-u)^/profiles/(?<profile_id>\d+)/settings$",
+    r"(?-u)^/organizations/(?<organization_id>\d+)/billing(?:/(?<billing_id>\d+))?$",
+    r"(?-u)^/vendors/(?<vendor_id>\d+)/products(?:/(?<product_id>\d+))?$",
+    r"(?-u)^/courses/(?<course_id>\d+)/modules(?:/(?<module_id>\d+))?$",
+    r"(?-u)^/accounts/(?<account_id>\d+)(?:/transactions/(?<transaction_id>\d+))?$",
+    r"(?-u)^/warehouses/(?<warehouse_id>\d+)/inventory(?:/(?<inventory_id>\d+))?$",
+    r"(?-u)^/campaigns/(?<campaign_id>\d+)/ads(?:/(?<ad_id>\d+))?$",
+    r"(?-u)^/applications/(?<application_id>\d+)/stages(?:/(?<stage_id>\d+))?$",
+    r"(?-u)^/notifications/(?<notification_id>\d+)$",
+    r"(?-u)^/albums/(?<album_id>\d+)/photos(?:/(?<photo_id>\d+))?$",
+    r"(?-u)^/news/(?<news_id>\d+)/articles(?:/(?<article_id>\d+))?$",
+    r"(?-u)^/libraries/(?<library_id>\d+)/books(?:/(?<book_id>\d+))?$",
+    r"(?-u)^/universities/(?<university_id>\d+)/students(?:/(?<student_id>\d+))?$",
+    r"(?-u)^/banks/(?<bank_id>\d+)/branches(?:/(?<branch_id>\d+))?$",
+    r"(?-u)^/vehicles/(?<vehicle_id>\d+)/services(?:/(?<service_id>\d+))?$",
+    r"(?-u)^/hotels/(?<hotel_id>\d+)/rooms(?:/(?<room_id>\d+))?$",
+    r"(?-u)^/doctors/(?<doctor_id>\d+)/appointments(?:/(?<appointment_id>\d+))?$",
+    r"(?-u)^/gyms/(?<gym_id>\d+)/memberships(?:/(?<membership_id>\d+))?$",
+    r"(?-u)^/restaurants/(?<restaurant_id>\d+)/menus(?:/(?<menu_id>\d+))?$",
+    r"(?-u)^/parks/(?<park_id>\d+)/events(?:/(?<event_id>\d+))?$",
+    r"(?-u)^/theaters/(?<theater_id>\d+)/shows(?:/(?<show_id>\d+))?$",
+    r"(?-u)^/museums/(?<museum_id>\d+)/exhibits(?:/(?<exhibit_id>\d+))?$",
+    r"(?-u)^/stadiums/(?<stadium_id>\d+)/games(?:/(?<game_id>\d+))?$",
+    r"(?-u)^/schools/(?<school_id>\d+)/classes(?:/(?<class_id>\d+))?$",
+    r"(?-u)^/clubs/(?<club_id>\d+)/events(?:/(?<event_id>\d+))?$",
+    r"(?-u)^/festivals/(?<festival_id>\d+)/tickets(?:/(?<ticket_id>\d+))?$",
+];
+use std::sync::LazyLock;
+
+static REGEX_SET: LazyLock<RegexSet> = LazyLock::new(|| RegexSet::new(ROUTES).unwrap());
+static REGEXES: LazyLock<Vec<Regex>> =
+    LazyLock::new(|| ROUTES.iter().map(|&r| Regex::new(r).unwrap()).collect());
+
+fn match_route(input: String) -> Result<Option<(usize, Option<RHash>)>> {
+    if let Some(index) = REGEX_SET.matches(&input).iter().next() {
+        let regex = &REGEXES[index];
+        if let Some(captures) = regex.captures(&input) {
+            let params = RHash::with_capacity(captures.len());
+            for name in regex.capture_names().flatten() {
+                if let Some(value) = captures.name(name) {
+                    params.aset(name, value.as_str()).ok();
+                }
+            }
+            return Ok(Some((index, Some(params))));
+        }
+        return Ok(Some((index, None)));
+    }
+    Ok(None)
+}
+
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<()> {
     itsi_tracing::init();
@@ -62,6 +129,7 @@ fn init(ruby: &Ruby) -> Result<()> {
         .ok();
 
     let itsi = ruby.get_inner(&ITSI_MODULE);
+    itsi.define_singleton_method("match_route", function!(match_route, 1))?;
     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))?;
@@ -71,6 +139,7 @@ fn init(ruby: &Ruby) -> Result<()> {
     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))?;
@@ -86,6 +155,8 @@ fn init(ruby: &Ruby) -> Result<()> {
     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))?;
@@ -102,6 +173,8 @@ fn init(ruby: &Ruby) -> Result<()> {
     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/scheduler/ext/itsi_server/src/request/itsi_request.rs

@@ -13,10 +13,11 @@ use crate::{
 use bytes::Bytes;
 use derive_more::Debug;
 use futures::StreamExt;
-use http::{request::Parts, Response, StatusCode};
+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_rb_helpers::print_rb_backtrace;
 use itsi_tracing::{debug, error};
 use magnus::{
     error::{ErrorType, Result as MagnusResult},
@@ -33,7 +34,6 @@ use tokio::sync::{
 };
 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)]
@@ -49,6 +49,7 @@ pub struct ItsiRequest {
     pub server: Arc<Server>,
     pub response: ItsiResponse,
     pub start: Instant,
+    pub content_type: String,
 }
 
 impl fmt::Display for ItsiRequest {
@@ -82,6 +83,14 @@ impl ItsiRequest {
         }
     }
 
+    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,
@@ -106,14 +115,7 @@ impl ItsiRequest {
             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());
@@ -175,8 +177,27 @@ impl ItsiRequest {
                 server,
                 listener,
                 version: format!("{:?}", &parts.version),
-                response: ItsiResponse::new(parts.clone(), response_channel.0),
+                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,

data/gems/scheduler/ext/itsi_server/src/response/itsi_response.rs

@@ -37,6 +37,7 @@ use crate::server::serve_strategy::single_mode::RunningPhase;
 #[derive(Debug, Clone)]
 pub struct ItsiResponse {
     pub data: Arc<ResponseData>,
+    pub accept: String,
 }
 
 #[derive(Debug)]
@@ -76,7 +77,6 @@ impl ItsiResponse {
                 (ReceiverStream::new(receiver), shutdown_rx),
                 |(mut receiver, mut shutdown_rx)| async move {
                     if let RunningPhase::ShutdownPending = *shutdown_rx.borrow() {
-                        warn!("Disconnecting streaming client.");
                         return None;
                     }
                     loop {
@@ -279,7 +279,8 @@ impl ItsiResponse {
         if let Some(writer) = writer.write().as_ref() {
             writer
                 .blocking_send(Some(frame))
-                .map_err(|_| itsi_error::ItsiError::ClientConnectionClosed)?;
+                .map_err(|_| itsi_error::ItsiError::ClientConnectionClosed)
+                .ok();
         }
         Ok(0)
     }
@@ -293,11 +294,19 @@ impl ItsiResponse {
         Ok(true)
     }
 
+    pub fn is_html(&self) -> bool {
+        self.accept.starts_with("text/html")
+    }
+
+    pub fn is_json(&self) -> bool {
+        self.accept.starts_with("application/json")
+    }
+
     pub fn close_read(&self) -> MagnusResult<bool> {
-        todo!();
+        Ok(true)
     }
 
-    pub fn new(parts: Parts, response_writer: mpsc::Sender<Option<Bytes>>) -> Self {
+    pub fn new(parts: Parts, response_writer: mpsc::Sender<Option<Bytes>>, accept: String) -> Self {
         Self {
             data: Arc::new(ResponseData {
                 response: RwLock::new(Some(Response::new(BoxBody::new(Empty::new())))),
@@ -306,6 +315,7 @@ impl ItsiResponse {
                 hijacked_socket: RwLock::new(None),
                 parts,
             }),
+            accept,
         }
     }
 

data/gems/scheduler/ext/itsi_server/src/server/bind.rs

@@ -101,7 +101,7 @@ impl FromStr for Bind {
                     "IPv6 addresses must use [ ] when specifying a port".to_owned(),
                 ));
             } else {
-                (h, None) // Treat as a hostname
+                (h, p.parse::<u16>().ok()) // Treat as a hostname
             }
         } else {
             (url, None)
@@ -110,18 +110,22 @@ impl FromStr for Bind {
         let address = if let Ok(ip) = host.parse::<IpAddr>() {
             BindAddress::Ip(ip)
         } else {
-            resolve_hostname(host)
-                .map(BindAddress::Ip)
-                .ok_or(ItsiError::ArgumentError(format!(
-                    "Failed to resolve hostname {}",
-                    host
-                )))?
+            match protocol {
+                BindProtocol::Https | BindProtocol::Http => resolve_hostname(host)
+                    .map(BindAddress::Ip)
+                    .ok_or(ItsiError::ArgumentError(format!(
+                        "Failed to resolve hostname {}",
+                        host
+                    )))?,
+                BindProtocol::Unix | BindProtocol::Unixs => BindAddress::UnixSocket(host.into()),
+            }
         };
-        let (port, address) = match protocol {
-            BindProtocol::Http => (port.or(Some(80)), address),
-            BindProtocol::Https => (port.or(Some(443)), address),
-            BindProtocol::Unix => (None, BindAddress::UnixSocket(host.into())),
-            BindProtocol::Unixs => (None, BindAddress::UnixSocket(host.into())),
+
+        let port = match protocol {
+            BindProtocol::Http => port.or(Some(80)),
+            BindProtocol::Https => port.or(Some(443)),
+            BindProtocol::Unix => None,
+            BindProtocol::Unixs => None,
         };
 
         let tls_config = match protocol {