polyphony 0.36 → 0.38

data/lib/polyphony/core/global_api.rb

@@ -1,119 +1,120 @@
 # frozen_string_literal: true
 
-export_default :API
-
-import '../extensions/core'
-import '../extensions/fiber'
-
-Exceptions  = import '../core/exceptions'
-Throttler   = import '../core/throttler'
+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
 
-# Global API methods to be included in ::Object
-module API
-  def after(interval, &block)
-    spin do
-      sleep interval
-      block.()
+    def cancel_after(interval, &block)
+      fiber = ::Fiber.current
+      canceller = spin do
+        sleep interval
+        fiber.schedule Polyphony::Cancel.new
+      end
+      block ? cancel_after_wrap_block(canceller, &block) : canceller
     end
-  end
 
-  def cancel_after(interval, &block)
-    fiber = ::Fiber.current
-    canceller = spin do
-      sleep interval
-      fiber.schedule Exceptions::Cancel.new
+    def cancel_after_wrap_block(canceller, &block)
+      block.call
+    ensure
+      canceller.stop
     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(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 spin_loop(tag = nil, rate: nil, &block)
-    if rate
-      Fiber.current.spin(tag, caller) do
-        throttled_loop(rate, &block)
+    def every(interval)
+      timer = Gyro::Timer.new(interval, interval)
+      loop do
+        timer.await
+        yield
       end
-    else
-      Fiber.current.spin(tag, caller) { loop(&block) }
+    ensure
+      timer.stop
     end
-  end
 
-  def every(interval)
-    timer = Gyro::Timer.new(interval, interval)
-    loop do
-      timer.await
-      yield
+    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
-  ensure
-    timer.stop
-  end
 
-  def move_on_after(interval, with_value: nil, &block)
-    fiber = ::Fiber.current
-    unless block
-      return spin do
+    def move_on_after_with_block(fiber, interval, with_value, &block)
+      canceller = spin do
         sleep interval
-        fiber.schedule with_value
+        fiber.schedule Polyphony::MoveOn.new(with_value)
       end
+      block.call
+    rescue Polyphony::MoveOn => e
+      e.value
+    ensure
+      canceller.stop
     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 Exceptions::MoveOn.new(with_value)
+    def receive
+      Fiber.current.receive
     end
-    block.call
-  rescue Exceptions::MoveOn => e
-    e.value
-  ensure
-    canceller.stop
-  end
 
-  def receive
-    Fiber.current.receive
-  end
-
-  def receive_pending
-    Fiber.current.receive_pending
-  end
+    def receive_pending
+      Fiber.current.receive_pending
+    end
 
-  def supervise(*args, &block)
-    Fiber.current.supervise(*args, &block)
-  end
+    def supervise(*args, &block)
+      Fiber.current.supervise(*args, &block)
+    end
 
-  def sleep(duration = nil)
-    return sleep_forever unless duration
+    def sleep(duration = nil)
+      return sleep_forever unless duration
 
-    timer = Gyro::Timer.new(duration, 0)
-    timer.await
-  end
+      timer = Gyro::Timer.new(duration, 0)
+      timer.await
+    end
 
-  def sleep_forever
-    Thread.current.fiber_ref
-    suspend
-  ensure
-    Thread.current.fiber_unref
-  end
+    def sleep_forever
+      Thread.current.fiber_ref
+      suspend
+    ensure
+      Thread.current.fiber_unref
+    end
 
-  def throttled_loop(rate, count: nil, &block)
-    throttler = Throttler.new(rate)
-    if count
-      count.times { throttler.(&block) }
-    else
-      loop { throttler.(&block) }
+    def throttled_loop(rate, count: nil, &block)
+      throttler = Polyphony::Throttler.new(rate)
+      if count
+        count.times { throttler.(&block) }
+      else
+        loop { throttler.(&block) }
+      end
+    ensure
+      throttler.stop
     end
-  ensure
-    throttler.stop
   end
 end
+
+Object.include Polyphony::GlobalAPI

data/lib/polyphony/core/resource_pool.rb

@@ -1,107 +1,107 @@
 # frozen_string_literal: true
 
-export_default :ResourcePool
-
-# Implements a limited resource pool
-class ResourcePool
-  attr_reader :limit, :size
-
-  # Initializes a new resource pool
-  # @param opts [Hash] options
-  # @param &block [Proc] allocator block
-  def initialize(opts, &block)
-    @allocator = block
+module Polyphony
+  # Implements a limited resource pool
+  class ResourcePool
+    attr_reader :limit, :size
+
+    # Initializes a new resource pool
+    # @param opts [Hash] options
+    # @param &block [Proc] allocator block
+    def initialize(opts, &block)
+      @allocator = block
+
+      @stock = []
+      @queue = []
+
+      @limit = opts[:limit] || 4
+      @size = 0
+    end
 
-    @stock = []
-    @queue = []
+    def available
+      @stock.size
+    end
 
-    @limit = opts[:limit] || 4
-    @size = 0
-  end
+    def acquire
+      Gyro.ref
+      resource = wait_for_resource
+      return unless resource
 
-  def available
-    @stock.size
-  end
+      yield resource
+    ensure
+      Gyro.unref
+      release(resource) if resource
+    end
 
-  def acquire
-    Gyro.ref
-    resource = wait_for_resource
-    return unless resource
+    def wait_for_resource
+      fiber = Fiber.current
+      @queue << fiber
+      ready_resource = from_stock
+      return ready_resource if ready_resource
 
-    yield resource
-  ensure
-    Gyro.unref
-    release(resource) if resource
-  end
+      suspend
+    ensure
+      @queue.delete(fiber)
+    end
 
-  def wait_for_resource
-    fiber = Fiber.current
-    @queue << fiber
-    ready_resource = from_stock
-    return ready_resource if ready_resource
+    def release(resource)
+      if resource.__discarded__
+        @size -= 1
+      elsif resource
+        return_to_stock(resource)
+        dequeue
+      end
+    end
 
-    suspend
-  ensure
-    @queue.delete(fiber)
-  end
+    def dequeue
+      return if @queue.empty? || @stock.empty?
 
-  def release(resource)
-    if resource.__discarded__
-      @size -= 1
-    elsif resource
-      return_to_stock(resource)
-      dequeue
+      @queue.shift.schedule(@stock.shift)
     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 return_to_stock(resource)
-    @stock << resource
-  end
+    def from_stock
+      @stock.shift || (@size < @limit && allocate)
+    end
 
-  def from_stock
-    @stock.shift || (@size < @limit && allocate)
-  end
+    def method_missing(sym, *args, &block)
+      acquire { |r| r.send(sym, *args, &block) }
+    end
 
-  def method_missing(sym, *args, &block)
-    acquire { |r| r.send(sym, *args, &block) }
-  end
+    def respond_to_missing?(*_args)
+      true
+    end
 
-  def respond_to_missing?(*_args)
-    true
-  end
+    # Extension to allow discarding of resources
+    module ResourceExtensions
+      def __discarded__
+        @__discarded__
+      end
 
-  # Extension to allow discarding of resources
-  module ResourceExtensions
-    def __discarded__
-      @__discarded__
+      def __discard__
+        @__discarded__ = true
+      end
     end
 
-    def __discard__
-      @__discarded__ = true
+    # Allocates a resource
+    # @return [any] allocated resource
+    def allocate
+      @size += 1
+      @allocator.().tap { |r| r.extend ResourceExtensions }
     end
-  end
-
-  # Allocates a resource
-  # @return [any] allocated resource
-  def allocate
-    @size += 1
-    @allocator.().tap { |r| r.extend ResourceExtensions }
-  end
 
-  def <<(resource)
-    @size += 1
-    resource.extend ResourceExtensions
-    @stock << resource
-    dequeue
-  end
+    def <<(resource)
+      @size += 1
+      resource.extend ResourceExtensions
+      @stock << resource
+      dequeue
+    end
 
-  def preheat!
-    (@limit - @size).times { @stock << allocate }
+    def preheat!
+      (@limit - @size).times { @stock << allocate }
+    end
   end
-end
+end

data/lib/polyphony/core/sync.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-export :Mutex
+module Polyphony
+  # Implements mutex lock for synchronizing access to a shared resource
+  class Mutex
+    def initialize
+      @waiting_fibers = Gyro::Queue.new
+    end
 
-# Implements mutex lock for synchronizing access to a shared resource
-class Mutex
-  def initialize
-    @waiting_fibers = []
+    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
+    end
   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
-  end
-end
+end

data/lib/polyphony/core/thread_pool.rb

@@ -1,52 +1,64 @@
 # frozen_string_literal: true
 
-export_default :ThreadPool
-
 require 'etc'
 
-# Implements a pool of threads
-class ThreadPool
-  attr_reader :size
+module Polyphony
+  # Implements a pool of threads
+  class ThreadPool
+    attr_reader :size
 
-  def self.process(&block)
-    @default_pool ||= new
-    @default_pool.process(&block)
-  end
+    def self.process(&block)
+      @default_pool ||= self.new
+      @default_pool.process(&block)
+    end
 
-  def initialize(size = Etc.nprocessors)
-    @size = size
-    @task_queue = ::Queue.new
-    @threads = (1..@size).map { Thread.new { thread_loop } }
-  end
+    def self.reset
+      return unless @default_pool
+      
+      @default_pool.stop
+      @default_pool = nil
+    end
 
-  def process(&block)
-    setup unless @task_queue
+    def initialize(size = Etc.nprocessors)
+      @size = size
+      @task_queue = Gyro::Queue.new
+      @threads = (1..@size).map { Thread.new { thread_loop } }
+    end
 
-    async = Fiber.current.auto_async
-    @task_queue << [block, async]
-    async.await
-  end
+    def process(&block)
+      setup unless @task_queue
 
-  def cast(&block)
-    setup unless @task_queue
+      async = Fiber.current.auto_async
+      @task_queue << [block, async]
+      async.await
+    end
 
-    @task_queue << [block, nil]
-    self
-  end
+    def cast(&block)
+      setup unless @task_queue
 
-  def busy?
-    !@task_queue.empty?
-  end
+      @task_queue << [block, nil]
+      self
+    end
 
-  def thread_loop
-    loop { run_queued_task }
-  end
+    def busy?
+      !@task_queue.empty?
+    end
+
+    def thread_loop
+      loop { run_queued_task }
+    end
+
+    def run_queued_task
+      (block, watcher) = @task_queue.pop
+      result = block.()
+      watcher&.signal(result)
+    rescue Exception => e
+      watcher ? watcher.signal(e) : raise(e)
+    end
 
-  def run_queued_task
-    (block, watcher) = @task_queue.pop
-    result = block.()
-    watcher&.signal(result)
-  rescue Exception => e
-    watcher ? watcher.signal(e) : raise(e)
+    def stop
+      @threads.each(&:kill)
+      @threads.each(&:join)
+    end
   end
 end