polyphony 0.15 → 0.16

data/lib/polyphony.rb

@@ -4,37 +4,73 @@ require 'modulation/gem'
 
 export_default :Polyphony
 
-Polyphony = import('./polyphony/core')
-Exceptions = import('./polyphony/core/exceptions')
-
-import('polyphony/extensions/socket')
-import('polyphony/extensions/ssl')
+require 'fiber'
+require_relative './ev_ext'
+import('./polyphony/extensions/kernel')
+import('./polyphony/extensions/io')
 
 module Polyphony
-  Cancel        = Exceptions::Cancel
-  MoveOn        = Exceptions::MoveOn
+  exceptions = import('./polyphony/core/exceptions')
+  Cancel        = exceptions::Cancel
+  MoveOn        = exceptions::MoveOn
+
+  Coprocess = import('./polyphony/core/coprocess')
+  FiberPool = import('./polyphony/core/fiber_pool')
+  Net       = import('./polyphony/net')
 
-  Net = import('./polyphony/net')
 
+  def self.trap(sig, ref = false, &callback)
+    sig = Signal.list[sig.to_s.upcase] if sig.is_a?(Symbol)
+    watcher = EV::Signal.new(sig, &callback)
+    EV.unref unless ref
+    watcher
+  end
+  
+  def self.fork(&block)
+    EV.break
+    pid = Kernel.fork do
+      FiberPool.reset!
+      EV.post_fork
+      Fiber.current.coprocess = Coprocess.new(Fiber.current)
+  
+      block.()
+  
+      # We cannot simply depend on the at_exit block (see below) to yield to the
+      # reactor fiber. Doing that will raise a FiberError complaining: "fiber
+      # called across stack rewinding barrier". Apparently this is a bug in
+      # Ruby, so the workaround is to yield just before exiting.
+      suspend
+    end
+    EV.restart
+    pid
+  end
+  
+  def self.debug
+    @debug
+  end
+  
+  def self.debug=(value)
+    @debug = value
+  end
+  
   auto_import(
+    CancelScope:  './polyphony/core/cancel_scope',
     Channel:      './polyphony/core/channel',
-    Coprocess:    './polyphony/core/coprocess',
+    # Coprocess:    './polyphony/core/coprocess',
+    FS:           './polyphony/fs',
+    # Net:          './polyphony/net',
+    ResourcePool: './polyphony/core/resource_pool',
+    Supervisor:   './polyphony/core/supervisor',
     Sync:         './polyphony/core/sync',
     Thread:       './polyphony/core/thread',
     ThreadPool:   './polyphony/core/thread_pool',
-  
-    FS:           './polyphony/fs',
-    # Net:          './polyphony/net',
-    ResourcePool: './polyphony/resource_pool',
-    Supervisor:   './polyphony/supervisor',
     Websocket:    './polyphony/websocket'
   )
+end
 
-  module HTTP
-    auto_import(
-      Agent:      './polyphony/http/agent',
-      Rack:       './polyphony/http/rack',
-      Server:     './polyphony/http/server',
-    )
-  end
+at_exit do
+  # in most cases, by the main fiber is done there are still pending or other
+  # or asynchronous operations going on. If the reactor loop is not done, we
+  # suspend the root fiber until it is done
+  suspend if $__reactor_fiber__&.alive?
 end

data/polyphony.gemspec

@@ -17,15 +17,16 @@ Gem::Specification.new do |s|
   s.extensions = ["ext/ev/extconf.rb"]
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency      'modulation',     '0.23'
+  s.add_runtime_dependency      'modulation',     '0.24'
   
   s.add_runtime_dependency      'http_parser.rb', '0.6.0'
   s.add_runtime_dependency      'http-2',         '0.10.0'
   
-  # s.add_runtime_dependency      'hiredis',        '0.6.1'
-  # s.add_runtime_dependency      'pg',             '1.0.0'
-
   s.add_development_dependency  'rake-compiler',  '1.0.5'
   s.add_development_dependency  'minitest',       '5.11.3'
   s.add_development_dependency  'localhost',      '1.1.4'
+  s.add_development_dependency  'websocket',      '1.2.8'
+  s.add_development_dependency  'pg',             '1.1.3'
+  s.add_development_dependency  'redis',          '4.1.0'
+  s.add_development_dependency  'hiredis',        '0.6.3'
 end

