polyphony 0.67 → 0.71

data/lib/polyphony/extensions/fiber.rb

@@ -27,6 +27,7 @@ module Polyphony
       end
 
       fiber = parent.spin(@tag, @caller, &@block)
+      @monitors&.each_key { |f| fiber.monitor(f) }
       fiber.schedule(value) unless value.nil?
       fiber
     end
@@ -79,46 +80,34 @@ module Polyphony
 
   # Fiber supervision
   module FiberSupervision
-    def supervise(opts = {})
-      @counter = 0
-      @on_child_done = proc do |fiber, result|
-        self << fiber unless result.is_a?(Exception)
+    def supervise(*fibers, **opts, &block)
+      block ||= supervise_opts_to_block(opts)
+
+      fibers.each do |f|
+        f.attach_to(self) unless f.parent == self
+        f.monitor(self)
       end
+
+      mailbox = monitor_mailbox
+
       while true
-        supervise_perform(opts)
+        (fiber, result) = mailbox.shift
+        block&.call(fiber, result)
       end
-  rescue Polyphony::MoveOn
-      # generated in #supervise_perform to stop supervisor
-    ensure
-      @on_child_done = nil
     end
 
-    def supervise_perform(opts)
-      fiber = receive
-      if fiber && opts[:restart]
-        restart_fiber(fiber, opts)
-      elsif Fiber.current.children.empty?
-        Fiber.current.stop
-      end
-    rescue Polyphony::Restart
-      restart_all_children
-    rescue Exception => e
-      Kernel.raise e if e.source_fiber.nil? || e.source_fiber == self
+    def supervise_opts_to_block(opts)
+      block = opts[:on_done] || opts[:on_error]
+      return nil unless block || opts[:restart]
 
-      if opts[:restart]
-        restart_fiber(e.source_fiber, opts)
-      elsif Fiber.current.children.empty?
-        Fiber.current.stop
-      end
-    end
+      error_only = !!opts[:on_error]
+      restart_always = opts[:restart] == :always
+      restart_on_error = opts[:restart] == :on_error
 
-    def restart_fiber(fiber, opts)
-      opts[:watcher]&.send [:restart, fiber]
-      case opts[:restart]
-      when true
-        fiber.restart
-      when :one_for_all
-        @children.keys.each(&:restart)
+      ->(f, r) do
+        is_error = r.is_a?(Exception)
+        block.(f, r) if block && (!error_only || is_error)
+        f.restart if restart_always || (restart_on_error && is_error)
       end
     end
   end
@@ -246,13 +235,6 @@ module Polyphony
         c.terminate(graceful)
         c.await
       end
-      reap_dead_children
-    end
-
-    def reap_dead_children
-      return unless @children
-
-      @children.reject! { |f| f.dead? }
     end
 
     def detach
@@ -261,10 +243,17 @@ module Polyphony
       @parent.add_child(self)
     end
 
-    def attach(parent)
+    def attach_to(fiber)
       @parent.remove_child(self)
-      @parent = parent
-      @parent.add_child(self)
+      @parent = fiber
+      fiber.add_child(self)
+    end
+
+    def attach_and_monitor(fiber)
+      @parent.remove_child(self)
+      @parent = fiber
+      fiber.add_child(self)
+      monitor(fiber)
     end
   end
 
@@ -329,6 +318,7 @@ module Polyphony
       inform_monitors(result, uncaught_exception)
       @running = false
     ensure
+      @parent&.remove_child(self)
       # Prevent fiber from being resumed after terminating
       @thread.fiber_unschedule(self)
       Thread.current.switch_fiber

data/lib/polyphony/extensions/io.rb

@@ -76,7 +76,7 @@ end
 
 # IO instance method patches
 class ::IO
-  def __polyphony_read_method__
+  def __parser_read_method__
     :backend_read
   end
 
@@ -160,8 +160,6 @@ class ::IO
       return @read_buffer.slice!(0, idx + sep_size) if idx
 
       result = readpartial(8192, @read_buffer, -1)
-        
-      #Polyphony.backend_read(self, @read_buffer, 8192, false, -1)
       return nil unless result
     end
   rescue EOFError

