polyphony 0.43.8 → 0.45.0

data/lib/polyphony/adapters/irb.rb

@@ -16,7 +16,7 @@ if Object.constants.include?(:Reline)
         fiber.cancel
       end
       read_ios.each do |io|
-        Thread.current.agent.wait_io(io, false)
+        Thread.current.backend.wait_io(io, false)
         return [io]
       end
     rescue Polyphony::Cancel
@@ -26,22 +26,7 @@ if Object.constants.include?(:Reline)
     end
   end
 else
-  # readline blocks the current thread, so we offload it to the blocking-ops
-  # thread pool. That way, the reactor loop can keep running while waiting for
-  # readline to return
-  module ::Readline
-    alias_method :orig_readline, :readline
-
-    Workers = Polyphony::ThreadPool.new
-
-    def readline(*args)
-      p :readline
-      # caller.each do |l|
-      #   STDOUT.orig_puts l
-      # end
-      Workers.process { orig_readline(*args) }
-    end
-  end
+  require_relative './readline'
 
   # RubyLex patches
   class ::RubyLex

data/lib/polyphony/adapters/mysql2.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../../polyphony'
+require 'mysql2/client'
+
+# Mysql2::Client overrides
+Mysql2::Client.prepend(Module.new do
+  def initialize(config)
+    config[:async] = true
+    super
+    @io = ::IO.for_fd(socket)
+  end
+
+  def query(sql, **options)
+    super
+    Thread.current.backend.wait_io(@io, false)
+    async_result
+  end
+end)

data/lib/polyphony/adapters/postgres.rb

@@ -15,8 +15,8 @@ module ::PG
       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_READING  then Thread.current.backend.wait_io(socket_io, false)
+      when PGRES_POLLING_WRITING  then Thread.current.backend.wait_io(socket_io, true)
       when PGRES_POLLING_OK       then return conn.setnonblocking(true)
       end
     end
@@ -42,7 +42,7 @@ class ::PG::Connection
 
   def get_result(&block)
     while is_busy
-      Thread.current.agent.wait_io(socket_io, false)
+      Thread.current.backend.wait_io(socket_io, false)
       consume_input
     end
     orig_get_result(&block)
@@ -59,7 +59,7 @@ class ::PG::Connection
 
   def block(_timeout = 0)
     while is_busy
-      Thread.current.agent.wait_io(socket_io, false)
+      Thread.current.backend.wait_io(socket_io, false)
       consume_input
     end
   end
@@ -97,7 +97,7 @@ class ::PG::Connection
     return move_on_after(timeout) { wait_for_notify(&block) } if timeout
 
     loop do
-      Thread.current.agent.wait_io(socket_io, false)
+      Thread.current.backend.wait_io(socket_io, false)
       consume_input
       notice = notifies
       next unless notice

data/lib/polyphony/adapters/process.rb

@@ -7,7 +7,7 @@ module Polyphony
       def watch(cmd = nil, &block)
         terminated = nil
         pid = cmd ? Kernel.spawn(cmd) : Polyphony.fork(&block)
-        Thread.current.agent.waitpid(pid)
+        Thread.current.backend.waitpid(pid)
         terminated = true
       ensure
         kill_process(pid) unless terminated || pid.nil?
@@ -23,7 +23,7 @@ module Polyphony
 
       def kill_and_await(sig, pid)
         ::Process.kill(sig, pid)
-        Thread.current.agent.waitpid(pid)
+        Thread.current.backend.waitpid(pid)
       rescue SystemCallError
         # ignore
         puts 'SystemCallError in kill_and_await'

data/lib/polyphony/adapters/readline.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'polyphony'
+require 'readline'
+
+# readline blocks the current thread, so we offload it to the blocking-ops
+# thread pool. That way, the reactor loop can keep running while waiting for
+# readline to return
+module ::Readline
+  alias_method :orig_readline, :readline
+
+  Worker = Polyphony::ThreadPool.new(1)
+
+  def readline(*args)
+    Worker.process { orig_readline(*args) }
+  end
+end

