Implement IO#wait with recent changes to MRI

IO#wait used to be a alias to wait_readable years ago, but the interface changed a lot.

Also update the related tests from MRI.

Author: larskanis

lib/truffle/io/wait.rb

@@ -14,17 +14,75 @@ def nread
 
   def ready?
     ensure_open_and_readable
-    Truffle::IOOperations.poll(self, Truffle::IOOperations::POLLIN, 0)
+    Truffle::IOOperations.poll(self, Truffle::IOOperations::POLLIN, 0) > 0
   end
 
   def wait_readable(timeout = nil)
     ensure_open_and_readable
-    Truffle::IOOperations.poll(self, Truffle::IOOperations::POLLIN, timeout) ? self : nil
+    Truffle::IOOperations.poll(self, Truffle::IOOperations::POLLIN, timeout) > 0 ? self : nil
   end
-  alias_method :wait, :wait_readable
 
   def wait_writable(timeout = nil)
     ensure_open_and_writable
-    Truffle::IOOperations.poll(self, Truffle::IOOperations::POLLOUT, timeout) ? self : nil
+    Truffle::IOOperations.poll(self, Truffle::IOOperations::POLLOUT, timeout) > 0 ? self : nil
+  end
+
+
+  # call-seq:
+  #   io.wait(events, timeout) -> event mask, false or nil
+  #   io.wait(timeout = nil, mode = :read) -> self, true, or false
+  #
+  # Waits until the IO becomes ready for the specified events and returns the
+  # subset of events that become ready, or a falsy value when times out.
+  #
+  # The events can be a bit mask of +IO::READABLE+, +IO::WRITABLE+ or
+  # +IO::PRIORITY+.
+  #
+  # Returns a truthy value immediately when buffered data is available.
+  #
+  # Optional parameter +mode+ is one of +:read+, +:write+, or
+  # +:read_write+.
+  #
+  def wait(*args)
+    ensure_open
+
+    if args.size != 2 || args[0].is_a?(Symbol) || args[1].is_a?(Symbol)
+      # Slow/messy path:
+
+      timeout = :undef
+      events = 0
+      args.each do |arg|
+        if arg.is_a?(Symbol)
+          events |= case arg
+                    when :r, :read, :readable then IO::READABLE
+                    when :w, :write, :writable then IO::WRITABLE
+                    when :rw, :read_write, :readable_writable then IO::READABLE | IO::WRITABLE
+                    else
+                      raise ArgumentError, "unsupported mode: #{mode.inspect}"
+                    end
+
+        elsif timeout == :undef
+          timeout = arg
+        else
+          raise ArgumentError, 'timeout given more than once'
+        end
+      end
+
+      timeout = nil if timeout == :undef
+
+      events = IO::READABLE if events == 0
+
+      res = Truffle::IOOperations.poll(self, events, timeout)
+      res == 0 ? nil : self
+    else
+      # argc == 2 and neither are symbols
+      # This is the fast path and the new interface:
+
+      events, timeout = *args
+      raise ArgumentError, 'Events must be positive integer!' if events <= 0
+      res = Truffle::IOOperations.poll(self, events, timeout)
+      # return events as bit mask
+      res == 0 ? nil : res
+    end
   end
 end

src/main/c/truffleposix/truffleposix.c

@@ -117,7 +117,7 @@ int truffleposix_poll(int fd, int events, int timeout_ms) {
   fds.fd = fd;
   fds.events = events;
 
-  return poll(&fds, 1, timeout_ms);
+  return poll(&fds, 1, timeout_ms) >= 0 ? fds.revents : -1;
 }
 
 int truffleposix_select(int nread, int *readfds, int nwrite, int *writefds,

src/main/ruby/truffleruby/core/truffle/io_operations.rb

@@ -205,9 +205,9 @@ def self.select(readables, readable_ios, writables, writable_ios, errorables, er
 
     end
 
-    # This method will return a true if poll returned without error
-    # with an event within the timeout, false if the timeout expired,
-    # or raises an exception for an errno.
+    # This method will return an event mask if poll returned without error.
+    # The event mask is >0 when an event occured within the timeout, 0 if the timeout expired.
+    # Raises an exception for an errno.
     def self.poll(io, event_mask, timeout)
       if (event_mask & POLLIN) != 0
         return 1 unless io.__send__(:buffer_empty?)
@@ -257,7 +257,7 @@ def self.poll(io, event_mask, timeout)
               Errno.handle_errno(errno)
             end
           else
-            primitive_result > 0
+            primitive_result
           end
       end while result == :retry
 

test/mri/tests/io/wait/test_io_wait.rb

@@ -3,10 +3,9 @@
 require 'test/unit'
 require 'timeout'
 require 'socket'
-begin
-  require 'io/wait'
-rescue LoadError
-end
+
+# For `IO#ready?` and `IO#nread`:
+require 'io/wait'
 
 class TestIOWait < Test::Unit::TestCase
 
@@ -50,6 +49,7 @@ def test_buffered_ready?
   end
 
   def test_wait
+    omit 'unstable on MinGW' if /mingw/ =~ RUBY_PLATFORM
     assert_nil @r.wait(0)
     @w.syswrite "."
     sleep 0.1
@@ -161,6 +161,34 @@ def test_wait_readwrite_timeout
     assert_equal @w, @w.wait(0.01, :read_write)
   end
 
+  def test_wait_mask_writable
+    omit("Missing IO::WRITABLE!") unless IO.const_defined?(:WRITABLE)
+    assert_equal IO::WRITABLE, @w.wait(IO::WRITABLE, 0)
+  end
+
+  def test_wait_mask_readable
+    omit("Missing IO::READABLE!") unless IO.const_defined?(:READABLE)
+    @w.write("Hello World\n" * 3)
+    assert_equal IO::READABLE, @r.wait(IO::READABLE, 0)
+
+    @r.gets
+    assert_equal IO::READABLE, @r.wait(IO::READABLE, 0)
+  end
+
+  def test_wait_mask_zero
+    omit("Missing IO::WRITABLE!") unless IO.const_defined?(:WRITABLE)
+    assert_raise(ArgumentError) do
+      @w.wait(0, 0)
+    end
+  end
+
+  def test_wait_mask_negative
+    omit("Missing IO::WRITABLE!") unless IO.const_defined?(:WRITABLE)
+    assert_raise(ArgumentError) do
+      @w.wait(-6, 0)
+    end
+  end
+
 private
 
   def fill_pipe

test/mri/tests/io/wait/test_io_wait_uncommon.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 require 'test/unit'
-require 'io/wait'
 
 # test uncommon device types to check portability problems
 # We may optimize IO#wait_*able for non-Linux kernels in the future
@@ -13,7 +12,7 @@ def test_tty_wait
   end
 
   def test_fifo_wait
-    skip 'no mkfifo' unless File.respond_to?(:mkfifo) && IO.const_defined?(:NONBLOCK)
+    omit 'no mkfifo' unless File.respond_to?(:mkfifo) && IO.const_defined?(:NONBLOCK)
     require 'tmpdir'
     Dir.mktmpdir('rubytest-fifo') do |dir|
       fifo = "#{dir}/fifo"