polyphony 0.17 → 0.19

data/lib/polyphony/http/http2_adapter.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+export_default :Protocol
+
+require 'http/2'
+
+Request = import('./request')
+
+class StreamWrapper
+  def initialize(stream, parse_fiber)
+    @stream = stream
+    @parse_fiber = parse_fiber
+    @parsing = true
+
+    stream.on(:data) { |data| on_body(data) }
+    stream.on(:half_close) { on_message_complete }
+  end
+
+  # Reads body chunk from connection
+  def get_body_chunk
+    @calling_fiber = Fiber.current
+    @read_body = true
+    @parse_fiber.safe_transfer
+  end
+
+  # Wait for request to finish
+  def consume_request
+    return unless @parsing
+
+    @calling_fiber = Fiber.current
+    @read_body = false
+    @parse_fiber.safe_transfer while @parsing
+  end
+
+  def on_body(data)
+    @calling_fiber.transfer(data) if @read_body
+  end
+
+  def on_message_complete
+    @parsing = false
+    @calling_fiber.transfer nil
+  end
+
+  # response API
+  def respond(chunk, headers)
+    consume_request if @parsing
+
+    headers[':status'] ||= '200'
+    @stream.headers(headers, end_stream: false)
+    @stream.data(chunk, end_stream: true)
+    @headers_sent = true
+  end
+
+  def send_headers(headers, empty_response = false)
+    return if @headers_sent
+
+    consume_request if @parsing
+
+    headers[':status'] ||= (empty_response ? 204 : 200).to_s
+    @stream.headers(headers, end_stream: false)
+    @headers_sent = true
+  end
+
+  def send_body_chunk(chunk, done: false)
+    send_headers({}, false) unless @headers_sent
+    @stream.data(chunk, end_stream: done)
+  end
+  
+  def finish
+    consume_request if @parsing
+
+    unless @headers_sent
+      headers[':status'] ||= '204'
+      @stream.headers(headers, end_stream: true)
+    else
+      @stream.close
+    end
+  end
+end
+
+class Protocol
+  def self.upgrade_each(socket, opts, headers, &block)
+    adapter = new(socket, opts, headers)
+    adapter.each(&block)
+  end
+
+  def initialize(conn, opts, upgrade_headers = nil)
+    @conn = conn  
+    @opts = opts
+
+    @interface = ::HTTP2::Server.new
+    @interface.on(:frame) { |bytes| conn << bytes }
+    @interface.on(:stream) { |stream| start_stream(stream) }
+    @parse_fiber = Fiber.new { parse_loop(upgrade_headers) }
+  end
+
+  def start_stream(stream)
+    stream.on(:headers) do |headers|
+      @calling_fiber.transfer([stream, headers.to_h])
+    end
+  end
+
+  def protocol
+    'h2'
+  end
+
+  def parse_loop(upgrade_headers)
+    upgrade(upgrade_headers) if upgrade_headers
+      
+    while (data = @conn.readpartial(8192))
+      @interface << data
+      snooze
+    end
+    @calling_fiber.transfer nil
+  rescue SystemCallError, IOError
+    # ignore
+    @calling_fiber.transfer nil
+  rescue => error
+    # an error return value will be raised by the receiving fiber
+    @calling_fiber.transfer error
+  end
+
+  # request API
+  
+  UPGRADE_MESSAGE = <<~HTTP.gsub("\n", "\r\n")
+  HTTP/1.1 101 Switching Protocols
+  Connection: Upgrade
+  Upgrade: h2c
+
+  HTTP
+
+def upgrade(headers)
+    settings = headers['HTTP2-Settings']
+    @conn << UPGRADE_MESSAGE
+    @interface.upgrade(settings, headers, '')
+  end
+
+  # Iterates over incoming requests
+  def each(&block)
+    can_upgrade = true
+    while @parse_fiber.alive?
+      stream, headers = get_headers
+      break unless stream
+      wrapper = StreamWrapper.new(stream, @parse_fiber)
+      request = Request.new(headers, wrapper)
+      Fiber.new { block.(request) }.resume
+    end
+  ensure
+    @conn.close rescue nil
+  end
+
+  # Reads headers from connection
+  def get_headers
+    @calling_fiber = Fiber.current
+    @parse_fiber.safe_transfer
+  end
+end

