polyphony 0.45.2 → 0.47.0

data/lib/polyphony/extensions/debug.rb

@@ -0,0 +1,13 @@
+module ::Kernel
+  def trace(*args)
+    STDOUT.orig_write(format_trace(args))
+  end
+
+  def format_trace(args)
+    if args.size > 1 && args.first.is_a?(String)
+      format("%s: %p\n", args.shift, args.size == 1 ? args.first : args)
+    else
+      format("%p\n", args.size == 1 ? args.first : args)
+    end
+  end
+end

data/lib/polyphony/extensions/fiber.rb

@@ -103,7 +103,7 @@ module Polyphony
       suspend
       fibers.map(&:result)
     ensure
-      await_select_cleanup(state)
+      await_select_cleanup(state) if state
     end
     alias_method :join, :await
 
@@ -165,6 +165,20 @@ module Polyphony
         state[:selected] = true
       end
     end
+
+    # Creates and schedules with priority an out-of-band fiber that runs the
+    # supplied block. If any uncaught exception is raised while the fiber is
+    # running, it will bubble up to the main thread's main fiber, which will
+    # also be scheduled with priority. This method is mainly used trapping
+    # signals (see also the patched `Kernel#trap`)
+    def schedule_priority_oob_fiber(&block)
+      f = Fiber.new do
+        block.call
+      rescue Exception => e
+        Thread.current.schedule_and_wakeup(Thread.main.main_fiber, e)
+      end
+      Thread.current.schedule_and_wakeup(f, nil)
+    end
   end
 
   # Methods for controlling child fibers
@@ -294,7 +308,7 @@ module Polyphony
       @waiting_fibers&.each_key { |f| f.schedule(result) }
       
       # propagate unaught exception to parent
-      @parent&.schedule(result) if uncaught_exception && !@waiting_fibers
+      @parent&.schedule_with_priority(result) if uncaught_exception && !@waiting_fibers
     end
 
     def when_done(&block)
@@ -321,7 +335,11 @@ class ::Fiber
   end
 
   def inspect
-    "#<Fiber:#{object_id} #{location} (#{state})>"
+    if @tag
+      "#<Fiber #{tag}:#{object_id} #{location} (#{state})>"
+    else
+      "#<Fiber:#{object_id} #{location} (#{state})>"
+    end
   end
   alias_method :to_s, :inspect
 

data/lib/polyphony/extensions/io.rb

@@ -90,11 +90,22 @@ class ::IO
   # def each_codepoint
   # end
 
-  # def getbyte
-  # end
+  alias_method :orig_getbyte, :getbyte
+  def getbyte
+    char = getc
+    char ? char.getbyte(0) : nil
+  end
 
-  # def getc
-  # end
+  alias_method :orig_getc, :getc
+  def getc
+    return @read_buffer.slice!(0) if @read_buffer && !@read_buffer.empty?
+    
+    @read_buffer ||= +''
+    Thread.current.backend.read(self, @read_buffer, 8192, false)
+    return @read_buffer.slice!(0) if !@read_buffer.empty?
+
+    nil
+  end
 
   alias_method :orig_read, :read
   def read(len = nil)

data/lib/polyphony/extensions/openssl.rb

@@ -36,6 +36,12 @@ class ::OpenSSL::SSL::SSLSocket
     end
   end
 
+  def accept_loop
+    loop do
+      yield accept
+    end
+  end
+
   alias_method :orig_sysread, :sysread
   def sysread(maxlen, buf = +'')
     loop do

data/lib/polyphony/extensions/socket.rb

@@ -19,16 +19,21 @@ class ::Socket
   end
 
   def recv(maxlen, flags = 0, outbuf = nil)
-    outbuf ||= +''
-    loop do
-      result = recv_nonblock(maxlen, flags, outbuf, **NO_EXCEPTION)
-      case result
-      when nil then raise IOError
-      when :wait_readable then Thread.current.backend.wait_io(self, false)
-      else
-        return result
-      end
-    end
+    Thread.current.backend.recv(self, buf || +'', maxlen)
+    # outbuf ||= +''
+    # loop do
+    #   result = recv_nonblock(maxlen, flags, outbuf, **NO_EXCEPTION)
+    #   case result
+    #   when nil then raise IOError
+    #   when :wait_readable then Thread.current.backend.wait_io(self, false)
+    #   else
+    #     return result
+    #   end
+    # end
+  end
+
+  def recv_loop(&block)
+    Thread.current.backend.recv_loop(self, &block)
   end
 
   def recvfrom(maxlen, flags = 0)
