polyphony 0.17 → 0.19

data/lib/polyphony/extensions/socket.rb

@@ -34,6 +34,19 @@ class ::Socket
     @write_watcher&.stop
   end
 
+  def recv(maxlen, flags = 0, outbuf = nil)
+    outbuf ||= +''
+    loop do
+      result = recv_nonblock(maxlen, flags, outbuf, NO_EXCEPTION)
+      case result
+      when :wait_readable
+        read_watcher.await
+      else
+        return result
+      end
+    end
+  end
+
   def recvfrom(maxlen, flags = 0)
     @read_buffer ||= +''
     loop do
@@ -70,6 +83,32 @@ class ::Socket
   end
 end
 
+class ::TCPSocket
+  NO_EXCEPTION = { exception: false }.freeze
+
+  def foo; :bar; end
+
+  def initialize(remote_host, remote_port, local_host=nil, local_port=nil)
+    @io = Socket.new Socket::AF_INET, Socket::SOCK_STREAM
+    if local_host && local_port
+      @io.bind(Addrinfo.tcp(local_host, local_port))
+    end
+    @io.connect(Addrinfo.tcp(remote_host, remote_port))
+  end
+
+  def close
+    @io.close
+  end
+
+  def setsockopt(*args)
+    @io.setsockopt(*args)
+  end
+
+  def closed?
+    @io.closed?
+  end
+end
+
 class ::TCPServer
   NO_EXCEPTION = { exception: false }.freeze
 
@@ -86,4 +125,4 @@ class ::TCPServer
   ensure
     @read_watcher&.stop
   end
-end
+end

data/lib/polyphony/http/agent.rb

@@ -21,12 +21,12 @@ end
 
 # Implements an HTTP agent
 class Agent
-  def self.get(url, query = nil)
-    default.get(url, query)
+  def self.get(*args)
+    default.get(*args)
   end
 
-  def self.post(url, query = nil)
-    default.post(url, query)
+  def self.post(*args)
+    default.post(*args)
   end
 
   def self.default
@@ -39,15 +39,16 @@ class Agent
     end
   end
 
-  def get(url, query = nil)
-    request(url, method: :GET, query: query)
+  OPTS_DEFAULT = {}.freeze
+
+  def get(url, opts = OPTS_DEFAULT)
+    request(url, opts.merge(method: :GET))
   end
 
-  def post(url, query = nil)
-    request(url, method: :POST, query: query)
+  def post(url, opts = OPTS_DEFAULT)
+    request(url, opts.merge(method: :POST))
   end
 
-  OPTS_DEFAULT = {}.freeze
 
   def request(url, opts = OPTS_DEFAULT)
     ctx = request_ctx(url, opts)
@@ -55,7 +56,7 @@ class Agent
     response = do_request(ctx)
     case response[:status_code]
     when 301, 302
-      request(response[:headers]['Location'])
+      redirect(response[:headers]['Location'], ctx, opts)
     when 200, 204
       response.extend(ResponseMixin)
     else
@@ -63,11 +64,31 @@ class Agent
     end
   end
 
+  def redirect(url, ctx, opts)
+    url = case url
+    when /^http(?:s)?\:\/\//
+      url
+    when /^\/\/(.+)$/
+      ctx[:uri].scheme + url
+    when /^\//
+      "%s://%s%s" % [
+        ctx[:uri].scheme,
+        ctx[:uri].host,
+        url
+      ]
+    else
+      ctx[:uri] + url
+    end
+
+    request(url, opts)
+  end
+
   def request_ctx(url, opts)
     {
       method: opts[:method] || :GET,
       uri:    url_to_uri(url, opts),
-      opts:   opts
+      opts:   opts,
+      retry:  0,
     }
   end
 
@@ -87,13 +108,20 @@ class Agent
   def do_request(ctx)
     key = uri_key(ctx[:uri])
     @pools[key].acquire do |state|
