polyphony 0.45.1 → 0.46.1

data/lib/polyphony.rb

@@ -76,10 +76,10 @@ module Polyphony
     end
 
     def install_terminating_signal_handlers
-      trap('SIGTERM', SystemExit)
+      trap('SIGTERM') { raise SystemExit }
       orig_trap('SIGINT') do
         orig_trap('SIGINT') { exit! }
-        Thread.current.break_out_of_ev_loop(Thread.main.main_fiber, Interrupt.new)
+        Fiber.schedule_priority_oob_fiber { raise Interrupt }
       end
     end
 

data/lib/polyphony/adapters/process.rb

@@ -24,9 +24,6 @@ module Polyphony
       def kill_and_await(sig, pid)
         ::Process.kill(sig, pid)
         Thread.current.backend.waitpid(pid)
-      rescue SystemCallError
-        # ignore
-        puts 'SystemCallError in kill_and_await'
       end
     end
   end

data/lib/polyphony/adapters/trace.rb

@@ -118,13 +118,13 @@ module Polyphony
 
         ALL_FIBER_EVENTS = %i[
           fiber_create fiber_terminate fiber_schedule fiber_switchpoint fiber_run
-          fiber_ev_loop_enter fiber_ev_loop_leave
+          fiber_event_poll_enter fiber_event_poll_leave
         ].freeze
 
         def event_masks(events)
           events.each_with_object([[], []]) do |e, masks|
             case e
-            when /fiber_/
+            when /^fiber_/
               masks[1] += e == :fiber_all ? ALL_FIBER_EVENTS : [e]
               masks[0] << :c_return unless masks[0].include?(:c_return)
             else

data/lib/polyphony/core/exceptions.rb

@@ -14,10 +14,6 @@ module Polyphony
       @caller_backtrace = caller
       @value = value
     end
-
-    def backtrace
-      sanitize(@caller_backtrace)
-    end
   end
 
   # MoveOn is used to interrupt a long-running blocking operation, while

data/lib/polyphony/core/global_api.rb

@@ -20,19 +20,24 @@ module Polyphony
       canceller = 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_exception(exception)
-      return exception.new if exception.is_a?(Class)
-
-      RuntimeError.new(exception)
+      case exception
+      when Class then exception.new
+      when Array then exception[0].new(exception[1])
+      else RuntimeError.new(exception)
+      end
     end
 
     def cancel_after_wrap_block(canceller, &block)
-      block.call
+      block.call(canceller)
     ensure
       canceller.stop
     end
@@ -81,7 +86,7 @@ module Polyphony
         sleep interval
         fiber.schedule Polyphony::MoveOn.new(with_value)
       end
-      block.call
+      block.call(canceller)
     rescue Polyphony::MoveOn => e
       e.value
     ensure
@@ -92,8 +97,8 @@ module Polyphony
       Fiber.current.receive
     end
 
-    def receive_pending
-      Fiber.current.receive_pending
+    def receive_all_pending
+      Fiber.current.receive_all_pending
     end
 
     def supervise(*args, &block)
@@ -107,10 +112,7 @@ module Polyphony
     end
 
     def sleep_forever
-      Thread.current.backend.ref
-      loop { sleep 60 }
-    ensure
-      Thread.current.backend.unref
+      Thread.current.backend.wait_event(true)
     end
 
     def throttled_loop(rate = nil, **opts, &block)

data/lib/polyphony/core/sync.rb

@@ -16,11 +16,13 @@ module Polyphony
 
     def synchronize_not_holding
       @token = @store.shift
-      @holding_fiber = Fiber.current
-      yield
-    ensure
-      @holding_fiber = nil
-      @store << @token if @token
+      begin
+        @holding_fiber = Fiber.current
+        yield
+      ensure
+        @holding_fiber = nil
+        @store << @token if @token
+      end
     end
 
     def conditional_release

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__, '..'))
@@ -149,39 +147,22 @@ module ::Kernel
     return orig_trap(sig, command) if command.is_a? String
 
     block = command if !block && command.respond_to?(:call)
-    exception = signal_exception(block, command)
 
     # The signal trap can be invoked at any time, including while the system
     # backend is blocking while polling for events. In order to deal with this