data/test/test_coprocess.rb

@@ -1,49 +1,46 @@
 require 'minitest/autorun'
-require 'modulation'
+require 'bundler/setup'
+require 'polyphony'
 
 class CoprocessTest < MiniTest::Test
-  Core        = import('../lib/polyphony/core')
-  Coprocess   = import('../lib/polyphony/core/coprocess')
-  Exceptions  = import('../lib/polyphony/core/exceptions')
-
   def setup
     EV.rerun
   end
 
   def test_that_main_fiber_has_associated_coprocess
-    assert_equal(Fiber.current, Coprocess.current.fiber)
-    assert_equal(Coprocess.current, Fiber.current.coprocess)
+    assert_equal(Fiber.current, Polyphony::Coprocess.current.fiber)
+    assert_equal(Polyphony::Coprocess.current, Fiber.current.coprocess)
   end
 
   def test_that_new_coprocess_starts_in_suspended_state
     result = nil
-    coproc = Coprocess.new { result = 42 }
+    coproc = Polyphony::Coprocess.new { result = 42 }
     assert_nil(result)
     coproc.await
     assert_equal(42, result)
   end
 
   def test_that_new_coprocess_runs_on_different_fiber
-    coproc = Coprocess.new { Fiber.current }
+    coproc = Polyphony::Coprocess.new { Fiber.current }
     fiber = coproc.await
     assert(fiber != Fiber.current)
   end
 
   def test_that_await_blocks_until_coprocess_is_done
     result = nil
-    coproc = Coprocess.new { sleep 0.001; result = 42 }
+    coproc = Polyphony::Coprocess.new { sleep 0.001; result = 42 }
     coproc.await
     assert_equal(42, result)
   end
 
   def test_that_await_returns_the_coprocess_return_value
-    coproc = Coprocess.new { [:foo, :bar] }
+    coproc = Polyphony::Coprocess.new { [:foo, :bar] }
     assert_equal([:foo, :bar], coproc.await)
   end
 
   def test_that_await_raises_error_raised_by_coprocess
     result = nil
-    coproc = Coprocess.new { raise 'foo' }
+    coproc = Polyphony::Coprocess.new { raise 'foo' }
     begin
       result = coproc.await
     rescue => e
@@ -55,7 +52,7 @@ class CoprocessTest < MiniTest::Test
 
   def test_that_running_coprocess_can_be_cancelled
     result = []
