polyphony 0.19 → 0.20

data/lib/polyphony/http/server.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-export :serve, :listen, :accept_loop
+export :serve, :listen, :accept_loop, :client_loop
 
 Net   = import('../net')
-HTTP1 = import('./http1_adapter')
-HTTP2 = import('./http2_adapter')
+HTTP1 = import('./server/http1')
+HTTP2 = import('./server/http2')
 
 ALPN_PROTOCOLS = %w[h2 http/1.1].freeze
 H2_PROTOCOL = 'h2'
@@ -34,11 +34,11 @@ def accept_loop(server, opts, &handler)
 end
 
 def client_loop(client, opts, &handler)
-  client.no_delay rescue nil
+  client.no_delay if client.respond_to?(:no_delay)
   adapter = protocol_adapter(client, opts)
   adapter.each(&handler)
 ensure
-  client.close rescue nil
+  client.close
 end
 
 def protocol_adapter(socket, opts)

data/lib/polyphony/http/server/http1.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+export_default :HTTP1Adapter
+
+require 'http/parser'
+
+Request = import('./request')
+HTTP2 = import('./http2')
+Exceptions = import('../../core/exceptions')
+
+# HTTP1 protocol implementation
+class HTTP1Adapter
+  # Initializes a protocol adapter instance
+  def initialize(conn, opts)
+    @conn = conn
+    @opts = opts
+    @parser = HTTP::Parser.new(self)
+  end
+
+  def each(&block)
+    while (data = @conn.readpartial(8192))
+      return if handle_incoming_data(data, &block)
+    end
+  rescue SystemCallError, IOError
+    # ignore
+  ensure
+    finalize_client_loop
+  end
+
+  # return [Boolean] true if client loop should stop
+  def handle_incoming_data(data, &block)
+    @parser << data
+    snooze
+    while (request = @requests_head)
+      return true if upgrade_connection(request.headers, &block)
+
+      @requests_head = request.__next__
+      block.call(request)
+      return true unless request.keep_alive?
+    end
+    nil
+  end
+
+  def finalize_client_loop
+    # release references to various objects
+    @requests_head = @requests_tail = nil
+    @parser = nil
+    @conn.close
+  end
+
+  # Reads a body chunk for the current request. Transfers control to the parse
+  # loop, and resumes once the parse_loop has fired the on_body callback
+  def get_body_chunk
+    @waiting_for_body_chunk = true
+    @next_chunk = nil
+    while !@requests_tail.complete? && (data = @conn.readpartial(8192))
+      @parser << data
+      return @next_chunk if @next_chunk
+
+      snooze
+    end
+    nil
+  ensure
+    @waiting_for_body_chunk = nil
+  end
+
+  # Waits for the current request to complete. Transfers control to the parse
+  # loop, and resumes once the parse_loop has fired the on_message_complete
+  # callback
+  def consume_request
+    request = @requests_head
+    while (data = @conn.readpartial(8192))
+      @parser << data
+      return if request.complete?
+
+      snooze
+    end
+  end
+
+  def protocol
+    version = @parser.http_version
+    "HTTP #{version.join('.')}"
+  end
+
+  def on_headers_complete(headers)
+    headers[':path'] = @parser.request_url
+    headers[':method'] = @parser.http_method
+    queue_request(Request.new(headers, self))
+  end
+
+  def queue_request(request)
+    if @requests_head
+      @requests_tail.__next__ = request
+      @requests_tail = request
+    else
+      @requests_head = @requests_tail = request
+    end
+  end
+
+  def on_body(chunk)
+    if @waiting_for_body_chunk
+      @next_chunk = chunk
+      @waiting_for_body_chunk = nil
+    else
+      @requests_tail.buffer_body_chunk(chunk)
+    end
+  end
+
+  def on_message_complete
+    @waiting_for_body_chunk = nil
+    @requests_tail.complete!(@parser.keep_alive?)
+  end
+
+  # Upgrades the connection to a different protocol, if the 'Upgrade' header is
+  # given. By default the only supported upgrade protocol is HTTP2. Additional
+  # protocols, notably WebSocket, can be specified by passing a hash to the
+  # :upgrade option when starting a server:
+  #
+  #     opts = {
+  #       upgrade: {
+  #         websocket: Polyphony::Websocket.handler(&method(:ws_handler))
+  #       }
+  #     }
+  #     Polyphony::HTTP::Server.serve('0.0.0.0', 1234, opts) { |req| ... }
+  #
+  # @param headers [Hash] request headers
+  # @return [boolean] truthy if the connection has been upgraded
+  def upgrade_connection(headers, &block)
+    upgrade_protocol = headers['Upgrade']
+    return nil unless upgrade_protocol
+
+    upgrade_protocol = upgrade_protocol.downcase.to_sym
+    upgrade_handler = @opts[:upgrade] && @opts[:upgrade][upgrade_protocol]
+    return upgrade_with_handler(upgrade_handler, headers) if upgrade_handler
+    return upgrade_to_http2(headers, &block) if upgrade_protocol == :h2c
+
+    nil
+  end
+
+  def upgrade_with_handler(handler, headers)
+    @parser = @requests_head = @requests_tail = nil
+    handler.(@conn, headers)
+    true
+  end
+
+  def upgrade_to_http2(headers, &block)
+    @parser = @requests_head = @requests_tail = nil
+    HTTP2.upgrade_each(@conn, @opts, http2_upgraded_headers(headers), &block)
+    true
+  end
+
+  # Returns headers for HTTP2 upgrade
+  # @param headers [Hash] request headers
+  # @return [Hash] headers for HTTP2 upgrade
+  def http2_upgraded_headers(headers)
+    headers.merge(
+      ':scheme'    => 'http',
+      ':authority' => headers['Host']
+    )
+  end
+
+  # response API
+
+  # Sends response including headers and body. Waits for the request to complete
+  # if not yet completed. The body is sent using chunked transfer encoding.
+  # @param body [String] response body
+  # @param headers
+  def respond(body, headers)
+    consume_request if @parsing
+    data = format_headers(headers, body)
+    if body
+      data << if @parser.http_minor == 0
+                body
+              else
+                "#{body.bytesize.to_s(16)}\r\n#{body}\r\n0\r\n\r\n"
+              end
+    end
+    @conn << data
+  end
+
+  DEFAULT_HEADERS_OPTS = {
+    empty_response:  false,
+    consume_request: true
+  }.freeze
+
+  # Sends response headers. If empty_response is truthy, the response status
+  # code will default to 204, otherwise to 200.
+  # @param headers [Hash] response headers
+  # @param empty_response [boolean] whether a response body will be sent
+  # @return [void]
+  def send_headers(headers, opts = DEFAULT_HEADERS_OPTS)
+    @conn << format_headers(headers, !opts[:empty_response])
+  end
+
+  # Sends a response body chunk. If no headers were sent, default headers are
+  # sent using #send_headers. if the done option is true(thy), an empty chunk
+  # will be sent to signal response completion to the client.
+  # @param chunk [String] response body chunk
+  # @param done [boolean] whether the response is completed
+  # @return [void]
+  def send_chunk(chunk, done: false)
+    data = +"#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n"
+    data << "0\r\n\r\n" if done
+    @conn << data
+  end
+
+  # Finishes the response to the current request. If no headers were sent,
+  # default headers are sent using #send_headers.
+  # @return [void]
+  def finish
+    @conn << "0\r\n\r\n"
+  end
+
+  def close
+    @conn.close
+  end
+
+  private
+
+  # Formats response headers. If empty_response is true(thy), the response
+  # status code will default to 204, otherwise to 200.
+  # @param headers [Hash] response headers
+  # @param empty_response [boolean] whether a response body will be sent
+  # @return [String] formatted response headers
+  def format_headers(headers, body)
+    status = headers[':status'] || (body ? 200 : 204)
+    data = format_status_line(body, status)
+
+    headers.each do |k, v|
+      next if k =~ /^:/
+
+      format_header_lines(k, v)
+    end
+    data << "\r\n"
+  end
+
+  def format_header_lines(key, value)
+    if value.is_a?(Array)
+      value.each { |item| data << "#{key}: #{item}\r\n" }
+    else
+      data << "#{key}: #{value}\r\n"
+    end
+  end
+
+  def format_status_line(body, status)
+    if !body
+      empty_status_line(status)
+    else
+      with_body_status_line(status, body)
+    end
+  end
+
+  def empty_status_line(status)
+    if status == 204
+      +"HTTP/1.1 #{status}\r\n"
+    else
+      +"HTTP/1.1 #{status}\r\nContent-Length: 0\r\n"
+    end
+  end
+
+  def with_body_status_line(status, body)
+    if @parser.http_minor == 0
+      +"HTTP/1.0 #{status}\r\nContent-Length: #{body.bytesize}\r\n"
+    else
+      +"HTTP/1.1 #{status}\r\nTransfer-Encoding: chunked\r\n"
+    end
+  end
+end