-      state[:socket] ||=  connect(key)
-      state[:protocol_method] ||= protocol_method(state[:socket], ctx)
-      send(state[:protocol_method], state, ctx)
-    rescue => e
-      state[:socket]&.close rescue nil
-      state.clear
-      raise e
+      cancel_after(10) do
+        state[:socket] ||=  connect(key)
+        state[:protocol_method] ||= protocol_method(state[:socket], ctx)
+        send(state[:protocol_method], state, ctx)
+      rescue => e
+        state[:socket]&.close rescue nil
+        state.clear
+        if ctx[:retry] < 3
+          ctx[:retry] += 1
+          do_request(ctx)
+        else
+          raise e
+        end
+      end
     end
   end
 
@@ -136,12 +164,13 @@ class Agent
     stream = state[:http2_client].new_stream # allocate new stream
 
     headers = {
-      ':scheme'     => ctx[:uri].scheme,
       ':method'     => ctx[:method].to_s,
-      ':path'       => ctx[:uri].request_uri,
+      ':scheme'     => ctx[:uri].scheme,      
       ':authority'  => [ctx[:uri].host, ctx[:uri].port].join(':'),
+      ':path'       => ctx[:uri].request_uri,
     }
     headers.merge!(ctx[:opts][:headers]) if ctx[:opts][:headers]
+    puts "* proxy request headers: #{headers.inspect}"
 
     if ctx[:opts][:payload]
       stream.headers(headers, end_stream: false)
@@ -173,13 +202,17 @@ class Agent
     (stream.close rescue nil) unless done
   end
 
-  HTTP1_REQUEST = "%<method>s %<request>s HTTP/1.1\r\nHost: %<host>s\r\n\r\n"
+  HTTP1_REQUEST = "%<method>s %<request>s HTTP/1.1\r\nHost: %<host>s\r\n%<headers>s\r\n"
 
   def format_http1_request(ctx)
+    headers = ctx[:opts][:headers] ? ctx[:opts][:headers].map { |k, v| "#{k}: #{v}\r\n"}.join : nil
+    puts "* proxy request headers: #{headers.inspect}"
+
     HTTP1_REQUEST % {
       method:   ctx[:method],
       request:  ctx[:uri].request_uri,
-      host:     ctx[:uri].host
+      host:     ctx[:uri].host,
+      headers:  headers
     }
   end
 
@@ -198,9 +231,7 @@ class Agent
     when 'http'
       Polyphony::Net.tcp_connect(key[:host], key[:port])
     when 'https'
-      Polyphony::Net.tcp_connect(key[:host], key[:port], SECURE_OPTS).tap do |socket|
-        socket.post_connection_check(key[:host])
-      end
+      Polyphony::Net.tcp_connect(key[:host], key[:port], SECURE_OPTS)
     else
       raise "Invalid scheme #{key[:scheme].inspect}"
     end

