polyphony 0.43.8

data/lib/polyphony/adapters/postgres.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative '../../polyphony'
+require 'pg'
+
+# PG overrides
+module ::PG
+  def self.connect(*args)
+    Connection.connect_start(*args).tap(&method(:connect_async))
+  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 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
+  end
+
+  def self.connect_sync(conn)
+    loop do
+      res = conn.connect_poll
+      case res
+      when PGRES_POLLING_FAILED
+        raise Error, conn.error_message
+      when PGRES_POLLING_OK
+        conn.setnonblocking(true)
+        return
+      end
+    end
+  end
+end
+
+# Overrides for PG connection
+class ::PG::Connection
+  alias_method :orig_get_result, :get_result
+
+  def get_result(&block)
+    while is_busy
+      Thread.current.agent.wait_io(socket_io, false)
+      consume_input
+    end
+    orig_get_result(&block)
+  end
+
+  alias_method :orig_async_exec, :async_exec
+  def async_exec(*args, &block)
+    send_query(*args)
+    get_result(&block)
+  ensure
+    # cleanup result in order to allow next query
+    while get_result; end
+  end
+
+  def block(_timeout = 0)
+    while is_busy
+      Thread.current.agent.wait_io(socket_io, false)
+      consume_input
+    end
+  end
+
+  SQL_BEGIN = 'begin'
+  SQL_COMMIT = 'commit'
+  SQL_ROLLBACK = 'rollback'
+
+  # Starts a transaction, runs given block, and commits transaction. If an
+  # error is raised, the transaction is rolled back and the error is raised
+  # again.
+  # @return [void]
+  def transaction(&block)
+    return yield if @transaction # allow nesting of calls to #transactions
+
+    perform_transaction(&block)
+  end
+
+  def perform_transaction
+    query(SQL_BEGIN)
+    began = true
+    @transaction = true
+    yield
+    query(SQL_COMMIT)
+  rescue StandardError => e
+    query(SQL_ROLLBACK) if began
+    raise e
+  ensure
+    @transaction = false
+  end
+
+  self.async_api = true
+
+  def wait_for_notify(timeout = nil, &block)
+    return move_on_after(timeout) { wait_for_notify(&block) } if timeout
+
+    loop do
+      Thread.current.agent.wait_io(socket_io, false)
+      consume_input
+      notice = notifies
+      next unless notice
+
+      values = notice.values
+      block&.(*values)
+      return values.first
+    end
+  end
+end

data/lib/polyphony/adapters/process.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+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 kill_process(pid)
+        cancel_after(5) do
+          kill_and_await('TERM', pid)
+        end
+      rescue Polyphony::Cancel
+        kill_and_await(-9, pid)
+      end
+
+      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
+end

data/lib/polyphony/adapters/redis.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative '../../polyphony'
+
+require 'redis'
+require 'hiredis/reader'
+
+# Polyphony-based Redis driver
+class Polyphony::RedisDriver
+  def self.connect(config)
+    raise 'unix sockets not supported' if config[:scheme] == 'unix'
+
+    # connection.connect_unix(config[:path], connect_timeout)
+
+    raise 'ssl not supported' if config[:scheme] == 'rediss' || config[:ssl]
+
+    # raise NotImplementedError, "SSL not supported by hiredis driver"
+
+    new(config[:host], config[:port])
+    # connection.connect(config[:host], config[:port], connect_timeout)
+  end
+
+  def initialize(host, port)
+    @connection = Polyphony::Net.tcp_connect(host, port)
+    @reader = ::Hiredis::Reader.new
+  end
+
+  def connected?
+    @connection && !@connection.closed?
+  end
+
+  def timeout=(timeout)
+    # ignore timeout for now
+  end
+
+  def disconnect
+    @connection.close
+    @connection = nil
+  end
+
+  def write(command)
+    @connection.write(format_command(command))
+  end
+
+  def format_command(args)
+    args = args.flatten
+    (+"*#{args.size}\r\n").tap do |s|
+      args.each do |a|
+        a = a.to_s
+        s << "$#{a.bytesize}\r\n#{a}\r\n"
+      end
+    end
+  end
+
+  def read
+    reply = @reader.gets
+    return reply if reply
+
+    while (data = @connection.readpartial(8192))
+      @reader.feed(data)
+      reply = @reader.gets
+      return reply unless reply == false
+    end
+  end
+end
+
+Redis::Connection.drivers << Polyphony::RedisDriver

data/lib/polyphony/adapters/trace.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative '../../polyphony'
+
+STOCK_EVENTS = %i[line call return c_call c_return b_call b_return].freeze
+
+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
+
+      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
+
+      SCHEDULE_VALUE_EVENTS = %i[fiber_schedule fiber_run].freeze
+
+      def tp_schedule_value(trp)
+        SCHEDULE_VALUE_EVENTS.include?(trp.event) ? trp.value : nil
+      end
+
+      def tp_raised_exception(trp)
+        trp.event == :raise && trp.raised_exception
+      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
+
+      # Implements fake TracePoint instances for fiber-related events
+      class FiberTracePoint
+        attr_reader :event, :fiber, :value
+
+        def initialize(tpoint)
+          @tp = tpoint
+          @event = tpoint.return_value[0]
+          @fiber = tpoint.return_value[1]
+          @value = tpoint.return_value[2]
+        end
+
+        def lineno
+          @tp.lineno
+        end
+
+        def method_id
+          @tp.method_id
+        end
+
+        def path
+          @tp.path
+        end
+
+        def self
+          @tp.self
+        end
+
+        def binding
+          @tp.binding
+        end
+      end
+
+      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
+end

