rage-iodine 5.4.0 → 5.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ef6e88ecbc5910815537ef78329c6bc965261fb4514c479be7594fb6de61dca
-  data.tar.gz: '09632895e2ed3a00f6300a418c46b7f10332403f83aceeaffe77af57258f9baf'
+  metadata.gz: 7ffa46cab7e0fb7fc7550dd142f42b0850287fee60cc0d72b7f52757f52720f7
+  data.tar.gz: c51b8ad9e316c21ed06e6803dcfb5af7bf70fc3eee84a0fd179b2730d2572473
 SHA512:
-  metadata.gz: 6ce3edb67d9029b9a9bf73a941dcbcd7378214246cbbb5a09084f085dda5c2b41003dc75338a595f054e28db146cc713e887a3d43fffebefc80567d87348a94a
-  data.tar.gz: 3b2f347ecc8732f23ecac55bbc5c8c3d9d51b6e814bbb9b87f23d538f211ab6a605972b879f4449c3ce10fe95bc1920930304e604f53f5f593d5d889f4095c25
+  metadata.gz: fa99ee4e7abb10b55b6f14aeeaef6bf03e85cf8aff9b33a66f7b4f64097c5ef824e0c3de6663caf00f5404b2d08b663debb60c796a0a44490138a96ac92a832c
+  data.tar.gz: ca2a4ac6f633955b202dccf09661cb7799ae92e16078ef3776c1648e18e2b1ab620f470f4b99b3c75b7d0e8f9b064fad180fd5c9b32ab6ae0ddd60c9d601b58d

data/CHANGELOG.md

@@ -6,6 +6,20 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.5.6.0 (2026-09-06)
+
+**Update**: TCP Socket Listen: Accept Queue
+
+#### Change log v.5.5.0 (2026-07-06)
+
+**Update**: Update `pre_start` callbacks to fail the server launch in case of errors
+
+**Update**: Update media types in the MIME table
+
+**Update**: Ensure users can override headers when serving files
+
+**Update**: Support `x-sendfile-root` headers
+
 #### Change log v.5.4.0 (2026-06-08)
 
 **Update**: Optimize `fio_run_every` timers

data/Gemfile

@@ -4,7 +4,8 @@ group :test do
   gem 'pry'
   gem 'rspec'
   gem 'rack'
-  gem 'http'
+  gem 'http', '~> 5.0'
+  gem 'ostruct', '~> 0.6.3'
   gem 'base64'
   gem 'benchmark'
 end

data/ext/iodine/fio.c

@@ -4532,10 +4532,22 @@ Initialize the library
 
 static void fio_pubsub_on_fork(void);
 