data/lib/polyphony/http/{http2_request.rb → request.rb}

@@ -5,24 +5,15 @@ export_default :Request
 require 'uri'
 
 class Request
-  def initialize(stream)
-    @stream = stream
-  end
+  attr_reader :headers, :adapter
 
-  def http_version
-    2
+  def initialize(headers, adapter)
+    @headers  = headers
+    @adapter  = adapter
   end
 
-  def set_headers(headers)
-    @headers = Hash[*headers.flatten]
-  end
-
-  def add_body_chunk(chunk)
-    if @body
-      @body << chunk
-    else
-      @body = +chunk
-    end
+  def protocol
+    @adapter.protocol
   end
 
   def method
@@ -33,16 +24,19 @@ class Request
     @scheme ||= @headers[':scheme']
   end
 
-  def path
+  def uri
     @uri ||= URI.parse(@headers[':path'] || '')
-    @path ||= @uri.path
+  end
+
+  def path
+    @path ||= uri.path
   end
 
   def query
     @uri ||= URI.parse(@headers[':path'] || '')
     return @query if @query
   
-    if (q = u.query)
+    if (q = uri.query)
       @query = q.split('&').each_with_object({}) do |kv, h|
         k, v = kv.split('=')
         h[k.to_sym] = URI.decode_www_form_component(v)
@@ -54,10 +48,19 @@ class Request
 
   EMPTY_HASH = {}
 
-  def respond(body, headers = EMPTY_HASH)
-    headers[':status'] ||= '200'
+  def respond(chunk, headers = EMPTY_HASH)
+    @adapter.respond(chunk, headers)
+  end
+
+  def send_headers(headers = EMPTY_HASH, empty_response = false)
+    @adapter.send_headers(headers, empty_response)
+  end
+
+  def send_body_chunk(body, done: false)
+    @adapter.send_body_chunk(body, done: done)
+  end
 
-    @stream.headers(headers, end_stream: false)
-    @stream.data(body, end_stream: true)
+  def finish
+    @adapter.finish
   end
 end

data/lib/polyphony/http/server.rb

@@ -3,8 +3,8 @@
 export :serve, :listen, :accept_loop
 
 Net   = import('../net')
-HTTP1 = import('./http1')
-HTTP2 = import('./http2')
+HTTP1 = import('./http1_adapter')
+HTTP2 = import('./http2_adapter')
 
 ALPN_PROTOCOLS = %w[h2 http/1.1].freeze
 H2_PROTOCOL = 'h2'
@@ -17,25 +17,33 @@ end
 
 def listen(host, port, opts = {})
   opts[:alpn_protocols] = ALPN_PROTOCOLS
-  Net.tcp_listen(host, port, opts)
+  Net.tcp_listen(host, port, opts).tap do |socket|
+    socket.define_singleton_method(:each) do |&block|
+      MODULE.accept_loop(socket, opts, &block)
+    end
+  end
 end
 
 def accept_loop(server, opts, &handler)
-  while true
+  loop do
     client = server.accept
-    coproc { client_task(client, opts, &handler) }
+    spin { client_loop(client, opts, &handler) }
+  rescue OpenSSL::SSL::SSLError
+    # disregard
   end
-rescue OpenSSL::SSL::SSLError
-  retry # disregard
 end
 
-def client_task(client, opts, &handler)
+def client_loop(client, opts, &handler)
   client.no_delay rescue nil
-  protocol_module(client).(client, opts, &handler)
+  adapter = protocol_adapter(client, opts)
+  adapter.each(&handler)
+ensure
+  client.close rescue nil
 end
 
