polyphony 0.43.6 → 0.44.0

data/lib/polyphony.rb

@@ -4,9 +4,6 @@ require 'fiber'
 require_relative './polyphony_ext'
 
 module Polyphony
-  # Map Queue to Libev queue implementation
-  Queue = LibevQueue
-
   # replace core Queue class with our own
   verbose = $VERBOSE
   $VERBOSE = nil
@@ -20,37 +17,29 @@ require_relative './polyphony/extensions/fiber'
 require_relative './polyphony/extensions/io'
 
 Thread.current.setup_fiber_scheduling
-Thread.current.agent = Polyphony::LibevAgent.new
+Thread.current.agent = Polyphony::Agent.new
 
 require_relative './polyphony/core/global_api'
 require_relative './polyphony/core/resource_pool'
 require_relative './polyphony/net'
 require_relative './polyphony/adapters/process'
-require_relative './polyphony/event'
 
 # Main Polyphony API
 module Polyphony
   class << self
-    def wait_for_signal(sig)
-      raise "should be reimplemented"
-
-      fiber = Fiber.current
-      # Polyphony.ref
-      old_trap = trap(sig) do
-        # Polyphony.unref
-        fiber.schedule(sig)
-        trap(sig, old_trap)
-      end
-      suspend
-
-    end
-
     def fork(&block)
       Kernel.fork do
-        # # Since the fiber doing the fork will become the main fiber of the
-        # # forked process, we leave it behind by transferring to a new fiber
-        # # created in the context of the forked process, which rescues *all*
-        # # exceptions, including Interrupt and SystemExit.
+        # A race condition can arise if a TERM or INT signal is received before
+        # the forked process has finished initializing. To prevent this we restore
+        # the default signal handlers, and then reinstall the custom Polyphony
+        # handlers just before running the given block.
+        trap('SIGTERM', 'DEFAULT')
+        trap('SIGINT', 'DEFAULT')
+
+        # Since the fiber doing the fork will become the main fiber of the
+        # forked process, we leave it behind by transferring to a new fiber
+        # created in the context of the forked process, which rescues *all*
+        # exceptions, including Interrupt and SystemExit.
         spin_forked_block(&block).transfer
       end
     end
@@ -61,7 +50,7 @@ module Polyphony
       rescue SystemExit
         # fall through to ensure
       rescue Exception => e
-        e.full_message
+        warn e.full_message
         exit!
       ensure
         exit_forked_process
@@ -69,13 +58,6 @@ module Polyphony
     end
 
     def run_forked_block(&block)
-      # A race condition can arise if a TERM or INT signal is received before
-      # the forked process has finished initializing. To prevent this we restore
-      # the default signal handlers, and then reinstall the custom Polyphony
-      # handlers just before running the given block.
-      trap('SIGTERM', 'DEFAULT')
-      trap('SIGINT', 'DEFAULT')
-
       Thread.current.setup
       Fiber.current.setup_main_fiber
       Thread.current.agent.post_fork

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.agent.wait_io(@io, false)
+    async_result
+  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/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[fiber] = nil
-          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,21 @@ 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
   end
 end

data/lib/polyphony/extensions/core.rb

@@ -46,6 +46,10 @@ class ::Exception
 
     backtrace.reject { |l| l[POLYPHONY_DIR] }
   end
+
+  def invoke
+    Kernel.raise(self)
+  end
 end
 
 # Overrides for Process
@@ -140,8 +144,16 @@ module ::Kernel
   def trap(sig, command = nil, &block)
     return orig_trap(sig, command) if command.is_a? String
       
-    block = command if command.respond_to?(:call) && !block
-    exception = command.is_a?(Class) && command.new
+    block = command if !block && command.respond_to?(:call)
+    if block
+      exception = Polyphony::Interjection.new(block)
+    else
+      exception = command.is_a?(Class) && command.new
+    end
+
+    unless exception
+      raise ArgumentError, "Must supply block or exception or callable object"
+    end
 
     # The signal trap can be invoked at any time, including while the system
     # agent is blocking while polling for events. In order to deal with this
@@ -152,12 +164,7 @@ module ::Kernel
     # If the command argument is an exception class however, it will be raised
     # directly in the context of the main fiber.
     orig_trap(sig) do
-      if exception
-        Thread.current.break_out_of_ev_loop(Thread.main.main_fiber, exception)
-      else
-        fiber = spin { snooze; block.call }
-        Thread.current.break_out_of_ev_loop(fiber, nil)
-      end
+      Thread.current.break_out_of_ev_loop(Thread.main.main_fiber, exception)
     end
   end
 end

data/lib/polyphony/extensions/fiber.rb

@@ -67,6 +67,10 @@ module Polyphony
       else RuntimeError.new
       end
     end
+
+    def interject(&block)
+      raise Polyphony::Interjection.new(block)
+    end
   end
 
   # Fiber supervision

data/lib/polyphony/extensions/socket.rb

@@ -24,15 +24,7 @@ class ::Socket
   NO_EXCEPTION = { exception: false }.freeze
 
   def connect(remotesockaddr)
-    loop do
-      result = connect_nonblock(remotesockaddr, **NO_EXCEPTION)
-      case result
-      when 0 then return
-      when :wait_writable then Thread.current.agent.wait_io(self, true)
-      else
-        raise IOError
-      end
-    end
+    Thread.current.agent.connect(self, remotesockaddr.ip_address, remotesockaddr.ip_port)
   end
 
   def recv(maxlen, flags = 0, outbuf = nil)
@@ -75,6 +67,10 @@ class ::Socket
     setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
   end
 
+  def reuse_port
+    setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEPORT, 1)
+  end
+
   class << self
     alias_method :orig_getaddrinfo, :getaddrinfo
     def getaddrinfo(*args)
@@ -128,6 +124,10 @@ class ::TCPSocket
   def reuse_addr
     setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR, 1)
   end
+
+  def reuse_port
+    setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEPORT, 1)
+  end
 end
 
 # Override stock TCPServer code by encapsulating a Socket instance.