io-event 1.19.3 → 1.19.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9b4e34ef8c8e421b9fe40c1e0556a1317b3233f0746f3c8c613c26bc962a2db
-  data.tar.gz: 8c4839836a933969612713d34031d2a88e8bac969061b64ad1d188db4f56e4db
+  metadata.gz: f7b5b3a617c2f1ef060c072fc860927172b31a8e7e574cc3607f8107326b57bf
+  data.tar.gz: '078687c1ee12579d38d9c5d85f8ad4a49827872567ed48f6835098a8081a6929'
 SHA512:
-  metadata.gz: 75d55f360c232dbbb88c9794db98cd3c4e685652f7e407b1f411c2296991a6a31b947f5448e91a44daed431d562859e3f3d45640ecc99ae0936b65edbcb48183
-  data.tar.gz: 8f47bb334168fc983d765e39c53ccc6a19501204c15ae68d72bbeb3d11f0459b6a255c2ea944061ac494c8696c28d992bb3b241c6685ba3c6aaa2fc8ef5c98a1
+  metadata.gz: '063501649153028126c8b1087d60c8c089aeb03f536ca86e3f5be2a494d891ab1bfca0b08fc796f5d050a8d28dab68c1ffda6fcf2f6e3ea4b20c4ea0310ae8c3'
+  data.tar.gz: cd0df567da5d936491da4c454106ae0c80e4b5a0368bc2ce2ddf02642dd5e313aec14e34d74d3b700be46d9f15f9e76413dae7a8397716afcc08e24a8280b1d9

data/context/getting-started.md

@@ -25,29 +25,55 @@ This example shows how to perform a blocking operation
 require "fiber"
 require "io/event"
 
+# Create an I/O event selector controlled by the main Fiber.
 selector = IO::Event::Selector.new(Fiber.current)
+
+# input: read end, output: write end.
 input, output = IO.pipe
 
 writer = Fiber.new do
+	puts "[writer] Writing data"
+
 	output.write("Hello World")
 	output.close
 end
 
 reader = Fiber.new do
-	selector.io_wait(Fiber.current, input, IO::READABLE)
-	pp read: input.read
+	puts "[reader] No data available, waiting for input"
+
+	# Suspend this Fiber until the input becomes readable.
+	selector.io_wait(
+		Fiber.current,
+		input,
+		IO::READABLE
+	)
+
+	# Execution resumes here once the selector detects the event.
+	puts "[reader] Received: #{input.read.inspect}"
 end
 
-# The reader will be blocked until the IO has data available:
+puts "[main] Transferring to reader fiber"
 reader.transfer
 
-# Write some data to the pipe and close the writing end:
+puts "[main] Reader is waiting, but main can keep running"
+
+puts "[main] Transferring to writer fiber"
 writer.transfer
 
+puts "[main] Checking for I/O events"
 selector.select(1)
 
+puts "[main] Done"
+
 # Results in:
-# {:read=>"Hello World"}
+# [main] Transferring to reader fiber
+# [reader] No data available, waiting for input
+# [main] Reader is waiting, but main can keep running
+# [main] Transferring to writer fiber
+# [writer] Writing data
+# [main] Checking for I/O events
+# [reader] Received: "Hello World"
+# [main] Done
 ```
 
 ## Debugging

data/ext/io/event/selector/epoll.c

@@ -847,6 +847,7 @@ struct select_arguments {
 	
 	int count;
 	int result;
+	int error;
 	struct epoll_event events[EPOLL_MAX_EVENTS];
 	
 	struct timespec * timeout;
@@ -868,9 +869,9 @@ static int make_timeout_ms(struct timespec * timeout) {
 }
 
 static
-int enosys_error(int result) {
+int enosys_error(int result, int error) {
 	if (result == -1) {
-		return errno == ENOSYS;
+		return error == ENOSYS;
 	}
 	
 	return 0;
@@ -882,12 +883,13 @@ void * select_internal(void *_arguments) {
 	
 #if defined(HAVE_EPOLL_PWAIT2)
 	arguments->result = epoll_pwait2(arguments->selector->descriptor, arguments->events, arguments->count, arguments->timeout, NULL);
+	arguments->error = errno;
 	
 	// Comment out the above line and enable the below lines to test ENOSYS code path.
 	// arguments->result = -1;
-	// errno = ENOSYS;
+	// arguments->error = ENOSYS;
 	
-	if (!enosys_error(arguments->result)) {
+	if (!enosys_error(arguments->result, arguments->error)) {
 		return NULL;
 	}
 	else {
@@ -896,6 +898,7 @@ void * select_internal(void *_arguments) {
 #endif
 	
 	arguments->result = epoll_wait(arguments->selector->descriptor, arguments->events, arguments->count, make_timeout_ms(arguments->timeout));
+	arguments->error = errno;
 	
 	return NULL;
 }
@@ -903,12 +906,12 @@ void * select_internal(void *_arguments) {
 static
 int select_internal_without_gvl(struct select_arguments *arguments) {
 	arguments->result = -1;
+	arguments->error = EINTR;
 	IO_Event_Selector_blocking_operation(&arguments->selector->backend, select_internal, (void *)arguments, RUBY_UBF_IO, 0);
 	
 	if (arguments->result == -1) {
-		// If Ruby skips the native callback, the result sentinel can remain `-1`; `errno` may be `0` or `EINTR` depending on the Ruby implementation. Both cases mean the blocking wait did not produce any events.
-		if (errno != EINTR && errno != 0) {
-			rb_sys_fail("select_internal_without_gvl:epoll_wait");
+		if (arguments->error != EINTR) {
+			rb_syserr_fail(arguments->error, "select_internal_without_gvl:epoll_wait");
 		} else {
 			return 0;
 		}
@@ -922,8 +925,8 @@ int select_internal_with_gvl(struct select_arguments *arguments) {
 	select_internal((void *)arguments);
 	
 	if (arguments->result == -1) {
-		if (errno != EINTR) {
-			rb_sys_fail("select_internal_with_gvl:epoll_wait");
+		if (arguments->error != EINTR) {
+			rb_syserr_fail(arguments->error, "select_internal_with_gvl:epoll_wait");
 		} else {
 			return 0;
 		}

data/ext/io/event/selector/kqueue.c

@@ -851,6 +851,7 @@ struct select_arguments {
 	
 	int count;
 	int result;
+	int error;
 	struct kevent events[KQUEUE_MAX_EVENTS];
 	
 	struct timespec storage;
@@ -864,6 +865,7 @@ void * select_internal(void *_arguments) {
 	struct select_arguments * arguments = (struct select_arguments *)_arguments;
 	
 	arguments->result = kevent(arguments->selector->descriptor, NULL, 0, arguments->events, arguments->count, arguments->timeout);
+	arguments->error = errno;
 	
 	return NULL;
 }
@@ -871,12 +873,12 @@ void * select_internal(void *_arguments) {
 static
 int select_internal_without_gvl(struct select_arguments *arguments) {
 	arguments->result = -1;
+	arguments->error = EINTR;
 	IO_Event_Selector_blocking_operation(&arguments->selector->backend, select_internal, (void *)arguments, RUBY_UBF_IO, 0);
 	
 	if (arguments->result == -1) {
-		// If Ruby skips the native callback, the result sentinel can remain `-1`; `errno` may be `0` or `EINTR` depending on the Ruby implementation. Both cases mean the blocking wait did not produce any events.
-		if (errno != EINTR && errno != 0) {
-			rb_sys_fail("select_internal_without_gvl:kevent");
+		if (arguments->error != EINTR) {
+			rb_syserr_fail(arguments->error, "select_internal_without_gvl:kevent");
 		} else {
 			return 0;
 		}
@@ -890,8 +892,8 @@ int select_internal_with_gvl(struct select_arguments *arguments) {
 	select_internal((void *)arguments);
 	
 	if (arguments->result == -1) {
-		if (errno != EINTR) {
-			rb_sys_fail("select_internal_with_gvl:kevent");
+		if (arguments->error != EINTR) {
+			rb_syserr_fail(arguments->error, "select_internal_with_gvl:kevent");
 		} else {
 			return 0;
 		}

data/ext/io/event/worker_pool.c

@@ -306,15 +306,54 @@ static VALUE worker_pool_initialize(int argc, VALUE *argv, VALUE self) {
 	return self;
 }
 
-static VALUE worker_pool_work_begin(VALUE _work) {
+static VALUE worker_pool_work_block(VALUE _work) {
 	struct IO_Event_WorkerPool_Work *work = (void*)_work;
 
-	if (DEBUG) fprintf(stderr, "worker_pool_work_begin:rb_fiber_scheduler_block work=%p\n", work);
+	if (DEBUG) fprintf(stderr, "worker_pool_work_block:rb_fiber_scheduler_block work=%p\n", work);
 	rb_fiber_scheduler_block(work->scheduler, work->blocker, Qnil);
 
 	return Qnil;
 }
 
+static VALUE worker_pool_work_wait(VALUE _work) {
+	struct IO_Event_WorkerPool_Work *work = (void*)_work;
+
+	while (true) {
+		worker_pool_work_block(_work);
+		if (DEBUG) fprintf(stderr, "-- worker_pool_work_wait:work completed=%d\n", work->completed);
+		
+		if (work->completed) {
+			break;
+		}
+		
+		if (DEBUG) fprintf(stderr, "worker_pool_work_wait:rb_fiber_scheduler_blocking_operation_cancel\n");
+		rb_fiber_scheduler_blocking_operation_cancel(work->blocking_operation);
+	}
+
+	return Qtrue;
+}
+
+static VALUE worker_pool_work_ensure(VALUE _work) {
+	struct IO_Event_WorkerPool_Work *work = (void*)_work;
+
+	while (!work->completed) {
+		if (DEBUG) fprintf(stderr, "worker_pool_work_ensure:rb_fiber_scheduler_blocking_operation_cancel\n");
+		rb_fiber_scheduler_blocking_operation_cancel(work->blocking_operation);
+		
+		int state = 0;
+		rb_protect(worker_pool_work_block, _work, &state);
+		if (DEBUG) fprintf(stderr, "-- worker_pool_work_ensure:work completed=%d, state=%d\n", work->completed, state);
+		
+		if (state) {
+			// Ignore errors raised while waiting for cancellation to complete. rb_ensure
+			// will restore and rethrow the original control-flow state after this returns.
+			rb_set_errinfo(Qnil);
+		}
+	}
+
+	return Qnil;
+}
+
 // Ruby method to submit work and wait for completion
 static VALUE worker_pool_call(VALUE self, VALUE _blocking_operation) {
 	struct IO_Event_WorkerPool *pool;
@@ -357,38 +396,10 @@ static VALUE worker_pool_call(VALUE self, VALUE _blocking_operation) {
 	pthread_cond_signal(&pool->work_available);
 	pthread_mutex_unlock(&pool->mutex);
 	
-	// Block the current fiber until work is completed:
-	int state = 0;
-	while (true) {
-		int current_state = 0;
-		rb_protect(worker_pool_work_begin, (VALUE)&work, &current_state);
-		if (DEBUG) fprintf(stderr, "-- worker_pool_call:work completed=%d, current_state=%d, state=%d\n", work.completed, current_state, state);
-		
-		// Store the first exception state:
-		if (!state) {
-			state = current_state;
-		}
-		
-		// If the work is still in the queue, we must wait for a worker to complete it (even if cancelled):
-		if (work.completed) {
-			// The work was completed, we can exit the loop:
-			break;
-		} else {
-			if (DEBUG) fprintf(stderr, "worker_pool_call:rb_fiber_scheduler_blocking_operation_cancel\n");
-			// Ensure the blocking operation is cancelled:
-			rb_fiber_scheduler_blocking_operation_cancel(blocking_operation);
-			
-			// The work was not completed, we need to wait for it to be completed, so we go around the loop again.
-		}
-	}
-	
-	if (DEBUG) fprintf(stderr, "<- worker_pool_call:work completed=%d, state=%d\n", work.completed, state);
-	
-	if (state) {
-		rb_jump_tag(state);
-	} else {
-		return Qtrue;
-	}
+	// Block the current fiber until work is completed. If blocking exits via an
+	// exception or another non-local jump, ensure the work is cancelled and fully
+	// drained before Ruby restores and rethrows the original control-flow state.
+	return rb_ensure(worker_pool_work_wait, (VALUE)&work, worker_pool_work_ensure, (VALUE)&work);
 }
 
 static VALUE worker_pool_allocate(VALUE klass) {

data/lib/io/event/version.rb

@@ -7,6 +7,6 @@
 class IO
 	# @namespace
 	module Event
-		VERSION = "1.19.3"
+		VERSION = "1.19.5"
 	end
 end

data/readme.md

@@ -18,6 +18,14 @@ Please see the [project documentation](https://socketry.github.io/io-event/) for
 
 Please see the [project releases](https://socketry.github.io/io-event/releases/index) for all releases.
 
+### v1.19.5
+
+  - Preserve the original exception or non-local control flow when `IO::Event::WorkerPool` cancellation interrupts a blocked fiber, while still cancelling and draining the in-flight blocking operation before returning control to Ruby.
+
+### v1.19.4
+
+  - Capture `errno` immediately after `epoll_wait` / `kevent`, preventing stale or subsequently clobbered values from raising a spurious `Errno::*` when a native selector wait is interrupted or skipped.
+
 ### v1.19.3
 
   - Prevent `URing`, `EPoll`, and `KQueue` from entering a native wait when a signal exception becomes pending during the GVL transition. On Ruby versions without `RB_NOGVL_PENDING_INTR_FAIL`, the fallback now refreshes pending-interrupt state immediately before releasing the GVL while preserving the caller's exception-delivery timing.
@@ -51,14 +59,6 @@ Please see the [project releases](https://socketry.github.io/io-event/releases/i
 
   - Handle `IOError` raised while shutting down the pure Ruby interrupt pipe, so `IO::Event::Interrupt#close` does not leak expected shutdown errors from the interrupt fiber.
 