data/lib/polyphony/extensions/openssl.rb

@@ -5,7 +5,7 @@ require_relative './socket'
 
 # OpenSSL socket helper methods (to make it compatible with Socket API) and overrides
 class ::OpenSSL::SSL::SSLSocket
-  def __polyphony_read_method__
+  def __parser_read_method__
     :readpartial
   end
 
@@ -114,6 +114,68 @@ end
 
 # OpenSSL socket helper methods (to make it compatible with Socket API) and overrides
 class ::OpenSSL::SSL::SSLServer
+  attr_reader :ctx
+
+  alias_method :orig_accept, :accept
+  def accept
+    # when @ctx.servername_cb is set, we use a worker thread to run the
+    # ssl.accept call. We need to do this because:
+    # - We cannot switch fibers inside of the servername_cb proc (see
+    #   https://github.com/ruby/openssl/issues/415)
+    # - We don't want to stop the world while we're busy provisioning an ACME
+    #   certificate
+    if @use_accept_worker.nil?
+      if (@use_accept_worker = use_accept_worker_thread?)
+        start_accept_worker_thread
+      end
+    end
+
+    sock, = @svr.accept
+    begin
+      ssl = OpenSSL::SSL::SSLSocket.new(sock, @ctx)
+      ssl.sync_close = true
+      if @use_accept_worker
+        @accept_worker_fiber << [ssl, Fiber.current]
+        receive
+      else
+        ssl.accept
+      end
+      ssl
+    rescue Exception => ex
+      if ssl
+        ssl.close
+      else
+        sock.close
+      end
+      raise ex
+    end
+  end
+
+  def start_accept_worker_thread
+    fiber = Fiber.current
+    @accept_worker_thread = Thread.new do
+      fiber << Fiber.current
+      loop do
+        socket, peer = receive
+        socket.accept
+        peer << socket
+      rescue => e
+        peer.schedule(e) if fiber
+      end
+    end
+    @accept_worker_fiber = receive
+  end
+
+  def use_accept_worker_thread?
+    !!@ctx.servername_cb
+  end
+
+  alias_method :orig_close, :close
+  def close
+    @accept_worker_thread&.kill
+    orig_close
+  end
+
   def accept_loop(ignore_errors = true)
     loop do
       yield accept

data/lib/polyphony/extensions/socket.rb

@@ -6,7 +6,7 @@ require_relative './io'
 require_relative '../core/thread_pool'
 
 class BasicSocket
-  def __polyphony_read_method__
+  def __parser_read_method__
     :backend_recv
   end
 end
@@ -206,7 +206,7 @@ class ::TCPSocket
   #   Polyphony.backend_send(self, mesg, 0)
   # end
 
-  def readpartial(maxlen, str = +'', buffer_pos = 0, raise_on_eof)
+  def readpartial(maxlen, str = +'', buffer_pos = 0, raise_on_eof = true)
     result = Polyphony.backend_recv(self, str, maxlen, buffer_pos)
     raise EOFError if !result && raise_on_eof
     result
@@ -299,7 +299,7 @@ class ::UNIXSocket
     Polyphony.backend_send(self, mesg, 0)
   end
 
-  def readpartial(maxlen, str = +'', buffer_pos = 0, raise_on_eof)
+  def readpartial(maxlen, str = +'', buffer_pos = 0, raise_on_eof = true)
     result = Polyphony.backend_recv(self, str, maxlen, buffer_pos)
     raise EOFError if !result && raise_on_eof
     result

data/lib/polyphony/version.rb

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

data/test/helper.rb

@@ -47,7 +47,6 @@ class MiniTest::Test
   def setup
     # trace "* setup #{self.name}"
     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.001

data/test/stress.rb

@@ -3,7 +3,7 @@
 count = ARGV[0] ? ARGV[0].to_i : 100
 test_name = ARGV[1]
 
-$test_cmd = +'ruby test/run.rb'
+$test_cmd = +'ruby test/run.rb  --name test_receive_cross_thread_exception'
 if test_name
   $test_cmd << " --name #{test_name}"
 end

