polyphony 0.23 → 0.24

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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-export_default :Response
-
-require 'json'
-
-# HTTP response
-class Response
-  attr_reader :status_code, :headers
-
-  def initialize(adapter, status_code, headers)
-    @adapter = adapter
-    @status_code = status_code
-    @headers = headers
-  end
-
-  def body
-    @body ||= @adapter.body
-  end
-
-  def each_chunk(&block)
-    @adapter.each_chunk(&block)
-  end
-
-  def next_body_chunk
-    @adapter.next_body_chunk
-  end
-
-  def json
-    @json ||= ::JSON.parse(body)
-  end
-end

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

@@ -1,109 +0,0 @@
-# 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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-export :serve, :listen, :accept_loop, :client_loop
-
-Net   = import('../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

@@ -1,268 +0,0 @@
-# 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