@@ -44,6 +49,19 @@ class ::Socket
     end
   end
 
+  def send(mesg, flags = 0)
+    Thread.current.backend.send(self, mesg)
+  end
+
+  def write(str)
+    Thread.current.backend.send(self, str)
+  end
+  alias_method :<<, :write
+
+  def readpartial(maxlen, str = +'')
+    Thread.current.backend.recv(self, str, maxlen)
+  end
+
   ZERO_LINGER = [0, 0].pack('ii').freeze
 
   def dont_linger
@@ -120,6 +138,37 @@ class ::TCPSocket
     setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEPORT, 1)
   end
 
+  def recv(maxlen, flags = 0, outbuf = nil)
+    Thread.current.backend.recv(self, buf || +'', maxlen)
+  end
+
+  def recv_loop(&block)
+    Thread.current.backend.recv_loop(self, &block)
+  end
+
+  def send(mesg, flags = 0)
+    Thread.current.backend.send(self, mesg)
+  end
+
+  def write(str)
+    Thread.current.backend.send(self, str)
+  end
+  alias_method :<<, :write
+
+  def readpartial(maxlen, str = nil)
+    @read_buffer ||= +''
+    result = Thread.current.backend.recv(self, @read_buffer, maxlen)
+    raise EOFError unless result
+
+    if str
+      str << @read_buffer
+    else
+      str = @read_buffer
+    end
+    @read_buffer = +''
+    str
+  end
+
   def read_nonblock(len, str = nil, exception: true)
     @io.read_nonblock(len, str, exception: exception)
   end
@@ -142,6 +191,10 @@ class ::TCPServer
     @io.accept
   end
 
+  def accept_loop(&block)
+    Thread.current.backend.accept_loop(@io, &block)
+  end
+
   alias_method :orig_close, :close
   def close
     @io.close

data/lib/polyphony/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polyphony
-  VERSION = '0.45.2'
+  VERSION = '0.47.0'
 end

data/polyphony.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.required_ruby_version = '>= 2.6'
 
-  s.add_development_dependency  'rake-compiler',        '1.0.5'
+  s.add_development_dependency  'rake-compiler',        '1.1.1'
   s.add_development_dependency  'minitest',             '5.13.0'
   s.add_development_dependency  'minitest-reporters',   '1.4.2'
   s.add_development_dependency  'simplecov',            '0.17.1'

data/test/helper.rb

@@ -22,29 +22,52 @@ class ::Fiber
   attr_writer :auto_watcher
 end
 
+module ::Kernel
+  def trace(*args)
+    STDOUT.orig_write(format_trace(args))
+  end
+
+  def format_trace(args)
+    if args.first.is_a?(String)
+      if args.size > 1
+        format("%s: %p\n", args.shift, args)
+      else
+        format("%s\n", args.first)
+      end
+    else
+      format("%p\n", args.size == 1 ? args.first : args)
+    end
+  end
+end
+
 class MiniTest::Test
   def setup
-    # puts "* setup #{self.name}"
+    # trace "* setup #{self.name}"
     if Fiber.current.children.size > 0
       puts "Children left: #{Fiber.current.children.inspect}"
       exit!
     end
     Fiber.current.setup_main_fiber
     Fiber.current.instance_variable_set(:@auto_watcher, nil)
+    Thread.current.backend.finalize
     Thread.current.backend = Polyphony::Backend.new
-    sleep 0 # apparently this helps with timer accuracy
+    sleep 0
   end
 
   def teardown
-    # puts "* teardown #{self.name.inspect} Fiber.current: #{Fiber.current.inspect}"
+    # trace "* teardown #{self.name}"
     Fiber.current.terminate_all_children
     Fiber.current.await_all_children
-    Fiber.current.auto_watcher = nil
+    Fiber.current.instance_variable_set(:@auto_watcher, nil)
   rescue => e
     puts e
     puts e.backtrace.join("\n")
     exit!
   end
+
+  def fiber_tree(fiber)
+    { fiber: fiber, children: fiber.children.map { |f| fiber_tree(f) } }
+  end
 end
 
 module Kernel
@@ -54,3 +77,12 @@ module Kernel
     e
   end
 end
+
+module Minitest::Assertions
+  def assert_in_range exp_range, act
+    msg = message(msg) { "Expected #{mu_pp(act)} to be in range #{mu_pp(exp_range)}" }
+    assert exp_range.include?(act), msg
+  end
+end
+
+puts "Polyphony backend: #{Thread.current.backend.kind}"

