rage-iodine 5.2.1 → 5.3.0

data/ext/iodine/iodine_worker_pool_test.c

@@ -0,0 +1,145 @@
+/*
+Test helpers for Iodine::WorkerPool.
+
+Provides:
+- busy(duration:): Blocking operation that releases the GVL.
+  When called within a fiber scheduler context, this will trigger
+  blocking_operation_wait and use the worker pool.
+
+Based on io-event worker_pool_test.c by Samuel Williams.
+*/
+
+#include "iodine.h"
+
+#ifdef HAVE_IODINE_WORKER_POOL
+
+#include "iodine_worker_pool_test.h"
+
+#include <ruby/thread.h>
+#include <ruby/fiber/scheduler.h>
+#include <unistd.h>
+#include <sys/select.h>
+
+static ID id_duration;
+
+struct busy_operation_data {
+  int read_fd;
+  int write_fd;
+  double duration;
+};
+
+/* The actual blocking operation that can be cancelled */
+static void *busy_blocking_operation(void *data) {
+  struct busy_operation_data *busy_data = (struct busy_operation_data *)data;
+
+  /* Use select() to wait for the pipe to become readable */
+  fd_set read_fds;
+  struct timeval timeout;
+
+  FD_ZERO(&read_fds);
+  FD_SET(busy_data->read_fd, &read_fds);
+
+  timeout.tv_sec = (long)busy_data->duration;
+  timeout.tv_usec = (int)((busy_data->duration - timeout.tv_sec) * 1000000);
+
+  /* This will block until:
+     1. The pipe becomes readable (cancellation)
+     2. The timeout expires
+     3. An error occurs */
+  int result = select(busy_data->read_fd + 1, &read_fds, NULL, NULL, &timeout);
+
+  if (result > 0 && FD_ISSET(busy_data->read_fd, &read_fds)) {
+    /* Pipe became readable - we were cancelled */
+    char buffer;
+    read(busy_data->read_fd, &buffer, 1);
+  }
+
+  return NULL;
+}
+
+/* Unblock function that writes to the pipe to cancel the operation */
+static void busy_unblock_function(void *data) {
+  struct busy_operation_data *busy_data = (struct busy_operation_data *)data;
+  char wake_byte = 1;
+  write(busy_data->write_fd, &wake_byte, 1);
+}
+
+/* Cleanup function for rb_ensure */
+static VALUE busy_operation_cleanup(VALUE data_value) {
+  struct busy_operation_data *busy_data =
+      (struct busy_operation_data *)data_value;
+  close(busy_data->read_fd);
+  close(busy_data->write_fd);
+  return Qnil;
+}
+
+/* The main operation execution */
+static VALUE busy_operation_execute(VALUE data_value) {
+  struct busy_operation_data *busy_data =
+      (struct busy_operation_data *)data_value;
+
+  rb_nogvl(busy_blocking_operation, busy_data, busy_unblock_function, busy_data,
+           RB_NOGVL_UBF_ASYNC_SAFE | RB_NOGVL_OFFLOAD_SAFE);
+
+  return Qnil;
+}
+
+/**
+ * Iodine::WorkerPool.busy(duration: 1.0) -> nil
+ *
+ * Creates a blocking operation for testing that releases the GVL.
+ * When called within a fiber scheduler context with a worker pool,
+ * this will trigger blocking_operation_wait.
+ *
+ * @param duration [Float] How long to block (default: 1.0 second)
+ * @return [nil]
+ */
+static VALUE worker_pool_test_busy(int argc, VALUE *argv, VALUE self) {
+  double duration = 1.0;
+
+  VALUE kwargs = Qnil;
+  VALUE rb_duration = Qundef;
+
+  rb_scan_args(argc, argv, "0:", &kwargs);
+
+  if (!NIL_P(kwargs)) {
+    VALUE kwvals[1];
+    ID kwkeys[1] = {id_duration};
+    rb_get_kwargs(kwargs, kwkeys, 0, 1, kwvals);
+    rb_duration = kwvals[0];
+  }
+
+  if (rb_duration != Qundef && !NIL_P(rb_duration)) {
+    duration = NUM2DBL(rb_duration);
+  }
+
+  /* Create pipe for cancellation */
+  int pipe_fds[2];
+  if (pipe(pipe_fds) != 0) {
+    rb_sys_fail("pipe creation failed");
+  }
+
+  struct busy_operation_data busy_data = {
+      .read_fd = pipe_fds[0], .write_fd = pipe_fds[1], .duration = duration};
+
+  return rb_ensure(busy_operation_execute, (VALUE)&busy_data,
+                   busy_operation_cleanup, (VALUE)&busy_data);
+  (void)self;
+}
+
+/* Initialize the test functions */
+void iodine_worker_pool_test_init(VALUE WorkerPoolKlass) {
+  id_duration = rb_intern("duration");
+
+  rb_define_singleton_method(WorkerPoolKlass, "__busy", worker_pool_test_busy,
+                             -1);
+}
+
+#else /* !HAVE_IODINE_WORKER_POOL */
+
+void iodine_worker_pool_test_init(VALUE WorkerPoolKlass) {
+  /* WorkerPool not available */
+  (void)WorkerPoolKlass;
+}
+
+#endif /* HAVE_IODINE_WORKER_POOL */

