polyphony 0.46.1 → 0.47.4

data/lib/polyphony/core/global_api.rb

@@ -16,16 +16,29 @@ module Polyphony
     end
 
     def cancel_after(interval, with_exception: Polyphony::Cancel, &block)
-      fiber = ::Fiber.current
-      canceller = spin do
+      if !block
+        cancel_after_blockless_canceller(Fiber.current, interval, with_exception)
+      elsif block.arity > 0
+        cancel_after_with_block(Fiber.current, interval, with_exception, &block)
+      else
+        Thread.current.backend.timeout(interval, with_exception, &block)
+      end
+    end
+
+    def cancel_after_blockless_canceller(fiber, interval, with_exception)
+      spin do
         sleep interval
         exception = cancel_exception(with_exception)
-        # we don't want the cancelling fiber caller location as part of the
-        # exception backtrace
         exception.__raising_fiber__ = nil
         fiber.schedule exception
       end
-      block ? cancel_after_wrap_block(canceller, &block) : canceller
+    end
+
+    def cancel_after_with_block(fiber, interval, with_exception, &block)
+      canceller = cancel_after_blockless_canceller(fiber, interval, with_exception)
+      block.call(canceller)
+    ensure
+      canceller.stop
     end
 
     def cancel_exception(exception)
@@ -36,49 +49,49 @@ module Polyphony
       end
     end
 
-    def cancel_after_wrap_block(canceller, &block)
-      block.call(canceller)
-    ensure
-      canceller.stop
-    end
-
     def spin(tag = nil, &block)
       Fiber.current.spin(tag, caller, &block)
     end
 
-    def spin_loop(tag = nil, rate: nil, &block)
-      if rate
+    def spin_loop(tag = nil, rate: nil, interval: nil, &block)
+      if rate || interval
         Fiber.current.spin(tag, caller) do
-          throttled_loop(rate, &block)
+          throttled_loop(rate: rate, interval: interval, &block)
         end
       else
         Fiber.current.spin(tag, caller) { loop(&block) }
       end
     end
 
-    def every(interval)
-      next_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + interval
-      loop do
-        now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-        Thread.current.backend.sleep(next_time - now)
-        yield
-        loop do
-          next_time += interval
-          break if next_time > now
-        end
-      end
+    def spin_scope
+      raise unless block_given?
+    
+      spin do
+        result = yield
+        Fiber.current.await_all_children
+        result
+      end.await
+    end
+
+    def every(interval, &block)
+      Thread.current.backend.timer_loop(interval, &block)
     end
 
     def move_on_after(interval, with_value: nil, &block)
-      fiber = ::Fiber.current
-      unless block
-        return spin do
-          sleep interval
-          fiber.schedule with_value
-        end
+      if !block
+        move_on_blockless_canceller(Fiber.current, interval, with_value)
+      elsif block.arity > 0
+        move_on_after_with_block(Fiber.current, interval, with_value, &block)
+      else
+        Thread.current.backend.timeout(interval, nil, with_value, &block)
       end
+    end
 
-      move_on_after_with_block(fiber, interval, with_value, &block)
+    def move_on_blockless_canceller(fiber, interval, with_value)
+      spin do
+        sleep interval
+        fiber.schedule with_value
+      end
     end
 
     def move_on_after_with_block(fiber, interval, with_value, &block)

data/lib/polyphony/extensions/fiber.rb

@@ -173,6 +173,7 @@ module Polyphony
     # signals (see also the patched `Kernel#trap`)
     def schedule_priority_oob_fiber(&block)
       f = Fiber.new do
+        Fiber.current.setup_raw
         block.call
       rescue Exception => e
         Thread.current.schedule_and_wakeup(Thread.main.main_fiber, e)
@@ -262,6 +263,7 @@ module Polyphony
     # allows the fiber to be scheduled and to receive messages.
     def setup_raw
       @thread = Thread.current
+      @running = true
     end
 
     def setup_main_fiber
@@ -328,14 +330,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/socket.rb

@@ -19,22 +19,13 @@ class ::Socket
   end
 
   def recv(maxlen, flags = 0, outbuf = nil)
-    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
+    Thread.current.backend.recv(self, outbuf || +'', maxlen)
   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 ||= +''
@@ -53,8 +44,12 @@ class ::Socket
     Thread.current.backend.send(self, mesg)
   end
 
-  def write(str)
-    Thread.current.backend.send(self, str)
+  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
 
@@ -145,13 +140,18 @@ class ::TCPSocket
   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)
-    Thread.current.backend.send(self, str)
+  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
 
@@ -200,3 +200,62 @@ class ::TCPServer
     @io.close
   end
 end
+
+class ::UNIXServer
+  alias_method :orig_accept, :accept
+ def accept
+    Thread.current.backend.accept(self)
+  end
+
+  def accept_loop(&block)
+    Thread.current.backend.accept_loop(self, &block)
+  end
+
+
+end
+
+class ::UNIXSocket
+  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
+
+  def write_nonblock(buf, exception: true)
+    @io.write_nonblock(buf, exception: exception)
+  end
+end

