itsi-server 0.1.9 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 479b2a6c1ed83ad8996367e19ca025b9b53172a66a143128eb2399c98a1b2f7d
-  data.tar.gz: '0687d23ed59b8a9fe81055d85c74cb374b679eae6025a9c89307591cf881a7bf'
+  metadata.gz: 95b630b919b54bfd70b967f601d54387723157a453f483793d7e39163a2bdff7
+  data.tar.gz: e6fc42f8966f04ba7fdca960b6b35ebb96d519257e7da42c32b1e21e774df0f3
 SHA512:
-  metadata.gz: 0b6ee383356c06fb6dfe62f3f1a2c9e631d584246f300ad3b6eb2b507f508099560c97d661cedf762553b6d062d6daece0ec9c7244971d1576be929b1e2cbad2
-  data.tar.gz: 78045f8853d52c243b8a458dc46d85199daf8a6c15984492644826c3fa0c5edfdd61f8842892b03a887c85441f5ce96ae67d05fe8f85f0db5370a31732f3272c
+  metadata.gz: 30cb39bd205b426089712acacc9d0bbf2bb52b8c64d3febfac29de2b939bc8c431f169fd458921271440d5baded4c7f56c78f6e6b0318f7fbe93bd7b0e5534ba
+  data.tar.gz: 3e593704f3906a2a5b7621cef3205bbe92da1ce0173e1b9849bfe97f3c116d7ef63c889c1f2a63c64a0112b268bd634bbb57e16ded91cb201acdece1f3ffc433

data/Cargo.lock