data/ext/iodine/iodine_worker_pool_test.h

@@ -0,0 +1,19 @@
+/*
+Test helpers for Iodine::WorkerPool.
+Provides a busy() class method for testing GVL release and cancellation.
+*/
+
+#ifndef H_IODINE_WORKER_POOL_TEST_H
+#define H_IODINE_WORKER_POOL_TEST_H
+
+#include <ruby.h>
+
+/**
+ * Initializes test methods on the WorkerPool class.
+ * Called from iodine_worker_pool_init() when HAVE_IODINE_WORKER_POOL is defined.
+ *
+ * @param WorkerPoolKlass The Iodine::WorkerPool class
+ */
+void iodine_worker_pool_test_init(VALUE WorkerPoolKlass);
+
+#endif

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '5.2.1'.freeze
+  VERSION = '5.3.0'.freeze
 end

data/lib/rack/handler/iodine.rb

@@ -1,5 +1,8 @@
 require 'iodine' unless defined?(::Iodine::VERSION)
-require 'rage/cli'
+begin
+  require 'rage/cli'
+rescue LoadError
+end
 
 module Iodine
   # Iodine's {Iodine::Rack} module provides a Rack compliant interface (connecting Iodine to Rack) for an HTTP and Websocket Server.
@@ -7,7 +10,13 @@ module Iodine
 
     # Runs a Rack app, as par the Rack handler requirements.
     def self.run(app, options = {})
-      Rage::CLI.new([], { port: options[:Port], binding: options[:Host], environment: options[:environment] }).server
+      if !defined?(Rage::CLI) && ENV["RSPEC_TEST_ENV"]
+        Iodine.listen(service: :http, handler: app, port: options[:Port], address: options[:Host])
+        Iodine.start
+      else
+        Rage::CLI.new([], { port: options[:Port], binding: options[:Host], environment: options[:environment] }).server
+      end
+
       true
     end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rage-iodine
 version: !ruby/object:Gem::Version
-  version: 5.2.1
+  version: 5.3.0
 platform: ruby
 authors:
 - Boaz Segev
 bindir: exe
 cert_chain: []
-date: 2026-03-18 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -121,6 +121,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - ".github/ISSUE_TEMPLATE/bug_report.md"
+- ".github/workflows/release.yml"
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
@@ -131,6 +132,7 @@ files:
 - LIMITS.md
 - README.md
 - Rakefile
+- SECURITY.md
 - SPEC-PubSub-Draft.md
 - SPEC-WebSocket-Draft.md
 - bin/console
@@ -226,6 +228,10 @@ files:
 - ext/iodine/iodine_tcp.h
 - ext/iodine/iodine_tls.c
 - ext/iodine/iodine_tls.h
+- ext/iodine/iodine_worker_pool.c
+- ext/iodine/iodine_worker_pool.h
+- ext/iodine/iodine_worker_pool_test.c
+- ext/iodine/iodine_worker_pool_test.h
 - ext/iodine/mustache_parser.h
 - ext/iodine/redis_engine.c
 - ext/iodine/redis_engine.h
@@ -272,7 +278,7 @@ requirements:
 - Ruby >= 2.5.0 recommended.
 - TLS requires OpenSSL >= 1.1.0.
 - Or Windows with Ruby >= 3.0.0 build with MingW and MingW as compiler.
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: iodine - a fast HTTP / Websocket Server with Pub/Sub support, optimized for
   Ruby MRI on Linux / BSD / Windows