+#if defined(__linux__)
+/* accept-queue tracking lock for the listener registry (defined alongside
+ * fio_accept_queue_listeners in the listener section below); declared here
+ * so fio_on_fork can reset it across children. */
+static fio_lock_i fio_accept_queue_lock;
+#endif
+
 /* Called within a child process after it starts. */
 static void fio_on_fork(void) {
   fio_timer_lock = FIO_LOCK_INIT;
   fio_data->lock = FIO_LOCK_INIT;
+#if defined(__linux__)
+  /* a forked child may inherit the accept-queue lock while a parent thread
+   * held it mid-walk; that thread won't exist in the child, so reset it. */
+  fio_accept_queue_lock = FIO_LOCK_INIT;
+#endif
   fio_defer_on_fork();
   fio_malloc_after_fork();
   fio_poll_init();
@@ -5571,6 +5583,14 @@ The listening protocol (use the facil.io API to make a socket and attach it)
 typedef struct {
   fio_protocol_s pr;
   intptr_t uuid;
+#if defined(__linux__)
+/**
+* Listener node adding this listener into to fio_accept_queue_listeners,
+* so Iodine::Perf.queued_connections can find its socket's fd and read its
+* kernel length accept-queue(AcceptQ):backlog where (backlog <= somaxconn) (TCP_INFO).
+*/
+  fio_ls_embd_s listener_node;
+#endif
   void *udata;
   void (*on_open)(intptr_t uuid, void *udata);
   void (*on_start)(intptr_t uuid, void *udata);
@@ -5582,8 +5602,20 @@ typedef struct {
   void *tls;
 } fio_listen_protocol_s;
 
+#if defined(__linux__)
+/* tracks iodine's listening sockets for the accept-queue backlog query.
+ * guarded against concurrent teardown (reactor thread, no GVL) */
+static fio_ls_embd_s fio_accept_queue_listeners = FIO_LS_INIT(fio_accept_queue_listeners);
+static fio_lock_i fio_accept_queue_lock = FIO_LOCK_INIT;
+#endif
+
 static void fio_listen_cleanup_task(void *pr_) {
   fio_listen_protocol_s *pr = pr_;
+#if defined(__linux__)
+  fio_lock(&fio_accept_queue_lock);
+  fio_ls_embd_remove(&pr->listener_node);
+  fio_unlock(&fio_accept_queue_lock);
+#endif
 #ifndef __MINGW32__
   if (pr->tls)
     fio_tls_destroy(pr->tls);
@@ -5733,6 +5765,12 @@ intptr_t fio_listen FIO_IGNORE_MACRO(struct fio_listen_args args) {
   if (port_len)
     memcpy(pr->port, args.port, port_len + 1);
 
+#if defined(__linux__)
+  fio_lock(&fio_accept_queue_lock);
+  fio_ls_embd_push(&fio_accept_queue_listeners, &pr->listener_node);
+  fio_unlock(&fio_accept_queue_lock);
+#endif
+
   if (fio_is_running()) {
     fio_attach(pr->uuid, &pr->pr);
   } else {
@@ -5753,6 +5791,65 @@ error:
   return -1;
 }
 
+/* -------------------------------------------------------------------------
+ * Kernel accept-queue(AcceptQ) which is Queue length: backlog, where backlog <= somaxconn  
+ * "backlog are established connections waiting for accept()" = sk_ack_backlog.
+ * Returns the sum of the accept-queues of all iodine listening sockets, or 0.
+ * ---------------------------------------------------------------------- */
+#if defined(__linux__)
+intptr_t fio_queued_connections(void) {
+  intptr_t backlog = 0;
+
+  fio_lock(&fio_accept_queue_lock);
+  /**
+   * Walk every registered listener and sum its kernel accept-queue depth/length.
+   * The list always begins with a permanent head node (fio_accept_queue_listeners) 
+   * that works like a fixed bookmark: it holds no listener of its own, real nodes 
+   * are chained after it, and the last node links back to it, forming a circle 
+   * i.e a circular linked list also it's a doubly linked list.
+   *
+   * So the loop:
+   *   - starts at `.next`, i.e. the FIRST REAL node starting at the head
+   *     itself would be wrong, since it owns no listener and converting it
+   *     with FIO_LS_EMBD_OBJ would produce a bogus pointer;
+   *   - stops when it arrives back at the head, meaning every real node
+   *     has been visited;
+   *   - runs zero times on an empty list, because a lone head simply
+   *     points at itself.
+   */
+  for (fio_ls_embd_s *pos = fio_accept_queue_listeners.next; pos != &fio_accept_queue_listeners; pos = pos->next) {
+    fio_listen_protocol_s *pr = FIO_LS_EMBD_OBJ(fio_listen_protocol_s, listener_node, pos);
+    struct tcp_info info;
+    socklen_t tlen = sizeof(info);
+    int fd = fio_uuid2fd(pr->uuid);
+
+    fio_lock(&fd_data(fd).protocol_lock);
+
+    /* Skip sockets that were closed or reused before we could query them.
+     * Callers must run this after listeners are attached (e.g. from within
+     * Iodine.run / a background thread), so the listener's protocol slot is
+     * populated and the checks below are meaningful. */
+    if (!uuid_is_valid(pr->uuid) || fd_data(fd).protocol != &pr->pr) {
+      fio_unlock(&fd_data(fd).protocol_lock);
+      continue;
+    }
+
+    int ok = !getsockopt(fd, IPPROTO_TCP, TCP_INFO, &info, &tlen);
+
+    fio_unlock(&fd_data(fd).protocol_lock);
+
+    if (!ok) {
+      continue;
+    }
+
+    backlog += (intptr_t)info.tcpi_unacked;
+  }
+  fio_unlock(&fio_accept_queue_lock);
+
+  return backlog;
+}
+#endif
+
 /* *****************************************************************************
 Section Start Marker
 

data/ext/iodine/fio.h

@@ -1111,6 +1111,19 @@ intptr_t fio_socket(const char *address, const char *port, uint8_t is_server);
  */
 intptr_t fio_accept(intptr_t srv_uuid);
 
+/**
+ * Returns the number of established connections currently parked in the
+ * kernel's accept queue(s) (sk_ack_backlog) of all iodine listening sockets.
+ *
+ * The query goes straight to the kernel via getsockopt(TCP_INFO).
+ *
+ * Returns the total accept queue length across all iodine listeners, or 0
+ * when there are no listeners.
+ */
+#if defined(__linux__)
+intptr_t fio_queued_connections(void);
+#endif /* linux only */
+
 /**
  * Returns 1 if the uuid refers to a valid and open, socket.
  *

data/ext/iodine/http.c

@@ -188,6 +188,26 @@ int http_set_header2(http_s *r, fio_str_info_s n, fio_str_info_s v) {
   return ret;
 }
 
+/**
+ * Sets a response header if it hasn't already been set.
+ *
+ * Returns -1 on error and 0 on success.
+ */
+static inline int http_set_header_if_none(http_s *r, FIOBJ name, FIOBJ value) {
+  if (HTTP_INVALID_HANDLE(r) || !name) {
+    fiobj_free(value);
+    return -1;
+  }
+
+  if (fiobj_hash_get2(r->private_data.out_headers, fiobj_obj2hash(name))) {
+    fiobj_free(value);
+    return 0;
+  }
+
+  fiobj_hash_set(r->private_data.out_headers, name, value);
+  return 0;
+}
+
 /**
  * Sets a response cookie, taking ownership of the value object, but NOT the
  * name object (so name objects could be reused in future responses).
@@ -461,12 +481,12 @@ no_gzip_support:
     return -1;
 found_file:
   /* set cache-control */
-  http_set_header(h, HTTP_HEADER_CACHE_CONTROL, fiobj_dup(HTTP_HVALUE_MAX_AGE));
+  http_set_header_if_none(h, HTTP_HEADER_CACHE_CONTROL, fiobj_dup(HTTP_HVALUE_MAX_AGE));
   /* set last-modified */
   FIOBJ last_modified_str = fiobj_str_buf(32);
   fiobj_str_resize(
       last_modified_str, http_time2str(fiobj_obj2cstr(last_modified_str).data, file_data.st_mtime));
-  http_set_header(h, HTTP_HEADER_LAST_MODIFIED, last_modified_str);
+  http_set_header_if_none(h, HTTP_HEADER_LAST_MODIFIED, last_modified_str);
   /* set & test etag */
   FIOBJ etag_str = fiobj_str_buf(1);
   fiobj_str_printf(etag_str, "%lx-%llx", file_data.st_mtime, file_data.st_size);
@@ -605,7 +625,7 @@ open_file:
       tmp = http_mimetype_find(s.data + pos, s.len - pos);
     }
     if (tmp)
-      http_set_header(h, HTTP_HEADER_CONTENT_TYPE, tmp);
+      http_set_header_if_none(h, HTTP_HEADER_CONTENT_TYPE, tmp);
   }
   http_sendfile(h, file, length, offset);
   return 0;

data/ext/iodine/http_internal.c

@@ -610,7 +610,7 @@ static void http_lib_init(void *ignr_) {
   REGISTER_MIME("jpgm", "video/jpm");
   REGISTER_MIME("jpgv", "video/jpeg");
   REGISTER_MIME("jpm", "video/jpm");
-  REGISTER_MIME("js", "application/javascript");
+  REGISTER_MIME("js", "text/javascript");
   REGISTER_MIME("json", "application/json");
   REGISTER_MIME("jsonml", "application/jsonml+json");
   REGISTER_MIME("kar", "audio/midi");
@@ -694,6 +694,7 @@ static void http_lib_init(void *ignr_) {
   REGISTER_MIME("mie", "application/x-mie");
   REGISTER_MIME("mif", "application/vnd.mif");
   REGISTER_MIME("mime", "message/rfc822");
+  REGISTER_MIME("mjs", "text/javascript");
   REGISTER_MIME("mj2", "video/mj2");
   REGISTER_MIME("mjp2", "video/mj2");
   REGISTER_MIME("mk3d", "video/x-matroska");
@@ -803,7 +804,7 @@ static void http_lib_init(void *ignr_) {
   REGISTER_MIME("osf", "application/vnd.yamaha.openscoreformat");
   REGISTER_MIME("osfpvg", "application/vnd.yamaha.openscoreformat.osfpvg+xml");
   REGISTER_MIME("otc", "application/vnd.oasis.opendocument.chart-template");
-  REGISTER_MIME("otf", "application/x-font-otf");
+  REGISTER_MIME("otf", "font/otf");
   REGISTER_MIME("otg", "application/vnd.oasis.opendocument.graphics-template");
   REGISTER_MIME("oth", "application/vnd.oasis.opendocument.text-web");
   REGISTER_MIME("oti", "application/vnd.oasis.opendocument.image-template");
@@ -1066,8 +1067,8 @@ static void http_lib_init(void *ignr_) {
   REGISTER_MIME("trm", "application/x-msterminal");
   REGISTER_MIME("tsd", "application/timestamped-data");
   REGISTER_MIME("tsv", "text/tab-separated-values");
-  REGISTER_MIME("ttc", "application/x-font-ttf");
-  REGISTER_MIME("ttf", "application/x-font-ttf");
+  REGISTER_MIME("ttc", "font/collection");
+  REGISTER_MIME("ttf", "font/ttf");
   REGISTER_MIME("ttl", "text/turtle");
   REGISTER_MIME("twd", "application/vnd.simtech-mindmapper");
   REGISTER_MIME("twds", "application/vnd.simtech-mindmapper");
@@ -1163,7 +1164,8 @@ static void http_lib_init(void *ignr_) {
   REGISTER_MIME("wmx", "video/x-ms-wmx");
   REGISTER_MIME("wmz", "application/x-ms-wmz");
   // REGISTER_MIME("wmz", "application/x-msmetafile");
-  REGISTER_MIME("woff", "application/font-woff");
+  REGISTER_MIME("woff", "font/woff");
+  REGISTER_MIME("woff2", "font/woff2");
   REGISTER_MIME("wpd", "application/vnd.wordperfect");
   REGISTER_MIME("wpl", "application/vnd.ms-wpl");
   REGISTER_MIME("wps", "application/vnd.ms-works");

data/ext/iodine/iodine.c

@@ -1401,6 +1401,9 @@ void Init_iodine_ext(void) {
   // initialize concurrency related methods
   iodine_defer_initialize();
 
+  // initialize performance metrics
+  iodine_perf_initialize();
+
   // initialize the connection class
   iodine_connection_init();
 

data/ext/iodine/iodine.h

@@ -42,6 +42,7 @@ typedef struct {
 #include "iodine_http.h"
 #include "iodine_json.h"
 #include "iodine_mustache.h"
+#include "iodine_perf.h"
 #include "iodine_pubsub.h"
 #include "iodine_rack_io.h"
 #include "iodine_store.h"

data/ext/iodine/iodine_caller.c

@@ -152,6 +152,18 @@ static VALUE iodine_call(VALUE obj, ID method) {
   return (VALUE)rv;
 }
 
+/** Calls a Ruby method on a given object, without protecting against exceptions. */
+static VALUE iodine_call_unprotected(VALUE obj, ID method) {
+  iodine_rb_task_s task = {
+      .obj = obj,
+      .argc = 0,
+      .argv = NULL,
+      .method = method,
+  };
+  void *rv = iodine_enterGVL((void *(*)(void *))iodine_ruby_caller_perform, &task);
+  return (VALUE)rv;
+}
+
 /** Calls a Ruby method on a given object, protecting against exceptions. */
 static VALUE iodine_call2(VALUE obj, ID method, int argc, VALUE *argv) {
   iodine_rb_task_s task = {
@@ -223,6 +235,8 @@ struct IodineCaller_s IodineCaller = {
     .call = iodine_call,
     /** Calls a Ruby method on a given object, protecting against exceptions. */
     .call2 = iodine_call2,
+    /** Calls a Ruby method on a given object, without protecting against exceptions. */
+    .call_unprotected = iodine_call_unprotected,
     /** Returns the GVL state flag. */
     .in_GVL = iodine_in_GVL,
     /** Forces the GVL state flag. */

data/ext/iodine/iodine_caller.h

@@ -14,6 +14,8 @@ extern struct IodineCaller_s {
   VALUE (*call)(VALUE obj, ID method);
   /** Calls a Ruby method on a given object, protecting against exceptions. */
   VALUE (*call2)(VALUE obj, ID method, int argc, VALUE *argv);
+  /** Calls a Ruby method on a given object, without protecting against exceptions. */
+  VALUE (*call_unprotected)(VALUE obj, ID method);
   /** Calls a Ruby method on a given object, protecting against exceptions. */
   VALUE(*call_with_block)
   (VALUE obj, ID method, int argc, VALUE *argv, VALUE udata,

data/ext/iodine/iodine_defer.c

@@ -323,6 +323,12 @@ static void iodine_perform_state_callback_persist(void *blk_) {
   IodineCaller.call(blk, call_id);
 }
 
+/* performs a Ruby state callback without protecting against exceptions */
+static void iodine_perform_unprotected_state_callback_persist(void *blk_) {
+  VALUE blk = (VALUE)blk_;
+  IodineCaller.call_unprotected(blk, call_id);
+}
+
 // clang-format off
 /**
 Sets a block of code to run when Iodine's core state is updated.
@@ -357,7 +363,7 @@ static VALUE iodine_on_state(VALUE self, VALUE event) {
 
   if (state == STATE_PRE_START) {
     fio_state_callback_add(FIO_CALL_PRE_START,
-                           iodine_perform_state_callback_persist,
+                           iodine_perform_unprotected_state_callback_persist,
                            (void *)block);
   } else if (state == STATE_BEFORE_FORK) {
     fio_state_callback_add(FIO_CALL_BEFORE_FORK,
@@ -409,6 +415,7 @@ static void iodine_defer_on_finish(void *ignr) {
   iodine_join_io_thread();
 }
 
+
 /* *****************************************************************************
 Add defer API to Iodine
 ***************************************************************************** */

data/ext/iodine/iodine_http.c

@@ -102,6 +102,7 @@ rack_declare(CONTENT_TYPE);
 rack_declare(R_URL_SCHEME);          // rack.url_scheme
 rack_declare(R_INPUT);               // rack.input
 rack_declare(XSENDFILE);             // for X-Sendfile support
+rack_declare(XSENDFILE_ROOT);        // for X-Sendfile support
 rack_declare(XSENDFILE_TYPE);        // for X-Sendfile support
 rack_declare(XSENDFILE_TYPE_HEADER); // for X-Sendfile support
 rack_declare(CONTENT_LENGTH_HEADER); // for X-Sendfile support
@@ -112,6 +113,7 @@ rack_declare(IODINE_HAS_BODY);
 typedef struct {
   http_s *h;
   FIOBJ body;
+  FIOBJ root;
   enum iodine_http_response_type_enum {
     IODINE_HTTP_NONE,
     IODINE_HTTP_SENDBODY,
@@ -716,6 +718,14 @@ static inline void *iodine_handle_request_in_GVL(void *handle_) {
     handle->body = fiobj_str_new(RSTRING_PTR(xfiles), RSTRING_LEN(xfiles));
     handle->type = IODINE_HTTP_XSENDFILE;
     rb_hash_delete(response_headers, XSENDFILE);
+    // extract optional root directory for path validation
+    VALUE xroot = rb_hash_aref(response_headers, XSENDFILE_ROOT);
+    if (xroot != Qnil && TYPE(xroot) == T_STRING) {
+      handle->root = fiobj_str_new(RSTRING_PTR(xroot), RSTRING_LEN(xroot));
+      rb_hash_delete(response_headers, XSENDFILE_ROOT);
+    } else {
+      handle->root = FIOBJ_INVALID;
+    }
     // remove content length headers, as this will be controled by iodine
     rb_hash_delete(response_headers, CONTENT_LENGTH_HEADER);
     // review each header and write it to the response.
@@ -782,8 +792,22 @@ iodine_perform_handle_action(iodine_http_request_handle_s handle) {
             .len == 7)
       fiobj_hash_delete2(handle.h->private_data.out_headers,
                          fiobj_obj2hash(HTTP_HEADER_CONTENT_ENCODING));
-    fio_str_info_s data = fiobj_obj2cstr(handle.body);
-    if (http_sendfile2(handle.h, data.data, data.len, NULL, 0)) {
+    fio_str_info_s file_data = fiobj_obj2cstr(handle.body);
+    int err;
+    if (handle.root != FIOBJ_INVALID) {
+      /* root dir specified - treat x-sendfile as relative/encoded path */
+      fio_str_info_s root_data = fiobj_obj2cstr(handle.root);
+      err = http_sendfile2(handle.h, root_data.data, root_data.len,
+                           file_data.data, file_data.len);
+      fiobj_free(handle.root);
+    } else {
+      /* no root dir - original behavior (absolute path as prefix) */
+      err = http_sendfile2(handle.h, file_data.data, file_data.len, NULL, 0);
+    }
+    if (err) {
+      fiobj_hash_clear(handle.h->private_data.out_headers);
+      http_set_header(handle.h, HTTP_HEADER_CACHE_CONTROL,
+                      fiobj_str_new("no-cache, max-age=0", 19));
       http_send_error(handle.h, 404);
     }
     fiobj_free(handle.body);
@@ -1181,10 +1205,11 @@ void iodine_init_http(void) {
   rack_set(QUERY_ESTRING, "");
   rack_set(R_URL_SCHEME, "rack.url_scheme");
   rack_set(R_INPUT, "rack.input");
-  rack_set(XSENDFILE, "X-Sendfile");
+  rack_set(XSENDFILE, "x-sendfile");
+  rack_set(XSENDFILE_ROOT, "x-sendfile-root");
   rack_set(XSENDFILE_TYPE, "sendfile.type");
   rack_set(XSENDFILE_TYPE_HEADER, "HTTP_X_SENDFILE_TYPE");
-  rack_set(CONTENT_LENGTH_HEADER, "Content-Length");
+  rack_set(CONTENT_LENGTH_HEADER, "content-length");
 
   rack_set(IODINE_R_INPUT, "rack.input");
   rack_set(IODINE_R_HIJACK_IO, "rack.hijack_io");

data/ext/iodine/iodine_perf.c

@@ -0,0 +1,28 @@
+#include "iodine.h"
+
+/* *****************************************************************************
+Performance metrics
+***************************************************************************** */
+
+/**
+ * Iodine::Perf.queued_connections
+ *
+ * Returns the total number of established connections currently parked in
+ * the kernel's accept queue(s) (sk_ack_backlog) for all iodine listening
+ * sockets. Returns 0 when there are no listeners and nil on non-Linux systems.
+ */
+static VALUE iodine_perf_queued_connections(VALUE self) {
+  (void)self;
+#if defined(__linux__)
+  intptr_t backlog = fio_queued_connections();
+  return INT2NUM((long)backlog);
+#else
+  return Qnil;
+#endif
+}
+
+void iodine_perf_initialize(void) {
+  VALUE IodinePerfModule = rb_define_module_under(IodineModule, "Perf");
+  rb_define_module_function(IodinePerfModule, "queued_connections",
+                            iodine_perf_queued_connections, 0);
+}

data/ext/iodine/iodine_perf.h

@@ -0,0 +1,6 @@
+#ifndef H_IODINE_PERF_H
+#define H_IODINE_PERF_H
+
+void iodine_perf_initialize(void);
+
+#endif

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '5.4.0'.freeze
+  VERSION = '5.6.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rage-iodine
 version: !ruby/object:Gem::Version
-  version: 5.4.0
+  version: 5.6.0
 platform: ruby
 authors:
 - Boaz Segev
@@ -217,6 +217,8 @@ files:
 - ext/iodine/iodine_json.h
 - ext/iodine/iodine_mustache.c
 - ext/iodine/iodine_mustache.h
+- ext/iodine/iodine_perf.c
+- ext/iodine/iodine_perf.h
 - ext/iodine/iodine_pubsub.c
 - ext/iodine/iodine_pubsub.h
 - ext/iodine/iodine_rack_io.c