diff --git a/lib/async/scheduler.rb b/lib/async/scheduler.rb index ffdd9e17..d0a06ba4 100644 --- a/lib/async/scheduler.rb +++ b/lib/async/scheduler.rb @@ -64,6 +64,22 @@ def blocking_operation_wait(work) private_constant :BlockingOperationWait + # Implements `#io_close` if the selector supports it. + module IoClose + # Close the given file descriptor. + # + # @public Since *Async v2.47* and *Ruby v4.0*. + # @asynchronous May be non-blocking. + # + # @parameter descriptor [Integer] The fd to close. + # @returns [Boolean] Whether the selector closed the descriptor. + def io_close(descriptor) + !!@selector&.io_close(descriptor) + end + end + + private_constant :IoClose + if ::IO::Event.const_defined?(:WorkerPool) WorkerPool = ::IO::Event::WorkerPool else @@ -99,6 +115,10 @@ def initialize(parent = nil, selector: nil, profiler: Profiler&.default, worker_ if @worker_pool self.singleton_class.prepend(BlockingOperationWait) end + + if @selector.respond_to?(:io_close) + self.singleton_class.prepend(IoClose) + end end # Compute the scheduler load according to the busy and idle times that are updated by the run loop. diff --git a/test/async/scheduler.rb b/test/async/scheduler.rb index d845f238..e879f5e8 100644 --- a/test/async/scheduler.rb +++ b/test/async/scheduler.rb @@ -164,6 +164,36 @@ end end + with "#io_close" do + it "delegates to selectors that support io_close" do + selector = Object.new + calls = [] + selector.define_singleton_method(:io_close) do |descriptor| + calls << descriptor + true + end + scheduler = Async::Scheduler.new(selector: selector) + + expect(scheduler.io_close(10)).to be == true + expect(calls).to be == [10] + end + + it "is not defined when the selector does not support io_close" do + scheduler = Async::Scheduler.new(selector: Object.new) + + expect(scheduler).not.to be(:respond_to?, :io_close) + end + + it "lets Ruby close the descriptor after the scheduler is closed" do + selector = IO::Event::Selector.new(Fiber.current) + selector.define_singleton_method(:io_close){|descriptor| true} + scheduler = Async::Scheduler.new(selector: selector) + scheduler.close + + expect(scheduler.io_close(10)).to be == false + end + end + with "#cancel" do it "shares the generated cancellation cause with child tasks" do cause = Async::Cancel::Cause.new("Cancelling task!") diff --git a/test/io.rb b/test/io.rb index 6b8a7294..c0194fb8 100644 --- a/test/io.rb +++ b/test/io.rb @@ -93,6 +93,59 @@ end with "#close" do + it "closes the descriptor" do + r, w = IO.pipe + + w.close + + expect(w).to be(:closed?) + # The reader only sees the end of the stream once the descriptor is actually closed: + expect(r.read).to be == "" + ensure + r&.close + end + + it "closes the descriptor using the scheduler" do + skip_unless_minimum_ruby_version("4.0") + skip "The selector does not support io_close!" unless scheduler.respond_to?(:io_close) + + r, w = IO.pipe + descriptor = w.fileno + + closed = [] + mock(scheduler) do |mock| + mock.before(:io_close){|descriptor| closed << descriptor} + end + + w.close + + expect(closed).to be(:include?, descriptor) + expect(w).to be(:closed?) + expect(r.read).to be == "" + ensure + r&.close + end + + it "closes the descriptor while the scheduler is terminating" do + r, w = IO.pipe + + Thread.new do + Sync do + # This task is still running when the scheduler exits, so the descriptor is closed during termination, just before the selector itself is closed: + Async(transient: true) do + sleep + ensure + w.close + end + end + end.join + + expect(w).to be(:closed?) + expect(r.read).to be == "" + ensure + r&.close + end + it "can interrupt reading fiber when closing" do skip_unless_minimum_ruby_version("3.5")