polyphony 0.13 → 0.14

data/lib/polyphony/http/rack.rb

@@ -18,10 +18,8 @@ def env(request)
   { }
 end
 
-S_STATUS = ':status'
-
 def respond(request, (status_code, headers, body))
-  headers[S_STATUS] = status_code.to_s
+  headers[':status'] = status_code.to_s
   body = body.first
   request.respond(body, headers)
 end

data/lib/polyphony/http/server.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-export :serve, :listen
+export :serve, :listener
 
 Net   = import('../net')
 HTTP1 = import('./http1')
@@ -13,27 +13,27 @@ async def serve(host, port, opts = {}, &handler)
   opts[:alpn_protocols] = ALPN_PROTOCOLS
   server = Net.tcp_listen(host, port, opts)
 
-  accept_loop(server, handler)
+  accept_loop(server, opts, handler)
 end
 
-def listen(host, port, opts = {}, &handler)
+def listener(host, port, opts = {}, &handler)
   opts[:alpn_protocols] = ALPN_PROTOCOLS
   server = Net.tcp_listen(host, port, opts)
-  proc { accept_loop(server, handler) }
+  proc { accept_loop(server, opts, handler) }
 end
 
-def accept_loop(server, handler)
+def accept_loop(server, opts, handler)
   while true
     client = server.accept
-    spawn client_task(client, handler)
+    spawn client_task(client, opts, handler)
   end
 rescue OpenSSL::SSL::SSLError
   retry # disregard
 end
 
-async def client_task(client, handler)
-  client.no_delay
-  protocol_module(client).run(client, handler)
+async def client_task(client, opts, handler)
+  client.no_delay rescue nil
+  protocol_module(client).run(client, opts, handler)
 end
 
 def protocol_module(socket)

data/lib/polyphony/net.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 export  :tcp_connect,
-        :tcp_listen,
-        :getaddrinfo
+        :tcp_listen#,
+        # :getaddrinfo
 
 import('./extensions/socket')
 import('./extensions/ssl')

data/lib/polyphony/resource_pool.rb

@@ -22,7 +22,7 @@ class ResourcePool
     yield resource
   ensure
     @available << resource if resource
-    dequeue
+    dequeue unless @waiting.empty?
   end
 
   def wait
@@ -43,6 +43,10 @@ class ResourcePool
     @available.shift || (@count < @limit && allocate)
   end
 
+  def method_missing(sym, *args, &block)
+    acquire { |r| r.send(sym, *args, &block) }
+  end
+
   # Allocates a resource
   # @return [any] allocated resource
   def allocate

data/lib/polyphony/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polyphony
-  VERSION = '0.13'
+  VERSION = '0.14'
 end

data/lib/polyphony/websocket.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+export :handler
+
+require 'digest/sha1'
+require 'websocket'
+
+class WebsocketConnection
+  def initialize(client, headers)
+    @client = client
+    @headers = headers    
+    setup(headers)
+  end
+
+  S_WS_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+  UPGRADE_RESPONSE = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: %s\r\n\r\n"
+
+  def setup(headers)
+    key = headers['Sec-WebSocket-Key']
+    @version = headers['Sec-WebSocket-Version'].to_i
+    accept = Digest::SHA1.base64digest([key, S_WS_GUID].join)
+    @client << UPGRADE_RESPONSE % accept
+
+    @reader = ::WebSocket::Frame::Incoming::Server.new(version: @version)
+  end
+
+  def recv
+    while true
+      data = @client.readpartial(8192)
+      break nil unless data
+
+      @reader << data
+      if msg = @reader.next
+        break msg.to_s
+      end
+    end
+  end
+
+  def send(data)
+    frame = ::WebSocket::Frame::Outgoing::Server.new(
+      version: @version, data: data, type: :text
+    )
+    @client << frame.to_s
+  end
+  alias_method :<<, :send
+end
+
+def handler(&block)
+  proc { |client, header|
+    block.(WebsocketConnection.new(client, header))
+  }
+end

data/polyphony.gemspec

@@ -0,0 +1,31 @@
+require_relative './lib/polyphony/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'polyphony'
+  s.version     = Polyphony::VERSION
+  s.licenses    = ['MIT']
+  s.summary     = 'Polyphony: Fiber-based Concurrency for Ruby'
+  s.author      = 'Sharon Rosner'
+  s.email       = 'ciconia@gmail.com'
+  s.files       = `git ls-files`.split
+  s.homepage    = 'http://github.com/digital-fabric/polyphony'
+  s.metadata    = {
+    "source_code_uri" => "https://github.com/digital-fabric/polyphony"
+  }
+  s.rdoc_options = ["--title", "polyphony", "--main", "README.md"]
+  s.extra_rdoc_files = ["README.md"]
+  s.extensions = ["ext/ev/extconf.rb"]
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency      'modulation',     '0.23'
+  
+  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'
+end