data/test/io_uring_test.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+::Exception.__disable_sanitized_backtrace__ = true
+
+module ::Kernel
+  def trace(*args)
+    STDOUT.orig_write(format_trace(args))
+  end
+
+  def format_trace(args)
+    if args.first.is_a?(String)
+      if args.size > 1
+        format("%s: %p\n", args.shift, args)
+      else
+        format("%s\n", args.first)
+      end
+    else
+      format("%p\n", args.size == 1 ? args.first : args)
+    end
+  end
+end
+
+i, o = IO.pipe
+
+buf = []
+f = spin do
+  buf << :ready
+  # loop do
+  #   s = Thread.current.backend.read(i, +'', 6, false)
+  #   trace read_result: s
+  #   break if s.nil?
+  #   buf << s
+  # rescue Exception => e
+  #   trace exception: e
+  #   raise e
+  # end
+  Thread.current.backend.read_loop(i) { |d| buf << d }
+  buf << :done
+end
+
+# writing always causes snoozing
+o << 'foo'
+o << 'bar'
+trace '...closing'
+o.close
+trace '...closed'
+
+f.await
+
+raise "Bad result: #{buf.inspect}" unless buf == [:ready, 'foo', 'bar', :done]
+
+puts '-' * 80
+p buf

data/test/stress.rb

@@ -6,6 +6,7 @@ TEST_CMD = 'ruby test/run.rb'
 
 def run_test(count)
   puts "#{count}: running tests..."
+  # sleep 1
   system(TEST_CMD)
   return if $?.exitstatus == 0
 
@@ -15,7 +16,9 @@ end
 
 trap('INT') { exit! }
 t0 = Time.now
-count.times { |i| run_test(i + 1) }
+count.times do |i|
+  run_test(i + 1)
+end
 elapsed = Time.now - t0
 puts format(
   "Successfully ran %d tests in %f seconds (%f per test)",

data/test/test_backend.rb

@@ -85,7 +85,7 @@ class BackendTest < MiniTest::Test
     i, o = IO.pipe
 
     buf = []
-    spin do
+    f = spin do
       buf << :ready
       @backend.read_loop(i) { |d| buf << d }
       buf << :done
@@ -96,9 +96,7 @@ class BackendTest < MiniTest::Test
     o << 'bar'
     o.close
 
-    # read_loop will snooze after every read
-    6.times { snooze }
-
+    f.await
     assert_equal [:ready, 'foo', 'bar', :done], buf
   end
 
@@ -111,12 +109,12 @@ class BackendTest < MiniTest::Test
     end
 
     c1 = TCPSocket.new('127.0.0.1', 1234)
-    10.times { snooze }
+    sleep 0.01
 
     assert_equal 1, clients.size
 
     c2 = TCPSocket.new('127.0.0.1', 1234)
-    10.times { snooze }
+    sleep 0.01
 
     assert_equal 2, clients.size
 
@@ -127,4 +125,63 @@ class BackendTest < MiniTest::Test
     snooze
     server&.close
   end
+
+  def test_timer_loop
+    i = 0
+    f = spin do
+      @backend.timer_loop(0.01) { i += 1 }
+    end
+    @backend.sleep(0.05)
+    f.stop
+    f.await # TODO: check why this test sometimes segfaults if we don't a<wait fiber
+    assert_in_range 4..6, i
+  end
+
+  class MyTimeoutException < Exception
+  end
+
+  def test_timeout
+    buffer = []
+    assert_raises(Polyphony::TimeoutException) do
+      @backend.timeout(0.01, Polyphony::TimeoutException) do
+        buffer << 1
+        sleep 0.02
+        buffer << 2
+      end
+    end
+    assert_equal [1], buffer
+
+    buffer = []
+    assert_raises(MyTimeoutException) do
+      @backend.timeout(0.01, MyTimeoutException) do
+        buffer << 1
+        sleep 1
+        buffer << 2
+      end
+    end
+    assert_equal [1], buffer
+
+    buffer = []
+    result = @backend.timeout(0.01, nil, 42) do
+      buffer << 1
+      sleep 1
+      buffer << 2
+    end
+    assert_equal 42, result
+    assert_equal [1], buffer
+  end
+
+  def test_nested_timeout
+    buffer = []
+    assert_raises(MyTimeoutException) do
+      @backend.timeout(0.01, MyTimeoutException) do
+        @backend.timeout(0.02, nil) do
+          buffer << 1
+          sleep 1
+          buffer << 2
+        end
+      end
+    end
+    assert_equal [1], buffer
+  end
 end