@@ -993,6 +993,7 @@ dependencies = [
  "crossbeam",
  "derive_more",
  "dirs",
+ "fnv",
  "fs2",
  "futures",
  "http",
@@ -1009,7 +1010,9 @@ dependencies = [
  "pin-project",
  "rb-sys",
  "rcgen",
+ "regex",
  "ring",
+ "route-recognizer",
  "rustls",
  "rustls-pemfile",
  "socket2",
@@ -1730,6 +1733,12 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "route-recognizer"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afab94fb28594581f62d981211a9a4d53cc8130bbcbbb89a0440d9b8e81a7746"
+
 [[package]]
 name = "rustc-demangle"
 version = "0.1.24"
@@ -2131,9 +2140,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.43.0"
+version = "1.44.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d61fa4ffa3de412bfea335c6ecff681de2b609ba3c77ef3e00e521813a9ed9e"
+checksum = "f382da615b842244d4b8738c82ed1275e6c5dd90c459a30941cd07080b06c91a"
 dependencies = [
  "backtrace",
  "bytes",

data/exe/itsi

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
+
 require "optparse"
 
 # Default options used when starting Osprey from the CLI using `osprey`
@@ -19,7 +20,9 @@ DEFAULT_OPTIONS = {
   # Scheduler class
   scheduler_class: nil,
   # Whether to stream the body or not
-  stream_body: false
+  stream_body: false,
+  # Config file
+  config_file: nil
 }
 
 options = DEFAULT_OPTIONS.to_a.select(&:last).to_h
@@ -28,6 +31,10 @@ options = DEFAULT_OPTIONS.to_a.select(&:last).to_h
 OptionParser.new do |opts|
   opts.banner = "Usage: itsi [options]"
 
+  opts.on("-C", "--config CONFIG_FILE", String, "Itsi Configuration file to use (default: Itsi.rb)") do |config_file|
+    options[:config_file] = config_file
+  end
+
   opts.on("-w", "--workers WORKERS", Integer, "Number of workers (default: #{options[:workers]})") do |w|
     options[:workers] = w
   end
@@ -41,11 +48,12 @@ OptionParser.new do |opts|
   end
 
   opts.on("--worker-memory-limit MEMORY_LIMIT", Integer,
-          "Memory limit for each worker (default: #{options[:worker_memory_limit] || 'None'}). If this limit is breached the worker is gracefully restarted") do |ml|
+          "Memory limit for each worker (default: #{options[:worker_memory_limit] || "None"}). If this limit is breached the worker is gracefully restarted") do |ml|
     options[:worker_memory_limit] = ml
   end
 
-  opts.on("-f", "--fiber_scheduler [CLASS_NAME]", [String], "Scheduler class to use (default: nil). Provide blank or true to use Itsi::Scheduler, or a classname to use an alternative scheduler") do |scheduler_class|
+  opts.on("-f", "--fiber_scheduler [CLASS_NAME]", [String],
+          "Scheduler class to use (default: nil). Provide blank or true to use Itsi::Scheduler, or a classname to use an alternative scheduler") do |scheduler_class|
     if scheduler_class.nil? || scheduler_class == "true"
       options[:scheduler_class] = "Itsi::Scheduler"
     elsif scheduler_class == "false"
@@ -65,8 +73,8 @@ OptionParser.new do |opts|
     end
   end
 
-
-  opts.on("-b", "--bind BIND", String, "Bind address (default: #{options[:binds].join(", ")}). You can specify this flag multiple times to bind to multiple addresses.") do |bind|
+  opts.on("-b", "--bind BIND", String,
+          "Bind address (default: #{options[:binds].join(", ")}). You can specify this flag multiple times to bind to multiple addresses.") do |bind|
     options[:binds].pop if options[:binds].first.frozen?
     options[:binds] << bind
   end
@@ -74,6 +82,7 @@ OptionParser.new do |opts|
   opts.on("-c", "--cert_path CERT_PATH", String,
           "Path to the SSL certificate file (must follow a --bind option). You can specify this flag multiple times.") do |cp|
     raise OptionParser::InvalidOption, "--cert_path must follow a --bind" if options[:binds].empty?
+
     require "uri"
 
     # Modify the last bind entry to add/update the cert query parameter
@@ -84,8 +93,10 @@ OptionParser.new do |opts|
     options[:binds][-1] = "#{uri.host}?#{query_string}"
   end
 
-  opts.on("-k", "--key_path KEY_PATH", String, "Path to the SSL key file (must follow a --bind option). You can specify this flag multiple times.") do |kp|
+  opts.on("-k", "--key_path KEY_PATH", String,
+          "Path to the SSL key file (must follow a --bind option). You can specify this flag multiple times.") do |kp|
     raise OptionParser::InvalidOption, "--key_path must follow a --bind" if options[:binds].empty?
+
     require "uri"
 
     # Modify the last bind entry to add/update the key query parameter
@@ -115,30 +126,49 @@ OptionParser.new do |opts|
   end
 end.parse!
 
-# Rack app loader, invoked per worker.
-# This is a no-op if preloading is enabled (we just return the preloaded app).
-preloader = \
-  if options[:preload]
+require "itsi/server/config"
+if ARGV.pop == "init"
+  Itsi::Server::Config.write_default
+  exit(0)
+  # Add initialization code here
+end
+
+options = Itsi::Server::Config.load(options)
+loader = nil
+
+if options[:app] || File.exist?(options[:rackup_file])
+  loader ||= lambda do
     require "rack"
+    require_relative "../lib/itsi/server/scheduler_mode" if options[:scheduler_class]
+    require "itsi/scheduler" if [true, "Itsi::Scheduler"].include?(options[:scheduler_class])
+    require "itsi/server"
+    return options[:app] if options[:app]
+    Array(Rack::Builder.parse_file(options[:rackup_file])).first
+  end
 
-    app = Array(Rack::Builder.parse_file(options[:rackup_file])).first
+  if options[:preload] == true
+    # If preload is true, we'll invoke our loader now, and just return a no-op proc
+    # which returns the app as loader. We still need to optionally load the scheduler class and rack
+    # in case the app has been provided directly in Itsi.rb instead of in config.ru
+    require "rack"
     require_relative "../lib/itsi/server/scheduler_mode" if options[:scheduler_class]
-    app.method(:itself).to_proc
-  else
-    lambda do
-      require "rack"
-
-      app = Array(Rack::Builder.parse_file(options[:rackup_file])).first
-      require_relative "../lib/itsi/server/scheduler_mode" if options[:scheduler_class]
-      app
-    end
+    require "itsi/scheduler" if [true, "Itsi::Scheduler"].include?(options[:scheduler_class])
+    loader = (options[:app] || loader[]).method(:itself).to_proc
+  elsif options[:preload]
+    # If a group name is given, we'll stick to just loading the gem group by the same name from the Gemfile.
+    # But we'll fall through to the default delayed loader for the full app.
+    require "bundler"
+    Bundler.setup
+    Bundler.require(options[:preload])
+    nil
   end
+end
 
 # Make sure Itsi is loaded, if not already loaded by the rack_app above.
 # Start the Itsi server
 require "itsi/server"
 
-Itsi::Server.new(
-  app: preloader,
+Itsi::Server.start(
+  loader: loader,
   **options.except(:preload, :rackup_file)
-).start
+)

data/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/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/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))?;

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

@@ -17,6 +17,7 @@ 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)]
@@ -115,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());

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

@@ -77,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 {
@@ -280,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)
     }

data/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 {

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

@@ -8,17 +8,17 @@ use super::{
 };
 use crate::{request::itsi_request::ItsiRequest, server::serve_strategy::ServeStrategy};
 use derive_more::Debug;
-use itsi_rb_helpers::{call_without_gvl, HeapVal};
+use itsi_rb_helpers::{call_without_gvl, HeapVal, HeapValue};
 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,
+    value::ReprValue,
+    ArgList, RArray, RHash, Ruby, Symbol, Value,
 };
 use parking_lot::{Mutex, RwLock};