data/lib/polyphony/adapters/sequel.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../../polyphony'
+require 'sequel'
+
+module Polyphony
+  # Sequel ConnectionPool that delegates to Polyphony::ResourcePool.
+  class FiberConnectionPool < Sequel::ConnectionPool
+    def initialize(db, opts = OPTS)
+      super
+      max_size = Integer(opts[:max_connections] || 4)
+      @pool = Polyphony::ResourcePool.new(limit: max_size) { make_new(:default) }
+    end
+
+    def hold(_server = nil)
+      @pool.acquire do |conn|
+        yield conn
+      rescue Polyphony::BaseException
+        # The connection may be in an unrecoverable state if interrupted,
+        # discard the connection from the pool so it isn't reused.
+        @pool.discard!
+        raise
+      end
+    end
+
+    def size
+      @pool.size
+    end
+
+    def max_size
+      @pool.limit
+    end
+
+    def preconnect(_concurrent = false)
+      @pool.preheat!
+    end
+  end
+
+  # Override Sequel::Database to use FiberConnectionPool by default.
+  Sequel::Database.prepend(Module.new do
+    def connection_pool_default_options
+      { pool_class: FiberConnectionPool }
+    end
+  end)
+end

data/lib/polyphony/core/channel.rb

@@ -5,42 +5,11 @@ 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
+  class Channel < Polyphony::Queue
+    alias_method :receive, :shift
 
     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
+      flush_waiters(Polyphony::MoveOn.new)
     end
   end
 end

data/lib/polyphony/core/exceptions.rb

@@ -33,4 +33,15 @@ module Polyphony
 
   # Restart is used to restart a fiber
   class Restart < BaseException; end
+
+  # Interjection is used to run arbitrary code on arbitrary fibers at any point
+  class Interjection < BaseException
+    def initialize(proc)
+      @proc = proc
+    end
+
+    def invoke
+      @proc.call
+    end
+  end
 end

data/lib/polyphony/core/global_api.rb

@@ -19,13 +19,18 @@ module Polyphony
       fiber = ::Fiber.current
       canceller = spin do
         sleep interval
-        exception = with_exception.is_a?(Class) ?
-          with_exception.new : RuntimeError.new(with_exception)
+        exception = cancel_exception(with_exception)
         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)
+    end
+
     def cancel_after_wrap_block(canceller, &block)
       block.call
     ensure
@@ -50,7 +55,7 @@ module Polyphony
       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)
+        Thread.current.backend.sleep(next_time - now)
         yield
         loop do
           next_time += interval
@@ -98,14 +103,14 @@ module Polyphony
     def sleep(duration = nil)
       return sleep_forever unless duration
 
-      Thread.current.agent.sleep duration
+      Thread.current.backend.sleep duration
     end
 
     def sleep_forever
-      Thread.current.agent.ref
+      Thread.current.backend.ref
       loop { sleep 60 }
     ensure
-      Thread.current.agent.unref
+      Thread.current.backend.unref
     end
 
     def throttled_loop(rate, count: nil, &block)

data/lib/polyphony/core/resource_pool.rb

@@ -10,73 +10,35 @@ module Polyphony
     # @param &block [Proc] allocator block
     def initialize(opts, &block)
       @allocator = block
-
-      @stock = []
-      @queue = []
-      @acquired_resources = {}
-
       @limit = opts[:limit] || 4
       @size = 0
+      @stock = Polyphony::Queue.new
+      @acquired_resources = {}
     end
 
     def available
       @stock.size
     end
 
-    def acquire
-      fiber = Fiber.current
-      if @acquired_resources[fiber]
-        yield @acquired_resources[fiber]
-      else
-        begin
-          Thread.current.agent.ref
-          resource = wait_for_resource
-          return unless resource
-          
-          @acquired_resources[fiber] = resource
-          yield resource
-        ensure
-          @acquired_resources.delete fiber
-          Thread.current.agent.unref
-          release(resource) if resource
-        end
-      end
-    end
-        
-    def wait_for_resource
+    def acquire(&block)
       fiber = Fiber.current
