io-event 1.19.4 → 1.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d72eba7de108f1051424997dec0f1d83a38a7a4d927089e1ca7ba0478922ef5
-  data.tar.gz: 0a423df73be6c4aec9efc892014b867807794989b45500700a5bbca423ff8915
+  metadata.gz: 648484dee2c6698568b24073b4fcf90a32629dcfa2119c450df16cae77f52c49
+  data.tar.gz: 895241950306f5dbc0f1c0b31f6981ec78096c6f90160c018a56dccc6102b799
 SHA512:
-  metadata.gz: cc15fd5deeaf2aeb9fcad4d58da2e06daf6e9ec6933020ccc2bfb1ad3705e52f52958b5086e459cc4a85c0a5ee22c16482b7cd9d3a0e0ff254f725df72bcc02e
-  data.tar.gz: 7fcab614752bb5db345e31e60a34d52e9b06d1386ac6531b301063ae77a1dd01cc1f5b2beeb5e482a89f4898ca9c85ce4cc56faf4db37219e3fd9c2478266118
+  metadata.gz: ff589133ec2d19d400c0c80daf0dc1cbf448005d26ca2c2df1d893c08371387cc12d37e8d1133379b17ed599cbe947197e0765e59c9c30c603802794283d9226
+  data.tar.gz: ec3c7a5d210053cf1e66d22eb4673c208184a044cb3b55404f34d645fcca0267711fe36ee12b7e8a7ef360d5ff6ed70a3da5ad0d64765406ec52ea2295119c40

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

