polyphony 0.13 → 0.14

data/lib/polyphony/extensions/postgres.rb

@@ -56,9 +56,10 @@ class ::PG::Connection
   alias_method :orig_async_exec, :async_exec
   def async_exec(*args, &block)
     send_query(*args)
-    result = get_result(&block)
+    get_result(&block)
+  ensure
+    # cleanup result in order to allow next query
     while get_result; end
-    result
   end
 
   def block(timeout = 0)

data/lib/polyphony/extensions/redis.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-export :Connection
+export :Driver
 
 require "redis"
 require "hiredis/reader"

data/lib/polyphony/extensions/socket.rb

@@ -5,9 +5,11 @@ require 'socket'
 import('./io')
 
 class ::Socket
+  NO_EXCEPTION = { exception: false }.freeze
+
   def accept
     loop do
-      result, client_addr = accept_nonblock(::IO::NO_EXCEPTION)
+      result, client_addr = accept_nonblock(NO_EXCEPTION)
       case result
       when Socket         then return result
       when :wait_readable then read_watcher.await
@@ -21,7 +23,7 @@ class ::Socket
 
   def connect(remotesockaddr)
     loop do
-      result = connect_nonblock(remotesockaddr, ::IO::NO_EXCEPTION)
+      result = connect_nonblock(remotesockaddr, NO_EXCEPTION)
       case result
       when 0              then return
       when :wait_writable then write_watcher.await
@@ -35,7 +37,7 @@ class ::Socket
   def recvfrom(maxlen, flags = 0)
     @read_buffer ||= +''
     loop do
-      result = recvfrom_nonblock(maxlen, flags, @read_buffer, ::IO::NO_EXCEPTION)
+      result = recvfrom_nonblock(maxlen, flags, @read_buffer, NO_EXCEPTION)
       case result
       when nil            then raise IOError
       when :wait_readable then read_watcher.await
@@ -69,9 +71,11 @@ class ::Socket
 end
 
 class ::TCPServer
+  NO_EXCEPTION = { exception: false }.freeze
+
   def accept
     loop do
-      result, client_addr = accept_nonblock(::IO::NO_EXCEPTION)
+      result, client_addr = accept_nonblock(NO_EXCEPTION)
       case result
       when TCPSocket         then return result
       when :wait_readable then read_watcher.await

data/lib/polyphony/extensions/ssl.rb

@@ -5,60 +5,6 @@ require 'openssl'
 import('./socket')
 
 class ::OpenSSL::SSL::SSLSocket
-  def accept
-    loop do
-      result = accept_nonblock(::IO::NO_EXCEPTION)
-      case result
-      when :wait_readable then io.read_watcher.await
-      when :wait_writable then io.write_watcher.await
-      else                     return true
-      end
-    end
-  ensure
-    io.stop_watchers
-  end
-
-  def connect
-    loop do
-      result = connect_nonblock(::IO::NO_EXCEPTION)
-      case result
-      when :wait_readable then io.read_watcher.await
-      when :wait_writable then io.write_watcher.await
-      else                     return true
-      end
-    end
-  ensure
-    io.stop_watchers
-  end
-
-  def read(max = 8192)
-    @read_buffer ||= +''
-    loop do
-      result = read_nonblock(max, @read_buffer, ::IO::NO_EXCEPTION)
-      case result
-      when nil            then raise ::IOError
-      when :wait_readable then io.read_watcher.await
-      else                return result
-      end
-    end
-  ensure
-    io.stop_watchers
-  end
-
-  def write(data)
-    loop do
-      result = write_nonblock(data, ::IO::NO_EXCEPTION)
-      case result
-      when nil            then raise ::IOError
-      when :wait_writable then io.write_watcher.await
-      else
-        (result == data.bytesize) ? (return result) : (data = data[result..-1])
-      end
-    end
-  ensure
-    io.stop_watchers
-  end
-
   def dont_linger
     io.dont_linger
   end

data/lib/polyphony/http/agent.rb

@@ -47,8 +47,6 @@ class Agent
     request(url, method: :POST, query: query)
   end
 
-  S_LOCATION = 'Location'
-
   OPTS_DEFAULT = {}.freeze
 
   def request(url, opts = OPTS_DEFAULT)
@@ -57,7 +55,7 @@ class Agent
 
     case response[:status_code]
     when 301, 302
-      request(response[:headers][S_LOCATION])
+      request(response[:headers]['Location'])
     when 200, 204
       response.extend(ResponseMixin)
     else
@@ -99,10 +97,8 @@ class Agent
     end
   end
 
-  S_H2 = 'h2'
-
   def protocol_method(socket, ctx)
-    if socket.is_a?(::OpenSSL::SSL::SSLSocket) && (socket.alpn_protocol == S_H2)
+    if socket.is_a?(::OpenSSL::SSL::SSLSocket) && (socket.alpn_protocol == 'h2')
       :do_http2
     else
       :do_http1
@@ -195,15 +191,13 @@ class Agent
     }
   end
 