-      @queue << fiber
-      ready_resource = from_stock
-      return ready_resource if ready_resource
+      return yield @acquired_resources[fiber] if @acquired_resources[fiber]
 
-      suspend
-    ensure
-      @queue.delete(fiber)
+      acquire_from_stock(fiber, &block)
     end
 
-    def release(resource)
-      if resource.__discarded__
-        @size -= 1
-      elsif resource
-        return_to_stock(resource)
-        dequeue
+    def acquire_from_stock(fiber)
+      add_to_stock if (@stock.empty? || @stock.pending?) && @size < @limit
+      resource = @stock.shift
+      @acquired_resources[fiber] = resource
+      yield resource
+    ensure
+      if resource && @acquired_resources[fiber] == resource
+        @acquired_resources.delete(fiber)
+        @stock.push resource
       end
     end
 
-    def dequeue
-      return if @queue.empty? || @stock.empty?
-
-      @queue.shift.schedule(@stock.shift)
-    end
-
-    def return_to_stock(resource)
-      @stock << resource
-    end
-
-    def from_stock
-      @stock.shift || (@size < @limit && allocate)
-    end
-
     def method_missing(sym, *args, &block)
       acquire { |r| r.send(sym, *args, &block) }
     end
@@ -85,33 +47,22 @@ module Polyphony
       true
     end
 
-    # Extension to allow discarding of resources
-    module ResourceExtensions
-      def __discarded__
-        @__discarded__
-      end
-
-      def __discard__
-        @__discarded__ = true
-      end
-    end
-
     # Allocates a resource
     # @return [any] allocated resource
-    def allocate
+    def add_to_stock
       @size += 1
-      @allocator.().tap { |r| r.extend ResourceExtensions }
+      resource = @allocator.call
+      @stock << resource
     end
 
-    def <<(resource)
-      @size += 1
-      resource.extend ResourceExtensions
-      @stock << resource
-      dequeue
+    # Discards the currently-acquired resource
+    # instead of returning it to the pool when done.
+    def discard!
+      @size -= 1 if @acquired_resources.delete(Fiber.current)
     end
 
     def preheat!
-      (@limit - @size).times { @stock << allocate }
+      add_to_stock while @size < @limit
     end
   end
 end

data/lib/polyphony/core/sync.rb

@@ -4,18 +4,57 @@ module Polyphony
   # Implements mutex lock for synchronizing access to a shared resource
   class Mutex
     def initialize
-      @waiting_fibers = Polyphony::Queue.new
+      @store = Queue.new
+      @store << :token
     end
 
     def synchronize
-      fiber = Fiber.current
-      @waiting_fibers << fiber
-      suspend if @waiting_fibers.size > 1
-      yield
-    ensure
-      @waiting_fibers.delete(fiber)
-      @waiting_fibers.first&.schedule
-      snooze
+      return yield if @holding_fiber == Fiber.current
+
+      begin
+        @token = @store.shift
+        @holding_fiber = Fiber.current
+        yield
+      ensure
+        @holding_fiber = nil
+        @store << @token if @token
+      end
+    end
+
+    def conditional_release
+      @store << @token
+      @token = nil
+      @holding_fiber = nil
+    end
+
+    def conditional_reacquire
+      @token = @store.shift
+      @holding_fiber = Fiber.current
+    end
+  end
+
+  # Implements a fiber-aware ConditionVariable
+  class ConditionVariable
+    def initialize
+      @queue = Polyphony::Queue.new
+    end
+
+    def wait(mutex, _timeout = nil)
+      mutex.conditional_release
+      @queue << Fiber.current
+      Thread.current.backend.wait_event(true)
+      mutex.conditional_reacquire
+    end
+
+    def signal
+      fiber = @queue.shift
+      fiber.schedule
+    end
+
+    def broadcast
+      while (fiber = @queue.shift)
+        fiber.schedule
+      end
     end
   end
 end