data/lib/polyphony/http/server/http2.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+export_default :Protocol
+
+require 'http/2'
+
+Stream = import './http2_stream'
+
+# HTTP2 API
+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
+    @upgrade_headers = upgrade_headers
+
+    @interface = ::HTTP2::Server.new
+    @interface.on(:frame) { |bytes| @conn << bytes }
+  end
+
+  # request API
+
+  UPGRADE_MESSAGE = <<~HTTP.gsub("\n", "\r\n")
+    HTTP/1.1 101 Switching Protocols
+    Connection: Upgrade
+    Upgrade: h2c
+
+  HTTP
+
+  def upgrade
+    @conn << UPGRADE_MESSAGE
+    settings = @upgrade_headers['HTTP2-Settings']
+    @interface.upgrade(settings, @upgrade_headers, '')
+  ensure
+    @upgrade_headers = nil
+  end
+
+  # Iterates over incoming requests
+  def each(&block)
+    @interface.on(:stream) { |stream| Stream.new(stream, &block) }
+    upgrade if @upgrade_headers
+
+    while (data = @conn.readpartial(8192))
+      @interface << data
+      snooze
+    end
+  rescue SystemCallError, IOError
+    # ignore
+  ensure
+    # release references to various objects
+    @interface = nil
+    @conn.close
+  end
+
+  def close
+    @conn.close
+  end
+end

