polyphony-http 0.24

data/lib/polyphony/http/client/site_connection_manager.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+export_default :SiteConnectionManager
+
+ResourcePool = import '../../core/resource_pool'
+HTTP1Adapter = import './http1'
+HTTP2Adapter = import './http2'
+
+# HTTP site connection pool
+class SiteConnectionManager < ResourcePool
+  def initialize(uri_key)
+    @uri_key = uri_key
+    super(limit: 4)
+  end
+
+  # def method_missing(sym, *args)
+  #   raise "Invalid method #{sym}"
+  # end
+
+  def acquire
+    Gyro.ref
+    prepare_first_connection if @size.zero?
+    super
+  ensure
+    Gyro.unref
+    # The size goes back to 0 only in case existing connections get into an
+    # error state and then get discarded
+    @state = nil if @size == 0
+  end
+
+  def prepare_first_connection
+    case @state
+    when nil
+      @state = :first_connection
+      create_first_connection
+    when :first_connection
+      @first_connection_queue << Fiber.current
+      suspend
+    end
+  end
+
+  def create_first_connection
+    @first_connection_queue = []
+    # @first_connection_queue << Fiber.current
+
+    adapter = connect
+    @state = adapter.protocol
+    send(:"setup_#{@state}_allocator", adapter)
+    dequeue_first_connection_waiters
+  end
+
+  def setup_http1_allocator(adapter)
+    @size += 1
+    adapter.extend ResourceExtensions
+    @stock << adapter
+    @allocator = proc { connect }
+  end
+
+  def setup_http2_allocator(adapter)
+    @adapter = adapter
+    @limit = 20
+    @size += 1
+    stream_adapter = adapter.allocate_stream_adapter
+    stream_adapter.extend ResourceExtensions
+    @stock << stream_adapter
+    @allocator = proc { adapter.allocate_stream_adapter }
+  end
+
+  def dequeue_first_connection_waiters
+    return unless @first_connection_queue
+
+    @first_connection_queue.each(&:schedule)
+    @first_connection_queue = nil
+  end
+
+  def connect
+    socket = create_socket
+    protocol = socket_protocol(socket)
+    case protocol
+    when :http1
+      HTTP1Adapter.new(socket)
+    when :http2
+      HTTP2Adapter.new(socket)
+    else
+      raise "Unknown protocol #{protocol.inspect}"
+    end
+  end
+
+  def socket_protocol(socket)
+    if socket.is_a?(OpenSSL::SSL::SSLSocket) && socket.alpn_protocol == 'h2'
+      :http2
+    else
+      :http1
+    end
+  end
+
+  SECURE_OPTS = { secure: true, alpn_protocols: ['h2', 'http/1.1'] }.freeze
+
+  def create_socket
+    case @uri_key[:scheme]
+    when 'http'
+      Polyphony::Net.tcp_connect(@uri_key[:host], @uri_key[:port])
+    when 'https'
+      Polyphony::Net.tcp_connect(@uri_key[:host], @uri_key[:port], SECURE_OPTS)
+    else
+      raise "Invalid scheme #{@uri_key[:scheme].inspect}"
+    end
+  end
+end

data/lib/polyphony/http/server.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+export :serve, :listen, :accept_loop, :client_loop
+
+Net   = Polyphony::Net
+HTTP1 = import('./server/http1')
+HTTP2 = import('./server/http2')
+
+ALPN_PROTOCOLS = %w[h2 http/1.1].freeze
+H2_PROTOCOL = 'h2'
+
+def serve(host, port, opts = {}, &handler)
+  opts[:alpn_protocols] = ALPN_PROTOCOLS
+  server = Net.tcp_listen(host, port, opts)
+  accept_loop(server, opts, &handler)
+end
+
+def listen(host, port, opts = {})
+  opts[:alpn_protocols] = ALPN_PROTOCOLS
+  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)
+  loop do
+    client = server.accept
+    spin { client_loop(client, opts, &handler) }
+  rescue OpenSSL::SSL::SSLError
+    # disregard
+  end
+end
+
+def client_loop(client, opts, &handler)
+  client.no_delay if client.respond_to?(:no_delay)
+  adapter = protocol_adapter(client, opts)
+  adapter.each(&handler)
+ensure
+  client.close
+end
+
+def protocol_adapter(socket, opts)
+  use_http2 = socket.respond_to?(:alpn_protocol) &&
+              socket.alpn_protocol == H2_PROTOCOL
+  klass = use_http2 ? HTTP2 : HTTP1
+  klass.new(socket, opts)
+end

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

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+export_default :HTTP1Adapter
+
+require 'http/parser'
+
+Request = import('./request')
+HTTP2 = import('./http2')
+
+# 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,78 @@
+# 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
+    @connection_fiber = Fiber.current
+    @interface.on(:frame, &method(:send_frame))
+    @streams = {}
+  end
+
+  def send_frame(data)
+    @conn << data
+  rescue Exception => e
+    @connection_fiber.transfer e
+  end
+
+  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']
+    Fiber.current.schedule(nil)
+    @interface.upgrade(settings, @upgrade_headers, '')
+  ensure
+    @upgrade_headers = nil
+  end
+
+  # Iterates over incoming requests
+  def each(&block)
+    @interface.on(:stream) { |stream| start_stream(stream, &block) }
+    upgrade if @upgrade_headers
+
+    while (data = @conn.readpartial(8192))
+      @interface << data
+      snooze
+    end
+  rescue SystemCallError, IOError
+    # ignore
+  ensure
+    finalize_client_loop
+  end
+
+  def start_stream(stream, &block)
+    stream = Stream.new(stream, &block)
+    @streams[stream] = true
+  end
+
+  def finalize_client_loop
+    @interface = nil
+    @streams.each_key(&:stop)
+    @conn.close
+  end
+
+  def close
+    @conn.close
+  end
+end