-    # correctly, we spin a fiber that will run the signal handler code, then
-    # call break_out_of_ev_loop, which will put the fiber at the front of the
-    # run queue, then wake up the backend.
-    #
-    # If the command argument is an exception class however, it will be raised
-    # directly in the context of the main fiber.
+    # correctly, we run the signal handler code in an out-of-band, priority
+    # scheduled fiber, that will pass any uncaught exception (including
+    # SystemExit and Interrupt) to the main thread's main fiber. See also
+    # `Fiber#schedule_priority_oob_fiber`.
     orig_trap(sig) do
-      Thread.current.break_out_of_ev_loop(Thread.main.main_fiber, exception)
+      Fiber.schedule_priority_oob_fiber(&block)
     end
   end
 end
 
-def signal_exception(block, command)
-  if block
-    Polyphony::Interjection.new(block)
-  elsif command.is_a?(Class)
-    command.new
-  else
-    raise ArgumentError, 'Must supply block or exception or callable object'
-  end
-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

@@ -7,20 +7,6 @@ require_relative '../core/exceptions'
 module Polyphony
   # Fiber control API
   module FiberControl
-    def await
-      if @running == false
-        return @result.is_a?(Exception) ? (Kernel.raise @result) : @result
-      end
-
-      fiber = Fiber.current
-      @waiting_fibers ||= {}
-      @waiting_fibers[fiber] = true
-      suspend
-    ensure
-      @waiting_fibers&.delete(fiber)
-    end
-    alias_method :join, :await
-
     def interrupt(value = nil)
       return if @running == false
 
@@ -117,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
 
@@ -179,21 +165,19 @@ module Polyphony
         state[:selected] = true
       end
     end
-  end
 
-  # Messaging functionality
-  module FiberMessaging
-    def <<(value)
-      @mailbox << value
-    end
-    alias_method :send, :<<
-
-    def receive
-      @mailbox.shift
-    end
-
-    def receive_pending
-      @mailbox.shift_all
+    # 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
 
@@ -225,14 +209,14 @@ module Polyphony
     def await_all_children
       return unless @children && !@children.empty?
 
-      @results = @children.dup
+      results = @children.dup
       @on_child_done = proc do |c, r|
-        @results[c] = r
+        results[c] = r
         schedule if @children.empty?
       end
       suspend
       @on_child_done = nil
-      @results.values
+      results.values
     end
 
     def shutdown_all_children
@@ -249,7 +233,6 @@ module Polyphony
       @parent = parent
       @caller = caller
       @block = block
-      @mailbox = Polyphony::Queue.new
       __fiber_trace__(:fiber_create, self)
       schedule
     end
@@ -279,7 +262,6 @@ module Polyphony
     # allows the fiber to be scheduled and to receive messages.
     def setup_raw
       @thread = Thread.current
-      @mailbox = Polyphony::Queue.new
     end
 
     def setup_main_fiber
@@ -288,11 +270,10 @@ module Polyphony
       @thread = Thread.current
       @running = true
       @children&.clear
-      @mailbox = Polyphony::Queue.new
     end
 
     def restart_self(first_value)
-      @mailbox = Polyphony::Queue.new
+      @mailbox = nil
       @when_done_procs = nil
       @waiting_fibers = nil
       run(first_value)
@@ -324,13 +305,10 @@ module Polyphony
     def inform_dependants(result, uncaught_exception)
       @parent&.child_done(self, result)
       @when_done_procs&.each { |p| p.(result) }
-      @waiting_fibers&.each_key do |f|
-        f.schedule(result)
-      end
-      return unless uncaught_exception && !@waiting_fibers
-
+      @waiting_fibers&.each_key { |f| f.schedule(result) }
+      
       # propagate unaught exception to parent
-      @parent&.schedule(result)
+      @parent&.schedule_with_priority(result) if uncaught_exception && !@waiting_fibers
     end
 
     def when_done(&block)
@@ -344,14 +322,13 @@ end
 class ::Fiber
   prepend Polyphony::FiberControl
   include Polyphony::FiberSupervision
-  include Polyphony::FiberMessaging
   include Polyphony::ChildFiberControl
   include Polyphony::FiberLifeCycle
 
   extend Polyphony::FiberControlClassMethods
 
   attr_accessor :tag, :thread, :parent
-  attr_reader :result
+  attr_reader :result, :mailbox
 
   def running?
     @running

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