data/lib/polyphony/http/server/http2_stream.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+export_default :StreamHandler
+
+require 'http/2'
+
+Request = import './request'
+
+# Manages an HTTP 2 stream
+class StreamHandler
+  attr_accessor :__next__
+
+  def initialize(stream, &block)
+    @stream = stream
+    @stream_fiber = Fiber.new(&block)
+
+    # stream callbacks occur on connection fiber
+    stream.on(:headers, &method(:on_headers))
+    stream.on(:data, &method(:on_data))
+    stream.on(:half_close, &method(:on_half_close))
+  end
+
+  def on_headers(headers)
+    @request = Request.new(headers.to_h, self)
+    @stream_fiber.transfer(@request)
+  end
+
+  def on_data(data)
+    if @waiting_for_body_chunk
+      @waiting_for_body_chunk = nil
+      @stream_fiber.transfer(data)
+    else
+      @request.buffer_body_chunk(data)
+    end
+  end
+
+  def on_half_close
+    if @waiting_for_body_chunk
+      @waiting_for_body_chunk = nil
+      @stream_fiber.transfer(nil)
+    elsif @waiting_for_half_close
+      @waiting_for_half_close = nil
+      @stream_fiber.transfer(nil)
+    else
+      @request.complete!
+    end
+  end
+
+  def protocol
+    'h2'
+  end
+
+  def get_body_chunk
+    # called in the context of the stream fiber
+    return nil if @request.complete?
+
+    @waiting_for_body_chunk = true
+    # the chunk (or an exception) will be returned once the stream fiber is
+    # resumed
+    suspend
+  ensure
+    @waiting_for_body_chunk = nil
+  end
+
+  # Wait for request to finish
+  def consume_request
+    return if @request.complete?
+
+    @waiting_for_half_close = true
+    suspend
+  ensure
+    @waiting_for_half_close = nil
+  end
+
+  # response API
+  def respond(chunk, headers)
+    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
+
+    headers[':status'] ||= (empty_response ? 204 : 200).to_s
+    @stream.headers(headers, end_stream: false)
+    @headers_sent = true
+  end
+
+  def send_chunk(chunk, done: false)
+    send_headers({}, false) unless @headers_sent
+    @stream.data(chunk, end_stream: done)
+  end
+
+  def finish
+    if @headers_sent
+      @stream.close
+    else
+      headers[':status'] ||= '204'
+      @stream.headers(headers, end_stream: true)
+    end
+  end
+end