data/lib/polyphony/version.rb

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

data/test/test_backend.rb

@@ -136,4 +136,52 @@ class BackendTest < MiniTest::Test
     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

data/test/test_fiber.rb

@@ -565,14 +565,14 @@ class FiberTest < MiniTest::Test
   end
 
   def test_inspect
-    expected = format('#<Fiber:%s (root) (running)>', Fiber.current.object_id)
+    expected = format('#<Fiber main:%s (root) (running)>', Fiber.current.object_id)
     assert_equal expected, Fiber.current.inspect
 
     spin_line_no = __LINE__ + 1
-    f = spin { :foo }
+    f = spin(:baz) { :foo }
 
     expected = format(
-      '#<Fiber:%s %s:%d:in `test_inspect\' (runnable)>',
+      '#<Fiber baz:%s %s:%d:in `test_inspect\' (runnable)>',
       f.object_id,
       __FILE__,
       spin_line_no
@@ -581,7 +581,7 @@ class FiberTest < MiniTest::Test
 
     f.await
     expected = format(
-      '#<Fiber:%s %s:%d:in `test_inspect\' (dead)>',
+      '#<Fiber baz:%s %s:%d:in `test_inspect\' (dead)>',
       f.object_id,
       __FILE__,
       spin_line_no
@@ -738,6 +738,35 @@ class MailboxTest < MiniTest::Test
     f&.stop
   end
 
+  def test_capped_fiber_mailbox
+    buffer = []
+    a = spin_loop do
+      3.times { snooze }
+      buffer << [:receive, receive]
+    end
+    a.mailbox.cap(1)
+
+    b = spin do
+      (1..3).each do |i|
+        a << i
+        buffer << [:send, i]
+      end
+    end
+
+    (1..10).each do |i|
+      snooze
+      buffer << [:snooze, i]
+    end
+
+    b.join
+
+    assert_equal [
+      [:snooze, 1], [:send, 1], [:snooze, 2], [:snooze, 3], [:snooze, 4],
+      [:receive, 1], [:snooze, 5], [:send, 2], [:snooze, 6], [:snooze, 7],
+      [:snooze, 8], [:receive, 2], [:snooze, 9], [:send, 3], [:snooze, 10]
+    ], buffer
+  end
+
   def test_that_multiple_messages_sent_at_once_arrive_in_order
     msgs = []
     f = spin { loop { msgs << receive } }

data/test/test_global_api.rb

@@ -150,6 +150,28 @@ class MoveOnAfterTest < MiniTest::Test
     assert t1 - t0 < 0.1
     assert_equal 'foo', v
   end
+
+  def test_nested_move_on_after
+    t0 = Time.now
+    o = move_on_after(0.01, with_value: 1) do
+      move_on_after(0.02, with_value: 2) do
+        sleep 1
+      end
+    end
+    t1 = Time.now
+    assert_equal 1, o
+    assert_in_range 0.008..0.013, t1 - t0
+
+    t0 = Time.now
+    o = move_on_after(0.02, with_value: 1) do
+      move_on_after(0.01, with_value: 2) do
+        sleep 1
+      end
+    end
+    t1 = Time.now
+    assert_equal 2, o
+    assert_in_range 0.008..0.013, t1 - t0
+  end
 end
 
 class CancelAfterTest < MiniTest::Test
@@ -188,7 +210,7 @@ class CancelAfterTest < MiniTest::Test
       sleep 0.007
     end
     t1 = Time.now
-    assert_in_range 0.014..0.02, t1 - t0
+    assert_in_range 0.014..0.024, t1 - t0
   end
 
   class CustomException < Exception
@@ -275,6 +297,55 @@ class SpinLoopTest < MiniTest::Test
     f.stop
     assert_in_range 1..3, counter
   end
+
+  def test_spin_loop_with_interval
+    buffer = []
+    counter = 0
+    t0 = Time.now
+    f = spin_loop(interval: 0.01) { buffer << (counter += 1) }
+    sleep 0.02
+    f.stop
+    assert_in_range 1..3, counter
+  end
+end
+
+class SpinScopeTest < MiniTest::Test
+  def test_spin_scope
+    queue = Queue.new
+    buffer = {}
+    spin do
+      queue << 1
+      snooze
+      queue << 2
+    end
+    f = nil
+    result = spin_scope do
+      f = Fiber.current
+      spin { buffer[:a] = queue.shift }
+      spin { buffer[:b] = queue.shift }
+      :foo
+    end
+    assert_equal :foo, result
+    assert_kind_of Fiber, f
+    assert_equal :dead, f.state
+    assert_equal ({a: 1, b: 2}), buffer
+  end
+
+  def test_spin_scope_with_exception
+    queue = Queue.new
+    buffer = []
+    spin do
+      spin_scope do
+        spin { buffer << queue.shift }
+        spin { raise 'foobar' }
+      end
+    rescue => e
+      buffer << e.message
+    end
+    6.times { snooze }
+    assert_equal 0, Fiber.current.children.size
+    assert_equal ['foobar'], buffer
+  end
 end
 
 class ThrottledLoopTest < MiniTest::Test