polyphony 0.45.5 → 0.47.2

data/lib/polyphony/extensions/core.rb

@@ -12,7 +12,7 @@ class ::Exception
     attr_accessor :__disable_sanitized_backtrace__
   end
 
-  attr_accessor :source_fiber
+  attr_accessor :source_fiber, :__raising_fiber__
 
   alias_method :orig_initialize, :initialize
   def initialize(*args)
@@ -22,8 +22,8 @@ class ::Exception
 
   alias_method :orig_backtrace, :backtrace
   def backtrace
-    unless @first_backtrace_call
-      @first_backtrace_call = true
+    unless @backtrace_called
+      @backtrace_called = true
       return orig_backtrace
     end
 
@@ -31,12 +31,10 @@ class ::Exception
   end
 
   def sanitized_backtrace
-    if @__raising_fiber__
-      backtrace = orig_backtrace || []
-      sanitize(backtrace + @__raising_fiber__.caller)
-    else
-      sanitize(orig_backtrace)
-    end
+    return sanitize(orig_backtrace) unless @__raising_fiber__
+
+    backtrace = orig_backtrace || []
+    sanitize(backtrace + @__raising_fiber__.caller)
   end
 
   POLYPHONY_DIR = File.expand_path(File.join(__dir__, '..'))
@@ -164,11 +162,7 @@ end
 
 # Override Timeout to use cancel scope
 module ::Timeout
-  def self.timeout(sec, klass = nil, message = nil, &block)
-    cancel_after(sec, &block)
-  rescue Polyphony::Cancel => e
-    error = klass ? klass.new(message) : ::Timeout::Error.new
-    error.set_backtrace(e.backtrace)
-    raise error
+  def self.timeout(sec, klass = Timeout::Error, message = 'execution expired', &block)
+    cancel_after(sec, with_exception: [klass, message], &block)
   end
 end

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

@@ -175,9 +175,9 @@ module Polyphony
       f = Fiber.new do
         block.call
       rescue Exception => e
-        Thread.current.break_out_of_ev_loop(Thread.main.main_fiber, e)
+        Thread.current.schedule_and_wakeup(Thread.main.main_fiber, e)
       end
-      Thread.current.break_out_of_ev_loop(f, nil)
+      Thread.current.schedule_and_wakeup(f, nil)
     end
   end
 
@@ -328,14 +328,18 @@ class ::Fiber
   extend Polyphony::FiberControlClassMethods
 
   attr_accessor :tag, :thread, :parent
-  attr_reader :result, :mailbox
+  attr_reader :result
 
   def running?
     @running
   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/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,18 +19,24 @@ 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
+  alias_method :read_loop, :recv_loop
+
   def recvfrom(maxlen, flags = 0)
     @read_buffer ||= +''
     loop do
@@ -44,6 +50,23 @@ class ::Socket
     end
   end
 
+  def send(mesg, flags = 0)
+    Thread.current.backend.send(self, mesg)
+  end
+
+  def write(str, *args)
+    if args.empty?
+      Thread.current.backend.send(self, str)
+    else
+      Thread.current.backend.send(self, str + args.join)
+    end
+  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 +143,42 @@ 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
+  alias_method :read_loop, :recv_loop
+
+  def send(mesg, flags = 0)
+    Thread.current.backend.send(self, mesg)
+  end
+
+  def write(str, *args)
+    if args.empty?
+      Thread.current.backend.send(self, str)
+    else
+      Thread.current.backend.send(self, str + args.join)
+    end
+  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 +201,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.5'
+  VERSION = '0.47.2'
 end

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