@@ -593,9 +593,11 @@ VALUE IO_Event_Selector_EPoll_io_wait(VALUE self, VALUE fiber, VALUE io, VALUE e
 #ifdef HAVE_RUBY_IO_BUFFER_H
 
 struct io_read_arguments {
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 	VALUE self;
 	VALUE fiber;
 	VALUE io;
+#endif
 	
 	int flags;
 	
@@ -605,14 +607,20 @@ struct io_read_arguments {
 	void *base;
 	size_t size;
 	
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 	// The minimum number of bytes requested by the caller.
 	size_t length;
+#endif
 };
 
 static
 VALUE io_read_loop(VALUE _arguments) {
 	struct io_read_arguments *arguments = (struct io_read_arguments *)_arguments;
 	
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	ssize_t result = read(arguments->descriptor, arguments->base, arguments->size);
+	return rb_fiber_scheduler_io_result(result, errno);
+#else
 	size_t length = arguments->length;
 	size_t total = 0;
 	
@@ -635,6 +643,7 @@ VALUE io_read_loop(VALUE _arguments) {
 	}
 	
 	return rb_fiber_scheduler_io_result(total, 0);
+#endif
 }
 
 static
@@ -646,14 +655,27 @@ VALUE io_read_ensure(VALUE _arguments) {
 	return Qnil;
 }
 
-VALUE IO_Event_Selector_EPoll_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length, VALUE _offset) {
-	size_t offset = NUM2SIZET(_offset);
-	size_t length = NUM2SIZET(_length);
-	
+VALUE IO_Event_Selector_EPoll_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _first, VALUE _second) {
 	void *base;
 	size_t size;
 	rb_io_buffer_get_bytes_for_writing(buffer, &base, &size);
 	
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	size_t offset = NUM2SIZET(_first);
+	size_t length = NUM2SIZET(_second);
+	
+	if (!IO_Event_Selector_valid_buffer_range(size, offset, length)) {
+		return rb_fiber_scheduler_io_result(-1, EINVAL);
+	} else if (length == 0) {
+		return rb_fiber_scheduler_io_result(0, 0);
+	}
+	
+	base = (char*)base + offset;
+	size = length;
+#else
+	size_t length = NUM2SIZET(_first);
+	size_t offset = NUM2SIZET(_second);
+	
 	if (offset > size) {
 		return rb_fiber_scheduler_io_result(-1, EINVAL);
 	} else if (offset == size) {
@@ -662,19 +684,24 @@ VALUE IO_Event_Selector_EPoll_io_read(VALUE self, VALUE fiber, VALUE io, VALUE b
 	
 	base = (char*)base + offset;
 	size -= offset;
+#endif
 	
 	int descriptor = IO_Event_Selector_io_descriptor(io);
 	
 	struct io_read_arguments io_read_arguments = {
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 		.self = self,
 		.fiber = fiber,
 		.io = io,
+#endif
 		
 		.flags = IO_Event_Selector_nonblock_set(descriptor),
 		.descriptor = descriptor,
 		.base = base,
 		.size = size,
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 		.length = length,
+#endif
 	};
 	
 	RB_OBJ_WRITTEN(self, Qundef, fiber);
@@ -682,6 +709,7 @@ VALUE IO_Event_Selector_EPoll_io_read(VALUE self, VALUE fiber, VALUE io, VALUE b
 	return rb_ensure(io_read_loop, (VALUE)&io_read_arguments, io_read_ensure, (VALUE)&io_read_arguments);
 }
 
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 VALUE IO_Event_Selector_EPoll_io_read_compatible(int argc, VALUE *argv, VALUE self)
 {
 	rb_check_arity(argc, 4, 5);
@@ -694,11 +722,14 @@ VALUE IO_Event_Selector_EPoll_io_read_compatible(int argc, VALUE *argv, VALUE se
 	
 	return IO_Event_Selector_EPoll_io_read(self, argv[0], argv[1], argv[2], argv[3], _offset);
 }
+#endif
 
 struct io_write_arguments {
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 	VALUE self;
 	VALUE fiber;
 	VALUE io;
+#endif
 	
 	int flags;
 	
@@ -708,14 +739,20 @@ struct io_write_arguments {
 	const void *base;
 	size_t size;
 	
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 	// The minimum number of bytes requested by the caller.
 	size_t length;
+#endif
 };
 
 static
 VALUE io_write_loop(VALUE _arguments) {
 	struct io_write_arguments *arguments = (struct io_write_arguments *)_arguments;
 	
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	ssize_t result = write(arguments->descriptor, arguments->base, arguments->size);
+	return rb_fiber_scheduler_io_result(result, errno);
+#else
 	size_t length = arguments->length;
 	size_t total = 0;
 	
@@ -738,6 +775,7 @@ VALUE io_write_loop(VALUE _arguments) {
 	}
 	
 	return rb_fiber_scheduler_io_result(total, 0);
+#endif
 };
 
 static
@@ -749,14 +787,27 @@ VALUE io_write_ensure(VALUE _arguments) {
 	return Qnil;
 };
 
-VALUE IO_Event_Selector_EPoll_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length, VALUE _offset) {
-	size_t length = NUM2SIZET(_length);
-	size_t offset = NUM2SIZET(_offset);
-	
+VALUE IO_Event_Selector_EPoll_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _first, VALUE _second) {
 	const void *base;
 	size_t size;
 	rb_io_buffer_get_bytes_for_reading(buffer, &base, &size);
 	
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	size_t offset = NUM2SIZET(_first);
+	size_t length = NUM2SIZET(_second);
+	
+	if (!IO_Event_Selector_valid_buffer_range(size, offset, length)) {
+		return rb_fiber_scheduler_io_result(-1, EINVAL);
+	} else if (length == 0) {
+		return rb_fiber_scheduler_io_result(0, 0);
+	}
+	
+	base = (const char*)base + offset;
+	size = length;
+#else
+	size_t length = NUM2SIZET(_first);
+	size_t offset = NUM2SIZET(_second);
+	
 	if (length > size) {
 		rb_raise(rb_eRuntimeError, "Length exceeds size of buffer!");
 	}
@@ -769,19 +820,24 @@ VALUE IO_Event_Selector_EPoll_io_write(VALUE self, VALUE fiber, VALUE io, VALUE
 	
 	base = (const char*)base + offset;
 	size -= offset;
+#endif
 	
 	int descriptor = IO_Event_Selector_io_descriptor(io);
 	
 	struct io_write_arguments io_write_arguments = {
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 		.self = self,
 		.fiber = fiber,
 		.io = io,
+#endif
 		
 		.flags = IO_Event_Selector_nonblock_set(descriptor),
 		.descriptor = descriptor,
 		.base = base,
 		.size = size,
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 		.length = length,
+#endif
 	};
 	
 	RB_OBJ_WRITTEN(self, Qundef, fiber);
@@ -789,6 +845,7 @@ VALUE IO_Event_Selector_EPoll_io_write(VALUE self, VALUE fiber, VALUE io, VALUE
 	return rb_ensure(io_write_loop, (VALUE)&io_write_arguments, io_write_ensure, (VALUE)&io_write_arguments);
 }
 
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 VALUE IO_Event_Selector_EPoll_io_write_compatible(int argc, VALUE *argv, VALUE self)
 {
 	rb_check_arity(argc, 4, 5);
@@ -801,6 +858,7 @@ VALUE IO_Event_Selector_EPoll_io_write_compatible(int argc, VALUE *argv, VALUE s
 	
 	return IO_Event_Selector_EPoll_io_write(self, argv[0], argv[1], argv[2], argv[3], _offset);
 }
+#endif
 
 #endif
 
@@ -1123,13 +1181,14 @@ void Init_IO_Event_Selector_EPoll(VALUE IO_Event_Selector) {
 	rb_define_method(IO_Event_Selector_EPoll, "io_wait", IO_Event_Selector_EPoll_io_wait, 3);
 	
 #ifdef HAVE_RUBY_IO_BUFFER_H
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	rb_define_method(IO_Event_Selector_EPoll, "io_read", IO_Event_Selector_EPoll_io_read, 5);
+	rb_define_method(IO_Event_Selector_EPoll, "io_write", IO_Event_Selector_EPoll_io_write, 5);
+#else
 	rb_define_method(IO_Event_Selector_EPoll, "io_read", IO_Event_Selector_EPoll_io_read_compatible, -1);
 	rb_define_method(IO_Event_Selector_EPoll, "io_write", IO_Event_Selector_EPoll_io_write_compatible, -1);
 #endif
-	
-	// Once compatibility isn't a concern, we can do this:
-	// rb_define_method(IO_Event_Selector_EPoll, "io_read", IO_Event_Selector_EPoll_io_read, 5);
-	// rb_define_method(IO_Event_Selector_EPoll, "io_write", IO_Event_Selector_EPoll_io_write, 5);
+#endif
 	
 	rb_define_method(IO_Event_Selector_EPoll, "process_wait", IO_Event_Selector_EPoll_process_wait, 3);
 }

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

@@ -582,9 +582,11 @@ VALUE IO_Event_Selector_KQueue_io_wait(VALUE self, VALUE fiber, VALUE io, VALUE
 #ifdef HAVE_RUBY_IO_BUFFER_H
 
 struct io_read_arguments {
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 	VALUE self;
 	VALUE fiber;
 	VALUE io;
+#endif
 	
 	int flags;
 	
@@ -594,14 +596,20 @@ struct io_read_arguments {
 	void *base;
 	size_t size;
 	
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 	// The minimum number of bytes requested by the caller.
 	size_t length;
+#endif
 };
 
 static
 VALUE io_read_loop(VALUE _arguments) {
 	struct io_read_arguments *arguments = (struct io_read_arguments *)_arguments;
 	
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	ssize_t result = read(arguments->descriptor, arguments->base, arguments->size);
+	return rb_fiber_scheduler_io_result(result, errno);
+#else
 	size_t length = arguments->length;
 	size_t total = 0;
 	
@@ -631,6 +639,7 @@ VALUE io_read_loop(VALUE _arguments) {
 	
 	if (DEBUG_IO_READ) fprintf(stderr, "io_read_loop(fd=%d, length=%zu) -> %zu\n", arguments->descriptor, length, total);
 	return rb_fiber_scheduler_io_result(total, 0);
+#endif
 }
 
 static
@@ -642,17 +651,30 @@ VALUE io_read_ensure(VALUE _arguments) {
 	return Qnil;
 }
 
-VALUE IO_Event_Selector_KQueue_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length, VALUE _offset) {
+VALUE IO_Event_Selector_KQueue_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _first, VALUE _second) {
 	struct IO_Event_Selector_KQueue *selector = NULL;
 	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
-	size_t length = NUM2SIZET(_length);
-	size_t offset = NUM2SIZET(_offset);
-	
 	void *base;
 	size_t size;
 	rb_io_buffer_get_bytes_for_writing(buffer, &base, &size);
 	
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	size_t offset = NUM2SIZET(_first);
+	size_t length = NUM2SIZET(_second);
+	
+	if (!IO_Event_Selector_valid_buffer_range(size, offset, length)) {
+		return rb_fiber_scheduler_io_result(-1, EINVAL);
+	} else if (length == 0) {
+		return rb_fiber_scheduler_io_result(0, 0);
+	}
+	
+	base = (char*)base + offset;
+	size = length;
+#else
+	size_t length = NUM2SIZET(_first);
+	size_t offset = NUM2SIZET(_second);
+	
 	if (offset > size) {
 		return rb_fiber_scheduler_io_result(-1, EINVAL);
 	} else if (offset == size) {
@@ -661,19 +683,24 @@ VALUE IO_Event_Selector_KQueue_io_read(VALUE self, VALUE fiber, VALUE io, VALUE
 	
 	base = (char*)base + offset;
 	size -= offset;
+#endif
 	
 	int descriptor = IO_Event_Selector_io_descriptor(io);
 	
 	struct io_read_arguments io_read_arguments = {
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 		.self = self,
 		.fiber = fiber,
 		.io = io,
+#endif
 		
 		.flags = IO_Event_Selector_nonblock_set(descriptor),
 		.descriptor = descriptor,
 		.base = base,
 		.size = size,
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 		.length = length,
+#endif
 	};
 	
 	RB_OBJ_WRITTEN(self, Qundef, fiber);
@@ -681,6 +708,7 @@ VALUE IO_Event_Selector_KQueue_io_read(VALUE self, VALUE fiber, VALUE io, VALUE
 	return rb_ensure(io_read_loop, (VALUE)&io_read_arguments, io_read_ensure, (VALUE)&io_read_arguments);
 }
 
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 static VALUE IO_Event_Selector_KQueue_io_read_compatible(int argc, VALUE *argv, VALUE self)
 {
 	rb_check_arity(argc, 4, 5);
@@ -693,11 +721,14 @@ static VALUE IO_Event_Selector_KQueue_io_read_compatible(int argc, VALUE *argv,
 	
 	return IO_Event_Selector_KQueue_io_read(self, argv[0], argv[1], argv[2], argv[3], _offset);
 }
+#endif
 
 struct io_write_arguments {
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 	VALUE self;
 	VALUE fiber;
 	VALUE io;
+#endif
 	
 	int flags;
 	
@@ -707,14 +738,20 @@ struct io_write_arguments {
 	const void *base;
 	size_t size;
 	
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 	// The minimum number of bytes requested by the caller.
 	size_t length;
+#endif
 };
 
 static
 VALUE io_write_loop(VALUE _arguments) {
 	struct io_write_arguments *arguments = (struct io_write_arguments *)_arguments;
 	
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	ssize_t result = write(arguments->descriptor, arguments->base, arguments->size);
+	return rb_fiber_scheduler_io_result(result, errno);
+#else
 	size_t length = arguments->length;
 	size_t total = 0;
 	
@@ -744,6 +781,7 @@ VALUE io_write_loop(VALUE _arguments) {
 	
 	if (DEBUG_IO_WRITE) fprintf(stderr, "io_write_loop(fd=%d, length=%zu) -> %zu\n", arguments->descriptor, length, total);
 	return rb_fiber_scheduler_io_result(total, 0);
+#endif
 };
 
 static
@@ -755,17 +793,30 @@ VALUE io_write_ensure(VALUE _arguments) {
 	return Qnil;
 };
 
-VALUE IO_Event_Selector_KQueue_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length, VALUE _offset) {
+VALUE IO_Event_Selector_KQueue_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _first, VALUE _second) {
 	struct IO_Event_Selector_KQueue *selector = NULL;
 	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
-	size_t length = NUM2SIZET(_length);
-	size_t offset = NUM2SIZET(_offset);
-	
 	const void *base;
 	size_t size;
 	rb_io_buffer_get_bytes_for_reading(buffer, &base, &size);
 	
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	size_t offset = NUM2SIZET(_first);
+	size_t length = NUM2SIZET(_second);
+	
+	if (!IO_Event_Selector_valid_buffer_range(size, offset, length)) {
+		return rb_fiber_scheduler_io_result(-1, EINVAL);
+	} else if (length == 0) {
+		return rb_fiber_scheduler_io_result(0, 0);
+	}
+	
+	base = (const char*)base + offset;
+	size = length;
+#else
+	size_t length = NUM2SIZET(_first);
+	size_t offset = NUM2SIZET(_second);
+	
 	if (length > size) {
 		rb_raise(rb_eRuntimeError, "Length exceeds size of buffer!");
 	}
@@ -778,19 +829,24 @@ VALUE IO_Event_Selector_KQueue_io_write(VALUE self, VALUE fiber, VALUE io, VALUE
 	
 	base = (const char*)base + offset;
 	size -= offset;
+#endif
 	
 	int descriptor = IO_Event_Selector_io_descriptor(io);
 	
 	struct io_write_arguments io_write_arguments = {
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 		.self = self,
 		.fiber = fiber,
 		.io = io,
+#endif
 		
 		.flags = IO_Event_Selector_nonblock_set(descriptor),
 		.descriptor = descriptor,
 		.base = base,
 		.size = size,
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 		.length = length,
+#endif
 	};
 	
 	RB_OBJ_WRITTEN(self, Qundef, fiber);
@@ -798,6 +854,7 @@ VALUE IO_Event_Selector_KQueue_io_write(VALUE self, VALUE fiber, VALUE io, VALUE
 	return rb_ensure(io_write_loop, (VALUE)&io_write_arguments, io_write_ensure, (VALUE)&io_write_arguments);
 }
 
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 static VALUE IO_Event_Selector_KQueue_io_write_compatible(int argc, VALUE *argv, VALUE self)
 {
 	rb_check_arity(argc, 4, 5);
@@ -810,6 +867,7 @@ static VALUE IO_Event_Selector_KQueue_io_write_compatible(int argc, VALUE *argv,
 	
 	return IO_Event_Selector_KQueue_io_write(self, argv[0], argv[1], argv[2], argv[3], _offset);
 }
+#endif
 
 #endif
 
@@ -1125,8 +1183,13 @@ void Init_IO_Event_Selector_KQueue(VALUE IO_Event_Selector) {
 	rb_define_method(IO_Event_Selector_KQueue, "io_wait", IO_Event_Selector_KQueue_io_wait, 3);
 	
 #ifdef HAVE_RUBY_IO_BUFFER_H
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	rb_define_method(IO_Event_Selector_KQueue, "io_read", IO_Event_Selector_KQueue_io_read, 5);
+	rb_define_method(IO_Event_Selector_KQueue, "io_write", IO_Event_Selector_KQueue_io_write, 5);
+#else
 	rb_define_method(IO_Event_Selector_KQueue, "io_read", IO_Event_Selector_KQueue_io_read_compatible, -1);
 	rb_define_method(IO_Event_Selector_KQueue, "io_write", IO_Event_Selector_KQueue_io_write_compatible, -1);
+#endif
 #endif
 	
 	rb_define_method(IO_Event_Selector_KQueue, "process_wait", IO_Event_Selector_KQueue_process_wait, 3);

data/ext/io/event/selector/selector.h

@@ -40,6 +40,10 @@ static inline int IO_Event_try_again(int error) {
 	return error == EAGAIN || error == EWOULDBLOCK;
 }
 
+static inline int IO_Event_Selector_valid_buffer_range(size_t size, size_t offset, size_t length) {
+	return offset <= size && length <= size - offset;
+}
+
 // Enter a blocking region without the GVL. On Rubies without
 // `RB_NOGVL_PENDING_INTR_FAIL`, refresh pending-interrupt state immediately
 // before releasing the GVL so a signal cannot be stranded in the queue.