polyphony 0.45.0 → 0.46.0

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/fs.rb

@@ -2,7 +2,7 @@
 
 require 'fileutils'
 
-require_relative './core/thread_pool'
+require_relative '../core/thread_pool'
 
 ::File.singleton_class.instance_eval do
   alias_method :orig_stat, :stat

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/redis.rb

@@ -56,7 +56,7 @@ class Polyphony::RedisDriver
     reply = @reader.gets
     return reply if reply
 
-    while (data = @connection.readpartial(8192))
+    @connection.read_loop do |data|
       @reader.feed(data)
       reply = @reader.gets
       return reply unless reply == false

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/global_api.rb

@@ -32,7 +32,7 @@ module Polyphony
     end
 
     def cancel_after_wrap_block(canceller, &block)
-      block.call
+      block.call(canceller)
     ensure
       canceller.stop
     end
@@ -81,7 +81,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 +92,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,16 +107,13 @@ 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, count: nil, &block)
-      throttler = Polyphony::Throttler.new(rate)
-      if count
-        count.times { |_i| throttler.(&block) }
+    def throttled_loop(rate = nil, **opts, &block)
+      throttler = Polyphony::Throttler.new(rate || opts)
+      if opts[:count]
+        opts[:count].times { |_i| throttler.(&block) }
       else
         loop { throttler.(&block) }
       end

data/lib/polyphony/core/sync.rb

@@ -8,11 +8,15 @@ module Polyphony
       @store << :token
     end
 
-    def synchronize
+    def synchronize(&block)
       return yield if @holding_fiber == Fiber.current
 
+      synchronize_not_holding(&block)
+    end
+
+    def synchronize_not_holding
+      @token = @store.shift
       begin
-        @token = @store.shift
         @holding_fiber = Fiber.current
         yield
       ensure

data/lib/polyphony/extensions/core.rb

@@ -141,12 +141,7 @@ module ::Kernel
   end
 
   def pipe_to_eof(src, dest)
-    loop do
-      data = src.readpartial(8192)
-      dest << data
-    rescue EOFError
-      break
-    end
+    src.read_loop { |data| dest << data }
   end
 
   alias_method :orig_trap, :trap
@@ -154,32 +149,19 @@ 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)

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)
@@ -163,19 +174,29 @@ class ::IO
   # def putc(obj)
   # end
 
+  LINEFEED = "\n"
+  LINEFEED_RE = /\n$/.freeze
+
   alias_method :orig_puts, :puts
   def puts(*args)
     if args.empty?
-      write "\n"
+      write LINEFEED
       return
     end
 
-    strs = args.each_with_object([]) do |a, m|
-      a = a.to_s
-      m << a
-      m << "\n" unless a =~ /\n$/
+    idx = 0
+    while idx < args.size
+      arg = args[idx]
+      args[idx] = arg = arg.to_s unless arg.is_a?(String)
+      if arg =~ LINEFEED_RE
+        idx += 1
+      else
+        args.insert(idx + 1, LINEFEED)
+        idx += 2
+      end
     end
-    write(*strs)
+
+    write(*args)
     nil
   end
 
@@ -217,4 +238,28 @@ class ::IO
   #   end
   #   outbuf
   # end
+
+  def wait_readable(timeout = nil)
+    if timeout
+      move_on_after(timeout) do
+        Thread.current.backend.wait_io(self, false)
+        self
+      end
+    else
+      Thread.current.backend.wait_io(self, false)
+      self
+    end
+  end
+
+  def wait_writable(timeout = nil)
+    if timeout
+      move_on_after(timeout) do
+        Thread.current.backend.wait_io(self, true)
+        self
+      end
+    else
+      Thread.current.backend.wait_io(self, true)
+      self
+    end
+  end
 end

data/lib/polyphony/extensions/socket.rb

@@ -13,21 +13,27 @@ class ::Socket
 
   NO_EXCEPTION = { exception: false }.freeze
 
-  def connect(remotesockaddr)
-    Thread.current.backend.connect(self, remotesockaddr.ip_address, remotesockaddr.ip_port)
+  def connect(addr)
+    addr = Addrinfo.new(addr) if addr.is_a?(String)
+    Thread.current.backend.connect(self, addr.ip_address, addr.ip_port)
   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)
@@ -43,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
@@ -118,6 +137,45 @@ class ::TCPSocket
   def reuse_port
     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
+
+  def write_nonblock(buf, exception: true)
+    @io.write_nonblock(buf, exception: exception)
+  end
 end
 
 # Override stock TCPServer code by encapsulating a Socket instance.