data/test/test_fiber.rb

@@ -67,8 +67,6 @@ class FiberTest < MiniTest::Test
     }
     Fiber.await(f2, f3)
     assert_equal [:foo, :bar, :baz], buffer
-    assert_equal [f1], Fiber.current.children
-    Fiber.current.reap_dead_children
     assert_equal [], Fiber.current.children
   end
 
@@ -93,8 +91,6 @@ class FiberTest < MiniTest::Test
     f1.stop
 
     snooze
-    assert_equal [f1, f2, f3], Fiber.current.children
-    Fiber.current.reap_dead_children
     assert_equal [], Fiber.current.children
   end
 
@@ -602,7 +598,6 @@ class FiberTest < MiniTest::Test
 
     f.stop
     snooze
-    Fiber.current.reap_dead_children
     assert_equal [], Fiber.current.children
   end
 
@@ -791,7 +786,7 @@ class FiberTest < MiniTest::Test
     ], buf
   end
 
-  def test_attach
+  def test_attach_to
     buf = []
     child = nil
     parent = spin(:parent) do
@@ -809,7 +804,7 @@ class FiberTest < MiniTest::Test
 
     snooze
     assert_equal parent, child.parent
-    child.attach(new_parent)
+    child.attach_to(new_parent)
     assert_equal new_parent, child.parent
     parent.await
     
@@ -954,6 +949,27 @@ class MailboxTest < MiniTest::Test
     assert_equal ['foo'] * 100, messages
   end
 
+  def test_receive_exception
+    e = RuntimeError.new 'foo'
+    spin { Fiber.current.parent << e }
+    r = receive
+    assert_equal e, r
+
+    spin { Fiber.current.parent.schedule e }
+    assert_raises(RuntimeError) { receive }
+  end
+
+  def test_receive_cross_thread_exception
+    e = RuntimeError.new 'foo'
+    f = Fiber.current
+    Thread.new { f << e }
+    r = receive
+    assert_equal e, r
+
+    Thread.new { f.schedule e }
+    assert_raises(RuntimeError) { receive }
+  end
+
   def test_receive_all_pending
     assert_equal [], receive_all_pending
 

data/test/test_global_api.rb

@@ -375,7 +375,6 @@ class SpinScopeTest < MiniTest::Test
       buffer << e.message
     end
     10.times { snooze }
-    Fiber.current.reap_dead_children
     assert_equal 0, Fiber.current.children.size
     assert_equal ['foobar'], buffer
   end

data/test/test_process_supervision.rb

@@ -6,7 +6,7 @@ class ProcessSupervisionTest < MiniTest::Test
   def test_process_supervisor_with_block
     i, o = IO.pipe
 
-    f = spin do
+    watcher = spin do
       Polyphony.watch_process do
         i.close
         sleep 5
@@ -14,31 +14,60 @@ class ProcessSupervisionTest < MiniTest::Test
         o << 'foo'
         o.close
       end
-      supervise(on_error: :restart)
     end
 
+    supervisor = spin { supervise(watcher, restart: :always) }
+
     sleep 0.05
-    f.terminate
-    f.await
+    supervisor.terminate
+    supervisor.await
 
     o.close
     msg = i.read
-    i.close
     assert_equal 'foo', msg
   end
 
+  def test_process_supervisor_restart_with_block
+    i1, o1 = IO.pipe
+    i2, o2 = IO.pipe
+
+    count = 0
+    watcher = spin do
+      count += 1
+      Polyphony.watch_process do
+        i1.gets
+        o2.puts count
+      end
+    end
+
+    supervisor = spin { supervise(watcher, restart: :always) }
+
+    o1.puts
+    l = i2.gets
+    assert_equal "1\n", l
+
+    o1.puts
+    l = i2.gets
+    assert_equal "2\n", l
+
+    o1.puts
+    l = i2.gets
+    assert_equal "3\n", l
+  end
+
   def test_process_supervisor_with_cmd
     fn = '/tmp/test_process_supervisor_with_cmd'
     FileUtils.rm(fn) rescue nil
 
