polyphony 0.34 → 0.41

data/lib/polyphony/adapters/fs.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
-export  :stat,
-        :read
-
 require 'fileutils'
 
-ThreadPool = import('./core/thread_pool')
+require_relative './core/thread_pool'
 
 ::File.singleton_class.instance_eval do
   alias_method :orig_stat, :stat

data/lib/polyphony/adapters/irb.rb

@@ -13,10 +13,10 @@ if Object.constants.include?(:Reline)
       fiber = Fiber.current
       timer = spin do
         sleep timeout
-        fiber.cancel!
+        fiber.cancel
       end
       read_ios.each do |io|
-        io.read_watcher.await
+        Thread.current.agent.wait_io(io, false)
         return [io]
       end
     rescue Polyphony::Cancel

data/lib/polyphony/adapters/postgres.rb

@@ -10,12 +10,13 @@ module ::PG
   end
 
   def self.connect_async(conn)
+    socket_io = conn.socket_io
     loop do
       res = conn.connect_poll
       case res
       when PGRES_POLLING_FAILED   then raise Error, conn.error_message
-      when PGRES_POLLING_READING  then conn.socket_io.read_watcher.await
-      when PGRES_POLLING_WRITING  then conn.socket_io.write_watcher.await
+      when PGRES_POLLING_READING  then Thread.current.agent.wait_io(socket_io, false)
+      when PGRES_POLLING_WRITING  then Thread.current.agent.wait_io(socket_io, true)
       when PGRES_POLLING_OK       then return conn.setnonblocking(true)
       end
     end
@@ -41,7 +42,7 @@ class ::PG::Connection
 
   def get_result(&block)
     while is_busy
-      socket_io.read_watcher.await
+      Thread.current.agent.wait_io(socket_io, false)
       consume_input
     end
     orig_get_result(&block)
@@ -58,7 +59,7 @@ class ::PG::Connection
 
   def block(_timeout = 0)
     while is_busy
-      socket_io.read_watcher.await
+      Thread.current.agent.wait_io(socket_io, false)
       consume_input
     end
   end
@@ -96,7 +97,7 @@ class ::PG::Connection
     return move_on_after(timeout) { wait_for_notify(&block) } if timeout
 
     loop do
-      socket_io.read_watcher.await
+      Thread.current.agent.wait_io(socket_io, false)
       consume_input
       notice = notifies
       next unless notice

data/lib/polyphony/adapters/process.rb

@@ -1,29 +1,33 @@
 # frozen_string_literal: true
 
-export :watch
+module Polyphony
+  # Process patches
+  module Process
+    class << self
+      def watch(cmd = nil, &block)
+        terminated = nil
+        pid = cmd ? Kernel.spawn(cmd) : Polyphony.fork(&block)
+        Thread.current.agent.waitpid(pid)
+        terminated = true
+      ensure
+        kill_process(pid) unless terminated || pid.nil?
+      end
 
-def watch(cmd = nil, &block)
-  terminated = nil
-  pid = cmd ? Kernel.spawn(cmd) : Polyphony.fork(&block)
-  watcher = Gyro::Child.new(pid)
-  watcher.await
-  terminated = true
-ensure
-  kill_process(pid) unless terminated || pid.nil?
-end
+      def kill_process(pid)
+        cancel_after(5) do
+          kill_and_await('TERM', pid)
+        end
+      rescue Polyphony::Cancel
+        kill_and_await(-9, pid)
+      end
 
-def kill_process(pid)
-  cancel_after(5) do
-    kill_and_await('TERM', pid)
+      def kill_and_await(sig, pid)
+        ::Process.kill(sig, pid)
+        Thread.current.agent.waitpid(pid)
+      rescue SystemCallError
+        # ignore
+        puts 'SystemCallError in kill_and_await'
+      end
+    end
   end
-rescue Polyphony::Cancel
-  kill_and_await(-9, pid)
-end
-
-def kill_and_await(sig, pid)
-  Process.kill(sig, pid)
-  Gyro::Child.new(pid).await
-rescue SystemCallError
-  # ignore
-  puts 'SystemCallError in kill_and_await'
 end

data/lib/polyphony/adapters/trace.rb

@@ -1,132 +1,137 @@
 # frozen_string_literal: true
 
-export :new, :analyze, :STOCK_EVENTS
-
-require 'polyphony'
+require_relative '../../polyphony'
 
 STOCK_EVENTS = %i[line call return c_call c_return b_call b_return].freeze
 