-### v1.16.2
-
-  - Improve timer heap performance by batching scheduled timer insertion, compacting cancelled timers during flush, and avoiding unnecessary heap rebuilds for small incremental inserts.
-
-### v1.16.1
-
-  - Ensure the pure Ruby `Select` selector returns `false`, not `nil`, when `io_wait` resumes without any ready events.
-
 ## Contributing
 
 We welcome contributions to this project.

data/releases.md

@@ -1,5 +1,13 @@
 # Releases
 
+## v1.19.5
+
+  - Preserve the original exception or non-local control flow when `IO::Event::WorkerPool` cancellation interrupts a blocked fiber, while still cancelling and draining the in-flight blocking operation before returning control to Ruby.
+
+## v1.19.4
+
+  - Capture `errno` immediately after `epoll_wait` / `kevent`, preventing stale or subsequently clobbered values from raising a spurious `Errno::*` when a native selector wait is interrupted or skipped.
+
 ## v1.19.3
 
   - Prevent `URing`, `EPoll`, and `KQueue` from entering a native wait when a signal exception becomes pending during the GVL transition. On Ruby versions without `RB_NOGVL_PENDING_INTR_FAIL`, the fallback now refreshes pending-interrupt state immediately before releasing the GVL while preserving the caller's exception-delivery timing.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: io-event
 version: !ruby/object:Gem::Version
-  version: 1.19.3
+  version: 1.19.5
 platform: ruby
 authors:
 - Samuel Williams