-  S_HTTP = 'http'
-  S_HTTPS = 'https'
   SECURE_OPTS = { secure: true, alpn_protocols: ['h2', 'http/1.1'] }
 
   def connect(key)
     case key[:scheme]
-    when S_HTTP
+    when 'http'
       Polyphony::Net.tcp_connect(key[:host], key[:port])
-    when S_HTTPS
+    when 'https'
       Polyphony::Net.tcp_connect(key[:host], key[:port], SECURE_OPTS).tap do |socket|
         socket.post_connection_check(key[:host])
       end

data/lib/polyphony/http/http1.rb

@@ -26,12 +26,13 @@ end
 # @param socket [Net::Socket] socket
 # @param handler [Proc] request handler
 # @return [void]
-def run(socket, handler)
-  ctx = connection_context(socket, handler)
+def run(socket, opts, handler)
+  ctx = connection_context(socket, opts, handler)
   ctx[:parser].on_body = proc { |chunk| handle_body_chunk(ctx, chunk) }
 
   loop do
-    data = socket.read
+    data = socket.readpartial(8192)
+    break unless data
     if ctx[:parser].parse(data)
       break unless handle_request(ctx)
       EV.snooze
@@ -48,15 +49,15 @@ end
 # @param socket [Net::Socket] socket
 # @param handler [Proc] request handler
 # @return [Hash]
-def connection_context(socket, handler)
+def connection_context(socket, opts, handler)
   {
     can_upgrade:  true,
+    upgrade:      opts[:upgrade],
     count:        0,
     socket:       socket,
     handler:      handler,
     parser:       Http::Parser.new.async!,
-    body:         nil,
-    request:      Request.new
+    body:         nil
   }
 end
 
@@ -77,8 +78,8 @@ def handle_request(ctx)
 
   # allow upgrading the connection only on first request
   ctx[:can_upgrade] = false
-  ctx[:request].setup(ctx[:socket], ctx[:parser], ctx[:body])
-  ctx[:handler].(ctx[:request])
+  request = Request.new(ctx[:socket], ctx[:parser], ctx[:body])
+  ctx[:handler].(request)
   
   if ctx[:parser].keep_alive?
     ctx[:body] = nil
@@ -88,24 +89,23 @@ def handle_request(ctx)
   end
 end
 
-S_EMPTY           = ''
-S_UPGRADE         = 'Upgrade'
-S_H2C             = 'h2c'
-S_SCHEME          = ':scheme'
-S_METHOD          = ':method'
-S_AUTHORITY       = ':authority'
-S_PATH            = ':path'
-S_HTTP            = 'http'
-S_HOST            = 'Host'
-
-# Upgrades an HTTP 1 connection to HTTP 2 on client request
+# Upgrades an HTTP 1 connection to HTTP/2 or other protocol on client request
 # @param ctx [Hash] connection context
 # @return [Boolean] true if connection was upgraded
 def upgrade_connection(ctx)
-  return false unless ctx[:parser].headers[S_UPGRADE] == S_H2C
+  upgrade_protocol = ctx[:parser].headers['Upgrade']
+  return false unless upgrade_protocol
 
+  if ctx[:upgrade] && ctx[:upgrade][upgrade_protocol.to_sym]
+    ctx[:upgrade][upgrade_protocol.to_sym].(ctx[:socket], ctx[:parser].headers)
+    return true
+  end
+
+  return false unless upgrade_protocol == 'h2c'
+  
+  # upgrade to HTTP/2
   request = http2_upgraded_request(ctx)
-  body = ctx[:body] || S_EMPTY
+  body = ctx[:body] || ''
   HTTP2.upgrade(ctx[:socket], ctx[:handler], request, body)
   true
 end
@@ -116,9 +116,9 @@ end
 def http2_upgraded_request(ctx)
   headers = ctx[:parser].headers
   headers.merge(
-    S_SCHEME    => S_HTTP,
-    S_METHOD    => ctx[:parser].http_method,
-    S_AUTHORITY => headers[S_HOST],
-    S_PATH      => ctx[:parser].request_url
+    ':scheme'     => 'http',
+    ':method'     => ctx[:parser].http_method,
+    ':authority'  => headers['Host'],
+    ':path'       => ctx[:parser].request_url
   )
 end

data/lib/polyphony/http/http1_request.rb

@@ -5,35 +5,34 @@ export_default :Request
 require 'uri'
 
 class Request
-  def setup(conn, parser, body)
+  def initialize(conn, parser, body)
     @conn         = conn
-    @parser = parser
+    @parser       = parser
     @method       = parser.http_method
     @request_url  = parser.request_url
     @body         = body
   end
 
+  def http_version
+    1
+  end
+
   def method
     @method ||= @parser.http_method
   end
 
-  S_EMPTY     = ''
-
   def path
-    @uri ||= URI.parse(@parser.request_url || S_EMPTY)
+    @uri ||= URI.parse(@parser.request_url || '')
     @path ||= @uri.path
   end
 
-  S_AMPERSAND = '&'
-  S_EQUAL     = '='
-  
   def query
-    @uri ||= URI.parse(@parser.request_url || S_EMPTY)
+    @uri ||= URI.parse(@parser.request_url || '')
     return @query if @query
   