data/lib/polyphony/core/channel.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative './exceptions'
+
+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 = 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)
+      end
+      snooze
+    end
+
+    def receive
+      Thread.current.agent.ref
+      if @payload_queue.empty?
+        @waiting_queue << Fiber.current
+        suspend
+      else
+        receive_from_queue
+      end
+    ensure
+      Thread.current.agent.unref
+    end
+
+    def receive_from_queue
+      payload = @payload_queue.shift
+      snooze
+      payload
+    end
+  end
+end

data/lib/polyphony/core/exceptions.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Polyphony
+  # Common exception class for interrupting fibers. These exceptions allow
+  # control of fibers. BaseException exceptions can encapsulate a value and thus
+  # provide a way to interrupt long-running blocking operations while still
+  # passing a value back to the call site. BaseException exceptions can also
+  # references a cancel scope in order to allow correct bubbling of exceptions
+  # through nested cancel scopes.
+  class BaseException < ::Exception
+    attr_reader :value
+
+    def initialize(value = nil)
+      @caller_backtrace = caller
+      @value = value
+    end
+
+    def backtrace
+      sanitize(@caller_backtrace)
+    end
+  end
+
+  # MoveOn is used to interrupt a long-running blocking operation, while
+  # continuing the rest of the computation.
+  class MoveOn < BaseException; end
+
+  # Cancel is used to interrupt a long-running blocking operation, bubbling the
+  # exception up through cancel scopes and supervisors.
+  class Cancel < BaseException; end
+
+  # Terminate is used to interrupt a fiber once its parent fiber has terminated.
+  class Terminate < BaseException; end
+
+  # Restart is used to restart a fiber
+  class Restart < BaseException; end
+end

data/lib/polyphony/core/global_api.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative '../extensions/core'
+require_relative '../extensions/fiber'
+require_relative './exceptions'
+require_relative './throttler'
+
+module Polyphony
+  # Global API methods to be included in ::Object
+  module GlobalAPI
+    def after(interval, &block)
+      spin do
+        sleep interval
+        block.()
+      end
+    end
+
+    def cancel_after(interval, with_exception: Polyphony::Cancel, &block)
+      fiber = ::Fiber.current
+      canceller = spin do
+        sleep interval
+        exception = with_exception.is_a?(Class) ?
+          with_exception.new : RuntimeError.new(with_exception)
+        fiber.schedule exception
+      end
+      block ? cancel_after_wrap_block(canceller, &block) : canceller
+    end
+
+    def cancel_after_wrap_block(canceller, &block)
+      block.call
+    ensure
+      canceller.stop
+    end
+
+    def spin(tag = nil, &block)
+      Fiber.current.spin(tag, caller, &block)
+    end
+
+    def spin_loop(tag = nil, rate: nil, &block)
+      if rate
+        Fiber.current.spin(tag, caller) do
+          throttled_loop(rate, &block)
+        end
+      else
+        Fiber.current.spin(tag, caller) { loop(&block) }
+      end
+    end
+
+    def every(interval)
+      next_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + interval
+      loop do
+        now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        Thread.current.agent.sleep(next_time - now)
+        yield
+        loop do
+          next_time += interval
+          break if next_time > now
+        end
+      end
+    end
+
+    def move_on_after(interval, with_value: nil, &block)
+      fiber = ::Fiber.current
+      unless block
+        return spin do
+          sleep interval
+          fiber.schedule with_value
+        end
+      end
+
+      move_on_after_with_block(fiber, interval, with_value, &block)
+    end
+
+    def move_on_after_with_block(fiber, interval, with_value, &block)
+      canceller = spin do
+        sleep interval
+        fiber.schedule Polyphony::MoveOn.new(with_value)
+      end
+      block.call
+    rescue Polyphony::MoveOn => e
+      e.value
+    ensure
+      canceller.stop
+    end
+
+    def receive
+      Fiber.current.receive
+    end
+
+    def receive_pending
+      Fiber.current.receive_pending
+    end
+
+    def supervise(*args, &block)
+      Fiber.current.supervise(*args, &block)
+    end
+
+    def sleep(duration = nil)
+      return sleep_forever unless duration
+
+      Thread.current.agent.sleep duration
+    end
+
+    def sleep_forever
+      Thread.current.agent.ref
+      loop { sleep 60 }
+    ensure
+      Thread.current.agent.unref
+    end
+
+    def throttled_loop(rate, count: nil, &block)
+      throttler = Polyphony::Throttler.new(rate)
+      if count
+        count.times { |_i| throttler.(&block) }
+      else
+        loop { throttler.(&block) }
+      end
+    ensure
+      throttler&.stop
+    end
+  end
+end
+
+Object.include Polyphony::GlobalAPI