data/test/test_coprocess.rb

@@ -0,0 +1,131 @@
+require 'minitest/autorun'
+require 'modulation'
+
+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)
+  end
+
+  def test_that_new_coprocess_starts_in_suspended_state
+    result = nil
+    coproc = 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 }
+    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.await
+    assert_equal(42, result)
+  end
+
+  def test_that_await_returns_the_coprocess_return_value
+    coproc = 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' }
+    begin
+      result = coproc.await
+    rescue => e
+      result = { error: e }
+    end
+    assert_kind_of(Hash, result)
+    assert_kind_of(RuntimeError, result[:error])
+  end
+
+  def test_that_running_coprocess_can_be_cancelled
+    result = []
+    coproc = Coprocess.new {
+      result << 1
+      sleep 0.002
+      result << 2
+    }
+    EV::Timer.new(0.001, 0).start { coproc.cancel! }
+    begin
+      coproc.await
+    rescue Exception => e
+      result << e
+    end
+    assert_equal(2, result.size)
+    assert_equal(1, result[0])
+    assert_kind_of(Exceptions::Cancel, result[1])
+  end
+
+  def test_that_running_coprocess_can_be_interrupted
+    # that is, stopped without exception
+    result = []
+    coproc = Coprocess.new {
+      result << 1
+      sleep 0.002
+      result << 2
+      3
+    }
+    EV::Timer.new(0.001, 0).start { coproc.stop(42) }
+
+    await_result = coproc.await
+    assert_equal(1, result.size)
+    assert_equal(42, await_result)
+  end
+end
+
+class MailboxTest < MiniTest::Test
+  def setup
+    EV.rerun
+  end
+
+  def test_that_coprocess_can_receive_messages
+    msgs = []
+    coproc = spawn {
+      loop {
+        msgs << receive
+      }
+    }
+
+    EV.snooze # allow coproc to start
+    
+    3.times { |i| coproc << i; EV.snooze }
+
+    assert_equal([0, 1, 2], msgs)
+  ensure
+    coproc.stop
+  end
+
+  def test_that_multiple_messages_sent_at_once_arrive
+    msgs = []
+    coproc = spawn {
+      loop { 
+        msgs << receive
+      }
+    }
+
+    EV.snooze # allow coproc to start
+    
+    3.times { |i| coproc << i }
+
+    EV.snooze
+
+    assert_equal([0, 1, 2], msgs)
+  ensure
+    coproc.stop
+  end
+end

data/test/test_core.rb

@@ -0,0 +1,274 @@
+require 'minitest/autorun'
+require 'modulation'
+
+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
+  end
+
+  class CoprocessTest < MiniTest::Test
+    def setup
+      EV.rerun
+    end
+
+    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
+
+    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 Exceptions::Cancel => e
+        result = e
+      end
+      EV.next_tick { coprocess.cancel! }
+
+      suspend
+
+      assert_kind_of(Exceptions::Cancel, result)
+      assert_kind_of(Exceptions::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 CancelScopeTest < Minitest::Test
+    def setup
+      EV.rerun
+    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(CancelScope, ctx[:cancel_scope])
+      assert_kind_of(Exceptions::Cancel, ctx[: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
+          sleep(1000)
+        end
+        result = 42
+      rescue Exceptions::Cancel
+        result = :cancelled
+      end
+      suspend
+      assert_equal(:cancelled, result)
+    end
+
+    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
+
+      outer_result = nil
+      spawn do
+        move_on_after(0.02) do
+          move_on_after(0.01) do
+            sleep(1000)
+          end
+          inner_result = 42
+        end
+        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
+
+    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])
+    end
+
+    def test_that_supervisor_can_add_coprocesss_after_having_started
+      result = []
+      spawn do
+        supervisor = Supervisor.new
+        3.times do |i|
+          spawn do
+            sleep(0.001)
+            supervisor.spawn do
+              sleep(0.001)
+              result << i
+            end
+          end
+        end
+        supervisor.await
+      end
+
+      suspend
+      assert_equal([0, 1, 2], result)
+    end
+  end
+end