-    coproc = Coprocess.new {
+    coproc = Polyphony::Coprocess.new {
       result << 1
       sleep 0.002
       result << 2
@@ -68,13 +65,13 @@ class CoprocessTest < MiniTest::Test
     end
     assert_equal(2, result.size)
     assert_equal(1, result[0])
-    assert_kind_of(Exceptions::Cancel, result[1])
+    assert_kind_of(Polyphony::Cancel, result[1])
   end
 
   def test_that_running_coprocess_can_be_interrupted
     # that is, stopped without exception
     result = []
-    coproc = Coprocess.new {
+    coproc = Polyphony::Coprocess.new {
       result << 1
       sleep 0.002
       result << 2
@@ -86,6 +83,82 @@ class CoprocessTest < MiniTest::Test
     assert_equal(1, result.size)
     assert_equal(42, await_result)
   end
+
+  def test_that_coprocess_can_be_awaited
+    result = nil
+    spawn do
+      coprocess = Polyphony::Coprocess.new { sleep(0.001); 42 }
+      result = coprocess.await
+    end
+    suspend
+    assert_equal(42, result)
+  end
+
+  def test_that_coprocess_can_be_stopped
+    result = nil
+    coprocess = spawn do
+      sleep(0.001)
+      result = 42
+    end
+    EV.next_tick { coprocess.interrupt }
+    suspend
+    assert_nil(result)
+  end
+
+  def test_that_coprocess_can_be_cancelled
+    result = nil
+    coprocess = spawn do
+      sleep(0.001)
+      result = 42
+    rescue Polyphony::Cancel => e
+      result = e
+    end
+    EV.next_tick { coprocess.cancel! }
+
+    suspend
+
+    assert_kind_of(Polyphony::Cancel, result)
+    assert_kind_of(Polyphony::Cancel, coprocess.result)
+    assert_nil(coprocess.running?)
+  end
+
+  def test_that_inner_coprocess_can_be_interrupted
+    result = nil
+    coprocess2 = nil
+    coprocess = spawn do
+      coprocess2 = spawn do
+        sleep(0.001)
+        result = 42
+      end
+      coprocess2.await
+      result && result += 1
+    end
+    EV.next_tick { coprocess.interrupt }
+    suspend
+    assert_nil(result)
+    assert_nil(coprocess.running?)
+    assert_nil(coprocess2.running?)
+  end
+
+  def test_that_inner_coprocess_can_interrupt_outer_coprocess
+    result, coprocess2 = nil
+    
+    coprocess = spawn do
+      coprocess2 = spawn do
+        EV.next_tick { coprocess.interrupt }
+        sleep(0.001)
+        result = 42
+      end
+      coprocess2.await
+      result && result += 1
+    end
+    
+    suspend
+    
+    assert_nil(result)
+    assert_nil(coprocess.running?)
+    assert_nil(coprocess2.running?)
+  end
 end
 
 class MailboxTest < MiniTest::Test

data/test/test_core.rb

@@ -1,274 +1,184 @@
 require 'minitest/autorun'
-require 'modulation'
+require 'bundler/setup'
+require 'polyphony'
 
-module CoreTests
-  CancelScope = import('../lib/polyphony/core/cancel_scope')
-  Core        = import('../lib/polyphony/core')
-  Coprocess   = import('../lib/polyphony/core/coprocess')
-  Exceptions  = import('../lib/polyphony/core/exceptions')
-  Supervisor  = import('../lib/polyphony/core/supervisor')
-
-  class SpawnTest < MiniTest::Test
-    def setup
-      EV.rerun
-    end
-
-    def test_that_spawn_returns_a_coprocess
-      result = nil
-      coprocess = spawn { result = 42 }
-
-      assert_kind_of(Coprocess, coprocess)
-      assert_nil(result)
-      suspend
-      assert_equal(42, result)
-    end
-
-    def test_that_spawn_accepts_coprocess_argument
-      result = nil
-      coprocess = Coprocess.new { result = 42 }
-      spawn coprocess
-
-      assert_nil(result)
-      suspend
-      assert_equal(42, result)
-    end
-
-    def test_that_spawned_coprocess_saves_result
-      coprocess = spawn { 42 }
-
-      assert_kind_of(Coprocess, coprocess)
-      assert_nil(coprocess.result)
-      suspend
-      assert_equal(42, coprocess.result)
-    end
-
-    def test_that_spawned_coprocess_can_be_interrupted
-      result = nil
-      coprocess = spawn { sleep(1); 42 }
-      EV.next_tick { coprocess.interrupt }
-      suspend
-      assert_nil(coprocess.result)
-    end
+class SpawnTest < MiniTest::Test
+  def setup
+    EV.rerun
   end
 
-  class CoprocessTest < MiniTest::Test
-    def setup
-      EV.rerun
-    end
+  def test_that_spawn_returns_a_coprocess
+    result = nil
+    coprocess = spawn { result = 42 }
 
-    def test_that_coprocess_can_be_awaited
-      result = nil
-      spawn do
-        coprocess = Coprocess.new { sleep(0.001); 42 }
-        result = coprocess.await
-      end
-      suspend
-      assert_equal(42, result)
-    end
+    assert_kind_of(Polyphony::Coprocess, coprocess)
+    assert_nil(result)
+    suspend
+    assert_equal(42, result)
+  end
 
-    def test_that_coprocess_can_be_stopped
-      result = nil
-      coprocess = spawn do
-        sleep(0.001)
-        result = 42
-      end
-      EV.next_tick { coprocess.interrupt }
-      suspend
-      assert_nil(result)
-    end
+  def test_that_spawn_accepts_coprocess_argument
+    result = nil
+    coprocess = Polyphony::Coprocess.new { result = 42 }
+    spawn coprocess
 
-    def test_that_coprocess_can_be_cancelled
-      result = nil
-      coprocess = spawn do
-        sleep(0.001)
-        result = 42
-      rescue Exceptions::Cancel => e
-        result = e
-      end
-      EV.next_tick { coprocess.cancel! }
+    assert_nil(result)
+    suspend
+    assert_equal(42, result)
+  end
 
-      suspend
+  def test_that_spawned_coprocess_saves_result
+    coprocess = spawn { 42 }
 
-      assert_kind_of(Exceptions::Cancel, result)
-      assert_kind_of(Exceptions::Cancel, coprocess.result)
-      assert_nil(coprocess.running?)
-    end
+    assert_kind_of(Polyphony::Coprocess, coprocess)
+    assert_nil(coprocess.result)
+    suspend
+    assert_equal(42, coprocess.result)
+  end
 
-    def test_that_inner_coprocess_can_be_interrupted
-      result = nil
-      coprocess2 = nil
-      coprocess = spawn do
-        coprocess2 = spawn do
-          sleep(0.001)
-          result = 42
-        end
-        coprocess2.await
-        result && result += 1
-      end
-      EV.next_tick { coprocess.interrupt }
-      suspend
-      assert_nil(result)
-      assert_nil(coprocess.running?)
-      assert_nil(coprocess2.running?)
-    end
+  def test_that_spawned_coprocess_can_be_interrupted
+    result = nil
+    coprocess = spawn { sleep(1); 42 }
+    EV.next_tick { coprocess.interrupt }
+    suspend
+    assert_nil(coprocess.result)
+  end
+end
 
-    def test_that_inner_coprocess_can_interrupt_outer_coprocess
-      result, coprocess2 = nil
-      
-      coprocess = spawn do
-        coprocess2 = spawn do
-          EV.next_tick { coprocess.interrupt }
-          sleep(0.001)
-          result = 42
-        end
-        coprocess2.await
-        result && result += 1
-      end
-      
-      suspend
-      
-      assert_nil(result)
-      assert_nil(coprocess.running?)
-      assert_nil(coprocess2.running?)
-    end
+class CancelScopeTest < Minitest::Test
+  def setup
+    EV.rerun
   end
 
-  class CancelScopeTest < Minitest::Test
-    def setup
-      EV.rerun
+  def sleep_with_cancel(ctx, mode = nil)
+    Polyphony::CancelScope.new(mode: mode).call do |c|
+      ctx[:cancel_scope] = c
+      ctx[:result] = sleep(0.01)
     end
+  end
 
-    def sleep_with_cancel(ctx, mode = nil)
-      CancelScope.new(mode: mode).call do |c|
-        ctx[:cancel_scope] = c
-        ctx[:result] = sleep(0.01)
-      end
-    end
+  def test_that_cancel_scope_cancels_coprocess
+    ctx = {}
+    spawn do
+      EV::Timer.new(0.005, 0).start { ctx[:cancel_scope]&.cancel! }
+      sleep_with_cancel(ctx, :cancel)
+    rescue Exception => e
+      ctx[:result] = e
+    end
+    assert_nil(ctx[:result])
+    # async operation will only begin on next iteration of event loop
+    assert_nil(ctx[:cancel_scope])
+    
+    suspend
+    assert_kind_of(Polyphony::CancelScope, ctx[:cancel_scope])
+    assert_kind_of(Polyphony::Cancel, ctx[:result])
+  end
 
-    def test_that_cancel_scope_cancels_coprocess
-      ctx = {}
-      spawn do
-        EV::Timer.new(0.005, 0).start { ctx[:cancel_scope]&.cancel! }
-        sleep_with_cancel(ctx, :cancel)
-      rescue Exception => e
-        ctx[:result] = e
+  # def test_that_cancel_scope_cancels_async_op_with_stop
+  #   ctx = {}
+  #   spawn do
+  #     EV::Timer.new(0, 0).start { ctx[:cancel_scope].cancel! }
+  #     sleep_with_cancel(ctx, :stop)
+  #   end
+    
+  #   suspend
+  #   assert(ctx[:cancel_scope])
+  #   assert_nil(ctx[:result])
+  # end
+
+  def test_that_cancel_after_raises_cancelled_exception
+    result = nil
+    spawn do
+      cancel_after(0.01) do
+        sleep(1000)
       end
-      assert_nil(ctx[:result])
-      # async operation will only begin on next iteration of event loop
-      assert_nil(ctx[:cancel_scope])
-      
-      suspend
-      assert_kind_of(CancelScope, ctx[:cancel_scope])
-      assert_kind_of(Exceptions::Cancel, ctx[:result])
+      result = 42
+    rescue Polyphony::Cancel
+      result = :cancelled
     end
+    suspend
+    assert_equal(:cancelled, result)
+  end
 
-    # def test_that_cancel_scope_cancels_async_op_with_stop
-    #   ctx = {}
-    #   spawn do
-    #     EV::Timer.new(0, 0).start { ctx[:cancel_scope].cancel! }
-    #     sleep_with_cancel(ctx, :stop)
-    #   end
-      
-    #   suspend
-    #   assert(ctx[:cancel_scope])
-    #   assert_nil(ctx[:result])
-    # end
-
-    def test_that_cancel_after_raises_cancelled_exception
-      result = nil
-      spawn do
-        cancel_after(0.01) do
+  def test_that_cancel_scopes_can_be_nested
+    inner_result = nil
+    outer_result = nil
+    spawn do
+      move_on_after(0.01) do
+        move_on_after(0.02) do
           sleep(1000)
         end
-        result = 42
-      rescue Exceptions::Cancel
-        result = :cancelled
+        inner_result = 42
       end
-      suspend
-      assert_equal(:cancelled, result)
+      outer_result = 42
     end
+    suspend
+    assert_nil(inner_result)
+    assert_equal(42, outer_result)
 
-    def test_that_cancel_scopes_can_be_nested
-      inner_result = nil
-      outer_result = nil
-      spawn do
-        move_on_after(0.01) do
-          move_on_after(0.02) do
-            sleep(1000)
-          end
-          inner_result = 42
-        end
-        outer_result = 42
-      end
-      suspend
-      assert_nil(inner_result)
-      assert_equal(42, outer_result)
-
-      EV.rerun
+    EV.rerun
 
-      outer_result = nil
-      spawn do
-        move_on_after(0.02) do
-          move_on_after(0.01) do
-            sleep(1000)
-          end
-          inner_result = 42
+    outer_result = nil
+    spawn do
+      move_on_after(0.02) do
+        move_on_after(0.01) do
+          sleep(1000)
         end
-        outer_result = 42
+        inner_result = 42
       end
-      suspend
-      assert_equal(42, inner_result)
-      assert_equal(42, outer_result)
+      outer_result = 42
     end
+    suspend
+    assert_equal(42, inner_result)
+    assert_equal(42, outer_result)
   end
+end
 
-  class SupervisorTest < MiniTest::Test
-    def setup
-      EV.rerun
-    end
+class SupervisorTest < MiniTest::Test
+  def setup
+    EV.rerun
+  end
 
-    def sleep_and_set(ctx, idx)
-      proc do
-        sleep(0.001 * idx)
-        ctx[idx] = true
-      end
+  def sleep_and_set(ctx, idx)
+    proc do
+      sleep(0.001 * idx)
+      ctx[idx] = true
     end
+  end
 
-    def parallel_sleep(ctx)
-      supervise do |s|
-        (1..3).each { |idx| s.spawn sleep_and_set(ctx, idx) }
-      end
-    end
-    
-    def test_that_supervisor_waits_for_all_nested_coprocesss_to_complete
-      ctx = {}
-      spawn do
-        parallel_sleep(ctx)
-      end
-      suspend
-      assert(ctx[1])
-      assert(ctx[2])
-      assert(ctx[3])
+  def parallel_sleep(ctx)
+    supervise do |s|
+      (1..3).each { |idx| s.spawn sleep_and_set(ctx, idx) }
     end
+  end
+  
+  def test_that_supervisor_waits_for_all_nested_coprocesses_to_complete
+    ctx = {}
+    spawn do
+      parallel_sleep(ctx)
+    end
+    suspend
+    assert(ctx[1])
+    assert(ctx[2])
+    assert(ctx[3])
+  end
 
-    def test_that_supervisor_can_add_coprocesss_after_having_started
-      result = []
-      spawn do
-        supervisor = Supervisor.new
-        3.times do |i|
-          spawn do
+  def test_that_supervisor_can_add_coprocesses_after_having_started
+    result = []
+    spawn {
+      supervisor = Polyphony::Supervisor.new
+      3.times do |i|
+        spawn do
+          sleep(0.001)
+          supervisor.spawn do
             sleep(0.001)
-            supervisor.spawn do
-              sleep(0.001)
-              result << i
-            end
+            result << i
           end
         end
-        supervisor.await
       end
+      supervisor.await
+    }.await
 
-      suspend
-      assert_equal([0, 1, 2], result)
-    end
+    assert_equal([0, 1, 2], result)
   end
 end