-use std::{cmp::max, ops::Deref, sync::Arc};
+use std::{cmp::max, collections::HashMap, ops::Deref, sync::Arc};
 use tracing::{info, instrument};
 
 static DEFAULT_BIND: &str = "http://localhost:3000";
@@ -36,7 +36,6 @@ impl Deref for Server {
         &self.config
     }
 }
-type AfterFork = Mutex<Arc<Option<Box<dyn Fn() + Send + Sync>>>>;
 
 #[derive(Debug)]
 pub struct ServerConfig {
@@ -51,15 +50,14 @@ pub struct ServerConfig {
     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 hooks: HashMap<String, HeapValue<Proc>>,
     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,
+    pub oob_gc_responses_threshold: Option<u64>,
 }
 
 #[derive(Debug)]
@@ -68,8 +66,6 @@ pub enum RequestJob {
     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],
@@ -80,20 +76,17 @@ where
     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)
 }
 
@@ -129,14 +122,14 @@ impl Server {
         type Args2 = KwArgs<
             (),
             (
-                // Before Fork
-                Option<Proc>,
-                // After Fork
-                Option<Proc>,
+                // Hooks
+                Option<RHash>,
                 // Scheduler Class
                 Option<String>,
                 // Worker Memory Limit
                 Option<u64>,
+                // Out-of-band GC Responses Threshold
+                Option<u64>,
                 // Silence
                 Option<bool>,
             ),
@@ -160,14 +153,33 @@ impl Server {
             &scan_args,
             &[],
             &[
-                "before_fork",
-                "after_fork",
+                "hooks",
                 "scheduler_class",
                 "worker_memory_limit",
+                "oob_gc_responses_threshold",
                 "silence",
             ],
         )?;
 
+        let hooks = args2
+            .optional
+            .0
+            .map(|rhash| -> Result<HashMap<String, HeapValue<Proc>>> {
+                let mut hook_map: HashMap<String, HeapValue<Proc>> = HashMap::new();
+                for pair in rhash.enumeratorize::<_, ()>("each", ()) {
+                    if let Some(pair_value) = RArray::from_value(pair?) {
+                        if let (Ok(key), Ok(value)) =
+                            (pair_value.entry::<Value>(0), pair_value.entry::<Proc>(1))
+                        {
+                            hook_map.insert(key.to_string(), HeapValue::from(value));
+                        }
+                    }
+                }
+                Ok(hook_map)
+            })
+            .transpose()?
+            .unwrap_or_default();
+
         let config = ServerConfig {
             app: HeapVal::from(args1.required.0),
             workers: max(args1.optional.0.unwrap_or(1), 1),
@@ -184,32 +196,16 @@ impl Server {
                     .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),
+            hooks,
+            scheduler_class: args2.optional.1.clone(),
+            worker_memory_limit: args2.optional.2,
             strategy: RwLock::new(None),
+            oob_gc_responses_threshold: args2.optional.3,
+            silence: args2.optional.4.is_some_and(|s| s),
         };
 
         if !config.silence {
-            if let Some(scheduler_class) = args2.optional.2 {
+            if let Some(scheduler_class) = args2.optional.1 {
                 info!(scheduler_class, fiber_scheduler = true);
             } else {
                 info!(fiber_scheduler = false);
@@ -222,7 +218,7 @@ impl Server {
     }
 
     #[instrument(name = "Bind", skip_all, fields(binds=format!("{:?}", self.config.binds.lock())))]
-    pub(crate) fn build_listeners(&self) -> Result<Arc<Vec<Arc<Listener>>>> {
+    pub(crate) fn build_listeners(&self) -> Result<Vec<Listener>> {
         let listeners = self
             .config
             .binds
@@ -232,13 +228,13 @@ impl Server {
             .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))
+        Ok(listeners)
     }
 
-    pub(crate) fn build_strategy(self, listeners: Arc<Vec<Arc<Listener>>>) -> Result<()> {
+    pub(crate) fn build_strategy(self) -> Result<()> {
+        let listeners = self.build_listeners()?;
         let server = Arc::new(self);
         let server_clone = server.clone();
 
@@ -276,11 +272,9 @@ impl Server {
     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() {
+            rself.clone().build_strategy()?;
+            if let Err(e) = rself.strategy.read().as_ref().unwrap().run() {
                 error!("Error running server: {}", e);
                 rself.strategy.read().as_ref().unwrap().stop()?;
             }