-    f = spin do
+    watcher = spin do
       Polyphony.watch_process("echo foo >> #{fn}")
-      supervise(on_error: :restart)
     end
 
+    supervisor = spin { supervise(watcher) }
+
     sleep 0.05
-    f.terminate
-    f.await
+    supervisor.terminate
+    supervisor.await
 
     assert_equal "foo\n", IO.read(fn)
 

data/test/test_supervise.rb

@@ -2,103 +2,186 @@
 
 require_relative 'helper'
 
-# class SuperviseTest < MiniTest::Test
-#   def test_supervise
-#     p = spin { supervise }
-#     snooze
-#     f1 = p.spin { receive }
-#     f2 = p.spin { receive }
-
-#     snooze
-#     assert_equal p.state, :waiting
-#     f1 << 'foo'
-#     f1.await
-#     snooze
-
-#     assert_equal :waiting, p.state
-#     assert_equal :waiting, f2.state
-
-#     f2 << 'bar'
-#     f2.await
-#     assert_equal :runnable, p.state
-    
-#     3.times { snooze }
-#     assert_equal :dead, p.state
-#   end
-
-#   def test_supervise_with_restart
-#     watcher = spin { receive }
-#     parent = spin { supervise(restart: true, watcher: watcher) }
-#     snooze
-
-#     buffer = []
-#     f1 = parent.spin do
-#       buffer << 'f1'
-#     end
-
-#     f1.await
-#     assert_equal ['f1'], buffer
-#     watcher.await
-#     assert_equal ['f1', 'f1'], buffer
-#   end
-
-#   def test_supervise_with_restart_on_error
-#     parent = spin { supervise(restart: true) }
-#     snooze
-
-#     buffer = []
-#     f1 = parent.spin do
-#       buffer << 'f1'
-#       buffer << receive
-#     end
-
-#     snooze
-#     assert_equal ['f1'], buffer
-
-#     f1.raise 'foo'
-
-#     3.times { snooze }
-
-#     assert_equal ['f1', 'f1'], buffer
-#     assert_equal :dead, f1.state
-
-#     # f1 should have been restarted by supervisor
-#     f1 = parent.children.first
-#     assert_kind_of Fiber, f1
-
-#     f1 << 'foo'
-#     f1.await
-
-#     assert_equal ['f1', 'f1', 'foo'], buffer
-#   end
-
-#   def test_supervisor_termination
-#     f = nil
-#     p = spin do
-#       f = spin { sleep 1 }
-#       supervise
-#     end
-#     sleep 0.01
-
-#     p.terminate
-#     p.await
-
-#     assert :dead, f.state
-#     assert :dead, p.state
-#   end
-
-#   def test_supervisor_termination_with_restart
-#     f = nil
-#     p = spin do
-#       f = spin { sleep 1 }
-#       supervise(restart: true)
-#     end
-#     sleep 0.01
-
-#     p.terminate
-#     p.await
-
-#     assert :dead, f.state
-#     assert :dead, p.state
-#   end
-# end
+class SuperviseTest < MiniTest::Test
+  def test_supervise_with_block
+    buffer = []
+    f1 = spin(:f1) { receive }
+    f2 = spin(:f2) { receive }
+    supervisor = spin(:supervisor) { supervise(f1, f2) { |*args| buffer << args } }
+
+    snooze
+    f1 << 'foo'
+    f1.await
+    10.times { snooze }
+    assert_equal [[f1, 'foo']], buffer
+
+    f2 << 'bar'
+    f2.await
+    assert_equal [[f1, 'foo'], [f2, 'bar']], buffer
+  end
+
+  def test_supervise_with_on_done
+    buffer = []
+    f1 = spin(:f1) { receive }
+    f2 = spin(:f2) { receive }
+    supervisor = spin(:supervisor) do
+      supervise(f1, f2, on_done: ->(*args) { buffer << args })
+    end
+
+    snooze
+    f1 << 'foo'
+    f1.await
+    10.times { snooze }
+    assert_equal [[f1, 'foo']], buffer
+
+    f2 << 'bar'
+    f2.await
+    assert_equal [[f1, 'foo'], [f2, 'bar']], buffer
+  end
+
+  def test_supervise_with_on_error
+    buffer = []
+    f1 = spin(:f1) { receive }
+    f2 = spin(:f2) { receive }
+    supervisor = spin(:supervisor) do
+      supervise(f1, f2, on_error: ->(*args) { buffer << args })
+    end
+
+    snooze
+    f1 << 'foo'
+    f1.await
+    10.times { snooze }
+    assert_equal [], buffer
+
+    e = RuntimeError.new('blah')
+    f2.raise(e)
+    3.times { snooze }
+    assert_equal [[f2, e]], buffer
+  end
+
+  def test_supervise_with_manual_restart
+    buffer = []
+    f1 = spin(:f1) { receive }
+    supervisor = spin(:supervisor) do
+      supervise(f1) do |f, r|
+        buffer << [f, r]
+        f.restart
+      end
+    end
+
+    snooze
+    f1 << 'foo'
+    f1.await
+    snooze
+    assert_equal [[f1, 'foo']], buffer
+
+    10.times { snooze }
+
+    assert_equal 1, supervisor.children.size
+    f2 = supervisor.children.first
+    assert f1 != f2
+    assert_equal :f1, f2.tag
+    assert_equal supervisor, f2.parent
+
+    e = RuntimeError.new('bar')
+    f2.raise(e)
+    f2.await rescue nil
+    3.times { snooze }
+    assert_equal [[f1, 'foo'], [f2, e]], buffer
+
+    assert_equal 1, supervisor.children.size
+    f3 = supervisor.children.first
+    assert f2 != f3
+    assert f1 != f3
+    assert_equal :f1, f3.tag
+    assert_equal supervisor, f3.parent
+  end
+
+  def test_supervise_with_restart_always
+    buffer = []
+    f1 = spin(:f1) do
+      buffer << receive
+    rescue => e
+      buffer << e
+      e
+    end
+    supervisor = spin(:supervisor) { supervise(f1, restart: :always) }
+
+    snooze
+    f1 << 'foo'
+    f1.await
+    snooze
+    assert_equal ['foo'], buffer
+
+    10.times { snooze }
+
+    assert_equal 1, supervisor.children.size
+    f2 = supervisor.children.first
+    assert f1 != f2
+    assert_equal :f1, f2.tag
+    assert_equal supervisor, f2.parent
+
+    e = RuntimeError.new('bar')
+    f2.raise(e)
+    f2.await rescue nil
+    3.times { snooze }
+    assert_equal ['foo', e], buffer
+
+    assert_equal 1, supervisor.children.size
+    f3 = supervisor.children.first
+    assert f2 != f3
+    assert f1 != f3
+    assert_equal :f1, f3.tag
+    assert_equal supervisor, f3.parent
+  end
+
+  def test_supervise_with_restart_on_error
+    buffer = []
+    f1 = spin(:f1) do
+      buffer << receive
+    rescue => e
+      buffer << e
+      e
+    end
+    supervisor = spin(:supervisor) { supervise(f1, restart: :on_error) }
+
+    snooze
+    e = RuntimeError.new('bar')
+    f1.raise(e)
+    f1.await rescue nil
+    snooze
+    assert_equal [e], buffer
+
+    10.times { snooze }
+
+    assert_equal 1, supervisor.children.size
+    f2 = supervisor.children.first
+    assert f1 != f2
+    assert_equal :f1, f2.tag
+    assert_equal supervisor, f2.parent
+
+    f2 << 'foo'
+    f2.await rescue nil
+    3.times { snooze }
+    assert_equal [e, 'foo'], buffer
+
+    assert_equal 0, supervisor.children.size
+  end
+
+  def test_supervise_terminate
+    buffer = []
+    f1 = spin(:f1) do
+      buffer << receive
+    rescue => e
+      buffer << e
+      e
+    end
+    supervisor = spin(:supervisor) { supervise(f1, restart: :on_error) }
+
+    sleep 0.05
+    supervisor.terminate
+    supervisor.await
+
+    assert_equal [], buffer
+  end
+end