-    if (q = u.query)
-      @query = q.split(S_AMPERSAND).each_with_object({}) do |kv, h|
-        k, v = kv.split(S_EQUAL)
+    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)
       end
     else
@@ -45,27 +44,40 @@ class Request
     @headers ||= @parser.headers
   end
 
-  S_CONTENT_LENGTH  = 'Content-Length'
-  S_STATUS          = ':status'
-  EMPTY_LINE = "\r\n"
+  EMPTY_HASH = {}
+
+  def respond(chunk, headers = EMPTY_HASH)
+    status = headers.delete(':status') || 200
+    data = format_head(headers)
+    if chunk
+      data << "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n0\r\n\r\n"
+    end
+    @conn << data
+  end
 
-  def respond(body, headers = {})
-    status = headers.delete(S_STATUS) || 200
-    data = +"HTTP/1.1 #{status}\r\n"
-    headers[S_CONTENT_LENGTH] = body.bytesize if body
+  def format_head(headers)
+    status = headers[':status'] || 200
+    data = +"HTTP/1.1 #{status}\r\nTransfer-Encoding: chunked\r\n"
     headers.each do |k, v|
+      next if k =~ /^:/
       if v.is_a?(Array)
-        v.each { |vv| data << "#{k}: #{vv}\r\n" }
+        v.each { |o| data << "#{k}: #{o}\r\n" }
       else
         data << "#{k}: #{v}\r\n"
       end
     end
-    if body
-      data << "\r\n#{body}"
-    else
-      data << EMPTY_LINE
-    end
+    data << "\r\n"
+  end
 
-    @conn << data
+  def write_head(headers = EMPTY_HASH)
+    @conn << format_head(headers)
+  end
+
+  def write(chunk)
+    data = +"#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n"
+  end
+
+  def finish
+    @conn << "0\r\n\r\n"
   end
 end

data/lib/polyphony/http/http2.rb

@@ -6,8 +6,6 @@ require 'http/2'
 
 Request = import('./http2_request')
 
-S_HTTP2_SETTINGS  = 'HTTP2-Settings'
-
 UPGRADE_MESSAGE = <<~HTTP.gsub("\n", "\r\n")
   HTTP/1.1 101 Switching Protocols
   Connection: Upgrade
@@ -17,7 +15,7 @@ HTTP
 
 def upgrade(socket, handler, request, body)
   interface = prepare(socket, handler)
-  settings = request[S_HTTP2_SETTINGS]
+  settings = request['HTTP2-Settings']
   socket.write(UPGRADE_MESSAGE)
   interface.upgrade(settings, request, body)
   client_loop(socket, interface)
@@ -30,14 +28,15 @@ def prepare(socket, handler)
   end
 end
 
-def run(socket, handler)
+def run(socket, opts, handler)
   interface = prepare(socket, handler)
   client_loop(socket, interface)
 end
 
 def client_loop(socket, interface)
   loop do
-    data = socket.read
+    data = socket.readpartial(8192)
+    break unless data
     interface << data
     EV.snooze
   end

data/lib/polyphony/http/http2_request.rb

@@ -9,6 +9,10 @@ class Request
     @stream = stream
   end
 
+  def http_version
+    2
+  end
+
   def set_headers(headers)
     @headers = Hash[*headers.flatten]
   end
@@ -21,33 +25,26 @@ class Request
     end
   end
 
-  S_METHOD = ':method'
-
   def method
-    @method ||= @headers[S_METHOD]
+    @method ||= @headers[':method']
   end
 
   def scheme
     @scheme ||= @headers[':scheme']
   end
 
-  S_EMPTY     = ''
-
   def path
-    @uri ||= URI.parse(@headers[':path'] || S_EMPTY)
+    @uri ||= URI.parse(@headers[':path'] || '')
     @path ||= @uri.path
   end
 
-  S_AMPERSAND = '&'
-  S_EQUAL     = '='
-  
   def query
-    @uri ||= URI.parse(@headers[':path'] || S_EMPTY)
+    @uri ||= URI.parse(@headers[':path'] || '')
     return @query if @query
   
     if (q = u.query)
-      @query = q.split(S_AMPERSAND).each_with_object({}) do |kv, h|
-        k, v = kv.split(S_EQUAL)
+      @query = q.split('&').each_with_object({}) do |kv, h|
+        k, v = kv.split('=')
         h[k.to_sym] = URI.decode_www_form_component(v)
       end
     else
@@ -55,13 +52,10 @@ class Request
     end
   end
 
-  S_CONTENT_LENGTH = 'Content-Length'
-  S_STATUS = ':status'
-  S_STATUS_200 = '200'
-  EMPTY_LINE = "\r\n"
+  EMPTY_HASH = {}
 
-  def respond(body, headers = {})
-    headers[S_STATUS] ||= S_STATUS_200
+  def respond(body, headers = EMPTY_HASH)
+    headers[':status'] ||= '200'
 
     @stream.headers(headers, end_stream: false)
     @stream.data(body, end_stream: true)