-def new(*events)
-  start_stamp = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-  events = STOCK_EVENTS if events.empty?
-  ::TracePoint.new(*events) { |tp| yield trace_record(tp, start_stamp) }
-end
-
-def trace_record(trp, start_stamp)
-  stamp = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start_stamp
-
-  { stamp: stamp, event: trp.event, location: "#{trp.path}:#{trp.lineno}",
-    self: trp.self, binding: trp.binding, fiber: tp_fiber(trp),
-    lineno: trp.lineno, method_id: trp.method_id,
-    path: trp.path, parameters: tp_params(trp),
-    return_value: tp_return_value(trp), schedule_value: tp_schedule_value(trp),
-    exception: tp_raised_exception(trp) }
-end
-
-def tp_fiber(trp)
-  trp.is_a?(FiberTracePoint) ? trp.fiber : Fiber.current
-end
-
-PARAMS_EVENTS = %i[call c_call b_call].freeze
-
-def tp_params(trp)
-  PARAMS_EVENTS.include?(trp.event) ? trp.parameters : nil
-end
-
-RETURN_VALUE_EVENTS = %i[return c_return b_return].freeze
-
-def tp_return_value(trp)
-  RETURN_VALUE_EVENTS.include?(trp.event) ? trp.return_value : nil
-end
+module Polyphony
+  # Tracing functionality for Polyphony
+  module Trace
+    class << self
+      def new(*events)
+        start_stamp = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        events = STOCK_EVENTS if events.empty?
+        ::TracePoint.new(*events) { |tp| yield trace_record(tp, start_stamp) }
+      end
 
-SCHEDULE_VALUE_EVENTS = %i[fiber_schedule fiber_run].freeze
+      def trace_record(trp, start_stamp)
+        stamp = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start_stamp
 
-def tp_schedule_value(trp)
-  SCHEDULE_VALUE_EVENTS.include?(trp.event) ? trp.value : nil
-end
+        { stamp: stamp, event: trp.event, location: "#{trp.path}:#{trp.lineno}",
+          self: trp.self, binding: trp.binding, fiber: tp_fiber(trp),
+          lineno: trp.lineno, method_id: trp.method_id,
+          path: trp.path, parameters: tp_params(trp),
+          return_value: tp_return_value(trp), schedule_value: tp_schedule_value(trp),
+          exception: tp_raised_exception(trp) }
+      end
 
-def tp_raised_exception(trp)
-  trp.event == :raise && trp.raised_exception
-end
+      def tp_fiber(trp)
+        trp.is_a?(FiberTracePoint) ? trp.fiber : Fiber.current
+      end
 
-def analyze(records)
-  by_fiber = Hash.new { |h, f| h[f] = [] }
-  records.each_with_object(by_fiber) { |r, h| h[r[:fiber]] << r }
-  { by_fiber: by_fiber }
-end
+      PARAMS_EVENTS = %i[call c_call b_call].freeze
 
-# Implements fake TracePoint instances for fiber-related events
-class FiberTracePoint
-  attr_reader :event, :fiber, :value
+      def tp_params(trp)
+        PARAMS_EVENTS.include?(trp.event) ? trp.parameters : nil
+      end
 
-  def initialize(tpoint)
-    @tp = tpoint
-    @event = tpoint.return_value[0]
-    @fiber = tpoint.return_value[1]
-    @value = tpoint.return_value[2]
-  end
+      RETURN_VALUE_EVENTS = %i[return c_return b_return].freeze
 
-  def lineno
-    @tp.lineno
-  end
+      def tp_return_value(trp)
+        RETURN_VALUE_EVENTS.include?(trp.event) ? trp.return_value : nil
+      end
 
-  def method_id
-    @tp.method_id
-  end
+      SCHEDULE_VALUE_EVENTS = %i[fiber_schedule fiber_run].freeze
 
-  def path
-    @tp.path
-  end
+      def tp_schedule_value(trp)
+        SCHEDULE_VALUE_EVENTS.include?(trp.event) ? trp.value : nil
+      end
 
-  def self
-    @tp.self
-  end
+      def tp_raised_exception(trp)
+        trp.event == :raise && trp.raised_exception
+      end
 
-  def binding
-    @tp.binding
-  end
-end
+      def analyze(records)
+        by_fiber = Hash.new { |h, f| h[f] = [] }
+        records.each_with_object(by_fiber) { |r, h| h[r[:fiber]] << r }
+        { by_fiber: by_fiber }
+      end
 
-class << ::TracePoint
-  POLYPHONY_FILE_REGEXP = /^#{::Exception::POLYPHONY_DIR}/.freeze
+      # Implements fake TracePoint instances for fiber-related events
+      class FiberTracePoint
+        attr_reader :event, :fiber, :value
 
-  alias_method :orig_new, :new
-  def new(*args, &block)
-    events_mask, fiber_events_mask = event_masks(args)
+        def initialize(tpoint)
+          @tp = tpoint
+          @event = tpoint.return_value[0]
+          @fiber = tpoint.return_value[1]
+          @value = tpoint.return_value[2]
+        end
 
-    orig_new(*events_mask) do |tp|
-      handle_tp_event(tp, fiber_events_mask, &block)
-    end
-  end
+        def lineno
+          @tp.lineno
+        end
 
