polyphony 0.46.0 → 0.47.3

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/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/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

@@ -35,6 +35,7 @@ class ::Socket
   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 +54,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 +150,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
 
@@ -191,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.46.0'
+  VERSION = '0.47.3'
 end

data/test/helper.rb

@@ -85,4 +85,4 @@ module Minitest::Assertions
   end
 end
 
-puts "Polyphony backend: #{Thread.current.backend.kind}"
+puts "Polyphony backend: #{Thread.current.backend.kind}"

data/test/stress.rb

@@ -2,7 +2,7 @@
 
 count = ARGV[0] ? ARGV[0].to_i : 100
 
-TEST_CMD = 'ruby test/test_backend.rb' #'ruby test/run.rb'
+TEST_CMD = 'ruby test/run.rb'
 
 def run_test(count)
   puts "#{count}: running tests..."

data/test/test_backend.rb

@@ -125,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

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
@@ -202,6 +224,19 @@ class CancelAfterTest < MiniTest::Test
       end
     end
 
+    begin
+      err = nil
+      cancel_after(0.01, with_exception: [CustomException, 'custom message']) do
+        sleep 1
+        :foo
+      end
+    rescue Exception => err
+    ensure
+      assert_kind_of CustomException, err
+      assert_equal 'custom message', err.message
+    end
+
+
     begin
       e = nil
       cancel_after(0.01, with_exception: 'foo') do
@@ -262,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

data/test/test_queue.rb

@@ -129,4 +129,121 @@ class QueueTest < MiniTest::Test
 
     assert_equal 0, @queue.size
   end
+end
+
+class CappedQueueTest < MiniTest::Test
+  def setup
+    super
+    @queue = Polyphony::Queue.new
+    @queue.cap(3)
+  end
+
+  def test_capped?
+    q = Polyphony::Queue.new
+    assert_nil q.capped?
+
+    q.cap(3)
+    assert_equal 3, q.capped?
+  end
+
+  def test_initalize_with_cap
+    q = Polyphony::Queue.new(42)
+    assert_equal 42, q.capped?
+  end
+
+  def test_capped_push
+    buffer = []
+    a = spin do
+      (1..5).each do |i|
+        @queue.push(i)
+        buffer << :"p#{i}"
+      end
+      @queue.push :stop
+    end
+
+    snooze
+
+    b = spin_loop do
+      i = @queue.shift
+      raise Polyphony::Terminate if i == :stop
+      buffer << :"s#{i}"
+    end
+
+    Fiber.join(a, b)
+    assert_equal [:p1, :p2, :s1, :p3, :s2, :p4, :s3, :p5, :s4, :s5], buffer
+  end
+
+  def test_capped_multi_push
+    buffer = []
+    a = spin(:a) do
+      (1..3).each do |i|
+        @queue.push(i)
+        buffer << :"p#{i}"
+      end
+    end
+
+    buffer = []
+    b = spin(:b) do
+      (4..6).each do |i|
+        @queue.push(i)
+        buffer << :"p#{i}"
+      end
+      @queue.push :stop
+    end
+
+    c = spin_loop do
+      i = @queue.shift
+      raise Polyphony::Terminate if i == :stop
+      buffer << :"s#{i}"
+      snooze
+    end
+
+    Fiber.join(a, b, c)
+    assert_equal [:p1, :p4, :s1, :p5, :p2, :s4, :p3, :s5, :p6, :s2, :s3, :s6], buffer
+  end
+
+  def test_capped_clear
+    buffer = []
+    a = spin(:a) do
+      (1..5).each do |i|
+        @queue.push(i)
+        buffer << i
+      end
+    end
+
+    snooze while buffer.size < 3
+    @queue.clear
+    buffer << :clear
+
+    a.join
+    assert_equal [1, 2, 3, :clear, 4, 5], buffer
+  end
+
+  def test_capped_delete
+    buffer = []
+    a = spin(:a) do
+      (1..5).each do |i|
+        @queue.push(i)
+        buffer << i
+      end
+    end
+
+    i = 0
+    spin_loop do
+      i += 1
+      snooze 
+    end
+
+    5.times { snooze }
+    assert_equal 5, i
+    @queue.delete 1
+    buffer << :"d#{i}"
+    3.times { snooze }
+    assert_equal 8, i
+    @queue.delete 2
+    buffer << :"d#{i}"
+
+    a.join
+    assert_equal [1, 2, 3, :d5, 4, :d8, 5], buffer
+  end
 end