-def protocol_module(socket)
+def protocol_adapter(socket, opts)
   use_http2 = socket.respond_to?(:alpn_protocol) &&
               socket.alpn_protocol == H2_PROTOCOL
-  use_http2 ? HTTP2 : HTTP1
+  klass = use_http2 ? HTTP2 : HTTP1
+  klass.new(socket, opts)
 end

data/lib/polyphony/net.rb

@@ -12,7 +12,7 @@ def tcp_connect(host, port, opts = {})
     s.connect(addr)
   }
   if opts[:secure_context] || opts[:secure]
-    secure_socket(socket, opts[:secure_context], opts)
+    secure_socket(socket, opts[:secure_context], opts.merge(host: host))
   else
     socket
   end
@@ -36,11 +36,15 @@ def tcp_listen(host = nil, port = nil, opts = {})
 end
 
 def secure_socket(socket, context, opts)
-  if context
-    setup_alpn(context, opts[:alpn_protocols]) if opts[:alpn_protocols]
-    OpenSSL::SSL::SSLSocket.new(socket, context).tap { |s| s.connect }
-  else
-    OpenSSL::SSL::SSLSocket.new(socket).tap { |s| s.connect }
+  setup_alpn(context, opts[:alpn_protocols]) if context && opts[:alpn_protocols]
+  socket = context ?
+    OpenSSL::SSL::SSLSocket.new(socket, context) :
+    OpenSSL::SSL::SSLSocket.new(socket)
+  
+  socket.tap do |s|
+    s.hostname = opts[:host] if opts[:host]
+    s.connect
+    s.post_connection_check(opts[:host]) if opts[:host]
   end
 end
 

data/lib/polyphony/version.rb

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

data/polyphony.gemspec

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

data/test/test_coprocess.rb

@@ -86,7 +86,7 @@ class CoprocessTest < MiniTest::Test
 
   def test_that_coprocess_can_be_awaited
     result = nil
-    coproc do
+    spin do
       coprocess = Polyphony::Coprocess.new { sleep(0.001); 42 }
       result = coprocess.await
     end
@@ -96,7 +96,7 @@ class CoprocessTest < MiniTest::Test
 
   def test_that_coprocess_can_be_stopped
     result = nil
-    coprocess = coproc do
+    coprocess = spin do
       sleep(0.001)
       result = 42
     end
@@ -107,7 +107,7 @@ class CoprocessTest < MiniTest::Test
 
   def test_that_coprocess_can_be_cancelled
     result = nil
-    coprocess = coproc do
+    coprocess = spin do
       sleep(0.001)
       result = 42
     rescue Polyphony::Cancel => e
@@ -125,8 +125,8 @@ class CoprocessTest < MiniTest::Test
   def test_that_inner_coprocess_can_be_interrupted
     result = nil
     coprocess2 = nil
-    coprocess = coproc do
-      coprocess2 = coproc do
+    coprocess = spin do
+      coprocess2 = spin do
         sleep(0.001)
         result = 42
       end
@@ -143,8 +143,8 @@ class CoprocessTest < MiniTest::Test
   def test_that_inner_coprocess_can_interrupt_outer_coprocess
     result, coprocess2 = nil
     
-    coprocess = coproc do
-      coprocess2 = coproc do
+    coprocess = spin do
+      coprocess2 = spin do
         EV.next_tick { coprocess.interrupt }
         sleep(0.001)
         result = 42
@@ -168,7 +168,7 @@ class MailboxTest < MiniTest::Test
 
   def test_that_coprocess_can_receive_messages
     msgs = []