-  def handle_tp_event(tpoint, fiber_events_mask)
-    # next unless !$watched_fiber || Fiber.current == $watched_fiber
+        def method_id
+          @tp.method_id
+        end
 
-    if tpoint.method_id == :__fiber_trace__
-      return if tpoint.event != :c_return
-      return unless fiber_events_mask.include?(tpoint.return_value[0])
+        def path
+          @tp.path
+        end
 
-      tpoint = FiberTracePoint.new(tpoint)
-    elsif tpoint.path =~ POLYPHONY_FILE_REGEXP
-      return
-    end
+        def self
+          @tp.self
+        end
 
-    yield tpoint
-  end
+        def binding
+          @tp.binding
+        end
+      end
 
-  ALL_FIBER_EVENTS = %i[
-    fiber_create fiber_terminate fiber_schedule fiber_switchpoint fiber_run
-    fiber_ev_loop_enter fiber_ev_loop_leave
-  ].freeze
-
-  def event_masks(events)
-    events.each_with_object([[], []]) do |e, masks|
-      case e
-      when /fiber_/
-        masks[1] += e == :fiber_all ? ALL_FIBER_EVENTS : [e]
-        masks[0] << :c_return unless masks[0].include?(:c_return)
-      else
-        masks[0] << e
+      class << ::TracePoint
+        POLYPHONY_FILE_REGEXP = /^#{::Exception::POLYPHONY_DIR}/.freeze
+
+        alias_method :orig_new, :new
+        def new(*args, &block)
+          events_mask, fiber_events_mask = event_masks(args)
+
+          orig_new(*events_mask) do |tp|
+            handle_tp_event(tp, fiber_events_mask, &block)
+          end
+        end
+
+        def handle_tp_event(tpoint, fiber_events_mask)
+          # next unless !$watched_fiber || Fiber.current == $watched_fiber
+
+          if tpoint.method_id == :__fiber_trace__
+            return if tpoint.event != :c_return
+            return unless fiber_events_mask.include?(tpoint.return_value[0])
+
+            tpoint = FiberTracePoint.new(tpoint)
+          elsif tpoint.path =~ POLYPHONY_FILE_REGEXP
+            return
+          end
+
+          yield tpoint
+        end
+
+        ALL_FIBER_EVENTS = %i[
+          fiber_create fiber_terminate fiber_schedule fiber_switchpoint fiber_run
+          fiber_ev_loop_enter fiber_ev_loop_leave
+        ].freeze
+
+        def event_masks(events)
+          events.each_with_object([[], []]) do |e, masks|
+            case e
+            when /fiber_/
+              masks[1] += e == :fiber_all ? ALL_FIBER_EVENTS : [e]
+              masks[0] << :c_return unless masks[0].include?(:c_return)
+            else
+              masks[0] << e
+            end
+          end
+        end
       end
     end
   end

data/lib/polyphony/core/channel.rb

@@ -1,46 +1,46 @@
 # frozen_string_literal: true
 
-export_default :Channel
+require_relative './exceptions'
 
-Exceptions = import('./exceptions')
-
-# Implements a unidirectional communication channel along the lines of Go
-# (buffered) channels.
-class Channel
-  def initialize
-    @payload_queue = []
-    @waiting_queue = []
-  end
+module Polyphony
+  # Implements a unidirectional communication channel along the lines of Go
+  # (buffered) channels.
+  class Channel
+    def initialize
+      @payload_queue = []
+      @waiting_queue = []
+    end
 
-  def close
-    stop = Exceptions::MoveOn.new
-    @waiting_queue.slice(0..-1).each { |f| f.schedule(stop) }
-  end
+    def close
+      stop = Polyphony::MoveOn.new
+      @waiting_queue.slice(0..-1).each { |f| f.schedule(stop) }
+    end
 
-  def <<(value)
-    if @waiting_queue.empty?
-      @payload_queue << value
-    else
-      @waiting_queue.shift&.schedule(value)
+    def <<(value)
+      if @waiting_queue.empty?
+        @payload_queue << value
+      else
+        @waiting_queue.shift&.schedule(value)
+      end
+      snooze
     end
-    snooze
-  end
 
-  def receive
-    Gyro.ref
-    if @payload_queue.empty?
-      @waiting_queue << Fiber.current
-      suspend
-    else
-      receive_from_queue
+    def receive
+      Polyphony.ref
+      if @payload_queue.empty?
+        @waiting_queue << Fiber.current
+        suspend
+      else
+        receive_from_queue
+      end
+    ensure
+      Polyphony.unref
     end
-  ensure
-    Gyro.unref
-  end
 
-  def receive_from_queue
-    payload = @payload_queue.shift
-    snooze
-    payload
+    def receive_from_queue
+      payload = @payload_queue.shift
+      snooze
+      payload
+    end
   end
 end