data/lib/polyphony/http/http1_adapter.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+export_default :HTTP1Adapter
+
+require 'http/parser'
+
+Request = import('./request')
+HTTP2 = import('./http2_adapter')
+
+# HTTP1 protocol implementation
+class HTTP1Adapter
+  # Initializes a protocol adapter instance
+  def initialize(conn, opts)
+    @conn = conn
+    @opts = opts
+    @parser = HTTP::Parser.new(self)
+    @parse_fiber = Fiber.new { parse_loop }
+  end
+
+  def protocol
+    'http/1.1'
+  end
+
+  # Parses incoming data, potentially firing parser callbacks. This loop runs on
+  # a separate fiber and is resumed only when the handler (client) loop asks for
+  # headers, or the request body, or waits for the request to be completed. The
+  # control flow is as follows (arrows represent control transfer between
+  # fibers):
+  #
+  #       handler               parse_loop
+  #       get_headers     -->   ...
+  #                             @parser << @conn.readpartial(8192)
+  #       ...             <--   on_headers
+  #
+  #       get_body        -->   ...
+  #       ...             <--   on_body
+  #       
+  #       consume_request -->   ...
+  #                             @parser << @conn.readpartial(8192)
+  #       ...             <--   on_message_complete
+  #
+  def parse_loop
+    while (data = @conn.readpartial(8192))
+      break unless data
+      @parser << data
+      snooze
+    end
+    @calling_fiber.transfer nil
+  rescue SystemCallError, IOError => error
+    # ignore IO/system call errors
+    @calling_fiber.transfer nil
+  rescue Exception => error
+    # an error return value will be raised by the receiving fiber
+    @calling_fiber.transfer error
+  end
+
+  # request API
+
+  # Iterates over incoming requests. Requests are yielded once all headers have
+  # been received. It is left to the application to read the request body or
+  # diesregard it.
+  def each(&block)
+    can_upgrade = true
+    while @parse_fiber.alive? && (headers = get_headers)
+      if can_upgrade
+        # The connection can be upgraded only on the first request
+        return if upgrade_connection(headers, &block)
+        can_upgrade = false
+      end
+
+      @headers_sent = nil
+      block.(Request.new(headers, self))
+      
+      if @parser.keep_alive?
+        @parsing = false
+      else
+        break
+      end
+    end
+  ensure
+    @conn.close rescue nil
+  end
+
+  # Reads headers for the next request. Transfers control to the parse loop,
+  # and resumes once the parse_loop has fired the on_headers callback
+  def get_headers
+    @parsing = true
+    @calling_fiber = Fiber.current
+    @parse_fiber.safe_transfer
+  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
+    @calling_fiber = Fiber.current
+    @read_body = true
+    @parse_fiber.safe_transfer
+  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
+    return unless @parsing
+
+    @calling_fiber = Fiber.current
+    @read_body = false
+    @parse_fiber.safe_transfer while @parsing
+  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
+
+    if @opts[:upgrade] && @opts[:upgrade][upgrade_protocol.to_sym]
+      @opts[:upgrade][upgrade_protocol.to_sym].(@conn, headers)
+      return true
+    end
+  
+    return nil unless upgrade_protocol == 'h2c'
+    
+    # upgrade to HTTP/2
+    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
+    
+  # HTTP parser callbacks, called in the context of @parse_fiber
+
+  # Resumes client fiber on receipt of all headers
+  # @param headers [Hash] request headers
+  # @return [void]
+  def on_headers_complete(headers)
+    headers[':path'] = @parser.request_url
+    headers[':method'] = @parser.http_method
+    @calling_fiber.transfer(headers)
+  end
+
+  # Resumes client fiber on receipt of body chunk
+  # @param chunk [String] body chunk
+  # @return [void]
+  def on_body(chunk)
+    @calling_fiber.transfer(chunk) if @read_body
+  end
+
+  # Resumes client fiber on request completion
+  # @return [void]
+  def on_message_complete
+    @parsing = false
+    @calling_fiber.transfer nil
+  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 chunk [String] response body
+  # @param headers
+  def respond(chunk, headers)
+    consume_request if @parsing
+    data = format_headers(headers, empty_response: !chunk)
+    if chunk
+      data << "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n0\r\n\r\n"
+    end
+    @conn << data
+    @headers_sent = true
+  end
+
+  DEFAULT_HEADERS_OPTS = {
+    empty_response: false,
+    consume_request: true
+  }
+
+  # Sends response headers. Waits for the request to complete if not yet
+  # completed. 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 [void]
+  def send_headers(headers, opts = DEFAULT_HEADERS_OPTS)
+    return if @headers_sent
+
+    consume_request if @parsing && opts[:consume_request]
+    @conn << format_headers(headers, opts[:empty_response])
+    @headers_sent = true
+  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_body_chunk(chunk, done: false)
+    send_headers({}) unless @headers_sent
+
+    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
+    send_headers({}, true) unless @headers_sent
+
+    @conn << "0\r\n\r\n" if @body_sent
+  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, empty_response)
+    status = headers[':status'] || (empty_response ? 204 : 200)
+    data = empty_response ? 
+      +"HTTP/1.1 #{status}\r\n" :
+      +"HTTP/1.1 #{status}\r\nTransfer-Encoding: chunked\r\n"
+
+    headers.each do |k, v|
+      next if k =~ /^:/
+      v.is_a?(Array) ?
+        v.each { |o| data << "#{k}: #{o}\r\n" } : data << "#{k}: #{v}\r\n"
+    end
+    data << "\r\n"
+  end
+end