-    coprocess = coproc {
+    coprocess = spin {
       loop {
         msgs << receive
       }
@@ -185,7 +185,7 @@ class MailboxTest < MiniTest::Test
 
   def test_that_multiple_messages_sent_at_once_arrive
     msgs = []
-    coprocess = coproc {
+    coprocess = spin {
       loop { 
         msgs << receive
       }

data/test/test_core.rb

@@ -9,7 +9,7 @@ class SpawnTest < MiniTest::Test
 
   def test_that_spawn_returns_a_coprocess
     result = nil
-    coprocess = coproc { result = 42 }
+    coprocess = spin { result = 42 }
 
     assert_kind_of(Polyphony::Coprocess, coprocess)
     assert_nil(result)
@@ -20,7 +20,7 @@ class SpawnTest < MiniTest::Test
   def test_that_spawn_accepts_coprocess_argument
     result = nil
     coprocess = Polyphony::Coprocess.new { result = 42 }
-    coproc coprocess
+    spin coprocess
 
     assert_nil(result)
     suspend
@@ -28,7 +28,7 @@ class SpawnTest < MiniTest::Test
   end
 
   def test_that_spawned_coprocess_saves_result
-    coprocess = coproc { 42 }
+    coprocess = spin { 42 }
 
     assert_kind_of(Polyphony::Coprocess, coprocess)
     assert_nil(coprocess.result)
@@ -38,7 +38,7 @@ class SpawnTest < MiniTest::Test
 
   def test_that_spawned_coprocess_can_be_interrupted
     result = nil
-    coprocess = coproc { sleep(1); 42 }
+    coprocess = spin { sleep(1); 42 }
     EV.next_tick { coprocess.interrupt }
     suspend
     assert_nil(coprocess.result)
@@ -59,7 +59,7 @@ class CancelScopeTest < Minitest::Test
 
   def test_that_cancel_scope_cancels_coprocess
     ctx = {}
-    coproc do
+    spin do
       EV::Timer.new(0.005, 0).start { ctx[:cancel_scope]&.cancel! }
       sleep_with_cancel(ctx, :cancel)
     rescue Exception => e
@@ -76,7 +76,7 @@ class CancelScopeTest < Minitest::Test
 
   # def test_that_cancel_scope_cancels_async_op_with_stop
   #   ctx = {}
-  #   coproc do
+  #   spin do
   #     EV::Timer.new(0, 0).start { ctx[:cancel_scope].cancel! }
   #     sleep_with_cancel(ctx, :stop)
   #   end
@@ -88,7 +88,7 @@ class CancelScopeTest < Minitest::Test
 
   def test_that_cancel_after_raises_cancelled_exception
     result = nil
-    coproc do
+    spin do
       cancel_after(0.01) do
         sleep(1000)
       end
@@ -103,7 +103,7 @@ class CancelScopeTest < Minitest::Test
   def test_that_cancel_scopes_can_be_nested
     inner_result = nil
     outer_result = nil
-    coproc do
+    spin do
       move_on_after(0.01) do
         move_on_after(0.02) do
           sleep(1000)
@@ -119,7 +119,7 @@ class CancelScopeTest < Minitest::Test
     EV.rerun
 
     outer_result = nil
-    coproc do
+    spin do
       move_on_after(0.02) do
         move_on_after(0.01) do
           sleep(1000)
@@ -148,13 +148,13 @@ class SupervisorTest < MiniTest::Test
 
   def parallel_sleep(ctx)
     supervise do |s|
-      (1..3).each { |idx| s.spawn sleep_and_set(ctx, idx) }
+      (1..3).each { |idx| s.spin sleep_and_set(ctx, idx) }
     end
   end
   
   def test_that_supervisor_waits_for_all_nested_coprocesses_to_complete
     ctx = {}
-    coproc do
+    spin do
       parallel_sleep(ctx)
     end
     suspend
@@ -165,12 +165,12 @@ class SupervisorTest < MiniTest::Test
 
   def test_that_supervisor_can_add_coprocesses_after_having_started
     result = []
-    coproc {
+    spin {
       supervisor = Polyphony::Supervisor.new
       3.times do |i|
-        coproc do
+        spin do
           sleep(0.001)
-          supervisor.spawn do
+          supervisor.spin do
             sleep(0.001)
             result << i
           end