tipi 0.40 → 0.45

data/lib/tipi/http1_adapter.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
-require 'http/parser'
-require_relative './http2_adapter'
+require 'h1p'
 require 'qeweney/request'
 
+require_relative './http2_adapter'
+
 module Tipi
   # HTTP1 protocol implementation
   class HTTP1Adapter
@@ -14,127 +15,83 @@ module Tipi
       @conn = conn
       @opts = opts
       @first = true
-      @parser = ::HTTP::Parser.new(self)
+      @parser = H1P::Parser.new(@conn)
     end
-    
+
     def each(&block)
-      @conn.recv_loop do |data|
-        return if handle_incoming_data(data, &block)
+      while true
+        headers = @parser.parse_headers
+        break unless headers
+
+        # handle_request returns true if connection is not persistent or was
+        # upgraded
+        break if handle_request(headers, &block)
       end
+    rescue H1P::Error, ArgumentError
+      # an ArgumentError might be raised in the parser if an invalid input
+      # string is given as the HTTP method (String#upcase will raise on invalid HTTP string)
+      #
+      # ignore
     rescue SystemCallError, IOError
       # ignore
     ensure
       finalize_client_loop
     end
-    
-    # return [Boolean] true if client loop should stop
-    def handle_incoming_data(data, &block)
-      rx = data.bytesize
-      @parser << data
-      while (request = @requests_head)
-        request.headers[':rx'] = rx
-        if @first
-          request.headers[':first'] = true
-          @first = nil
-        end
-        return true if upgrade_connection(request.headers, &block)
-        
-        @requests_head = request.__next__
-        block.call(request)
-        return true unless request.keep_alive?
+
+    def handle_request(headers, &block)
+      scheme = (proto = headers['x-forwarded-proto']) ?
+                proto.downcase : scheme_from_connection
+      headers[':scheme'] = scheme
+      @protocol = headers[':protocol']
+      if @first
+        headers[':first'] = true
+        @first = nil
       end
-      nil
+
+      return true if upgrade_connection(headers, &block)
+
+      request = Qeweney::Request.new(headers, self)
+      if !@parser.complete?
+        request.buffer_body_chunk(@parser.read_body_chunk(true))
+      end
+      block.call(request)
+      return !persistent_connection?(headers)
     end
-    
+
+    def persistent_connection?(headers)
+      if headers[':protocol'] == 'http/1.1'
+        return headers['connection'] != 'close'
+      else
+        connection = headers['connection']
+        return connection && connection != 'close'
+      end
+    end
+
     def finalize_client_loop
-      # release references to various objects
-      @requests_head = @requests_tail = nil
       @parser = nil
       @splicing_pipe = nil
       @conn.shutdown if @conn.respond_to?(:shutdown) rescue 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(request)
-      @waiting_for_body_chunk = true
-      @next_chunk = nil
-      while !@requests_tail.complete? && (data = @conn.readpartial(8192))
-        request.rx_incr(data.bytesize)
-        @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)
-      request = @requests_head
-      @conn.recv_loop do |data|
-        request.rx_incr(data.bytesize)
-        @parser << data
-        return if request.complete?
-      end
-    end
-    
-    def protocol
-      version = @parser.http_version
-      "HTTP #{version.join('.')}"
-    end
-    
-    def on_headers_complete(headers)
-      headers = normalize_headers(headers)
-      headers[':path'] = @parser.request_url
-      headers[':method'] = @parser.http_method.downcase
-      scheme = (proto = headers['x-forwarded-proto']) ?
-                proto.downcase : scheme_from_connection
-      headers[':scheme'] = scheme
-      queue_request(Qeweney::Request.new(headers, self))
+    def get_body_chunk(request, buffered_only = false)
+      @parser.read_body_chunk(buffered_only)
     end
 
-    def normalize_headers(headers)
-      headers.each_with_object({}) do |(k, v), h|
-        k = k.downcase
-        hk = h[k]
-        if hk
-          hk = h[k] = [hk] unless hk.is_a?(Array)
-          v.is_a?(Array) ? hk.concat(v) : hk << v
-        else
-          h[k] = v
-        end
-      end
-    end
-    
-    def queue_request(request)
-      if @requests_head
-        @requests_tail.__next__ = request
-        @requests_tail = request
-      else
-        @requests_head = @requests_tail = request
-      end
+    def get_body(request)
+      @parser.read_body
     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
+
+    def complete?(request)
+      @parser.complete?
     end
-    
-    def on_message_complete
-      @waiting_for_body_chunk = nil
-      @requests_tail.complete!(@parser.keep_alive?)
+
+    def protocol
+      @protocol
     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
@@ -160,27 +117,28 @@ module Tipi
     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
+      @parser = nil
       handler.(self, headers)
       true
     end
-    
+
     def upgrade_to_http2(headers, &block)
-      @parser = @requests_head = @requests_tail = nil
-      HTTP2Adapter.upgrade_each(@conn, @opts, http2_upgraded_headers(headers), &block)
+      headers = http2_upgraded_headers(headers)
+      body = @parser.read_body
+      HTTP2Adapter.upgrade_each(@conn, @opts, headers, body, &block)
       true
     end
-    
+
     # Returns headers for HTTP2 upgrade
     # @param headers [Hash] request headers
     # @return [Hash] headers for HTTP2 upgrade
@@ -198,10 +156,10 @@ module Tipi
     def scheme_from_connection
       @conn.is_a?(OpenSSL::SSL::SSLSocket) ? 'https' : 'http'
     end
-    
+
     # response API
 
-    CRLF = "\r\n"    
+    CRLF = "\r\n"
     CRLF_ZERO_CRLF_CRLF = "\r\n0\r\n\r\n"
 
     # Sends response including headers and body. Waits for the request to complete
@@ -210,7 +168,6 @@ module Tipi
     # @param body [String] response body
     # @param headers
     def respond(request, body, headers)
-      consume_request(request) if @parsing
       formatted_headers = format_headers(headers, body, false)
       request.tx_incr(formatted_headers.bytesize + (body ? body.bytesize : 0))
       if body
@@ -220,21 +177,21 @@ module Tipi
       end
     end
 
-    def respond_from_io(request, io, headers, chunk_size = 2**14)
-      consume_request(request) if @parsing
+    CHUNK_LENGTH_PROC = ->(len) { "#{len.to_s(16)}\r\n" }
 
+    def respond_from_io(request, io, headers, chunk_size = 2**14)
       formatted_headers = format_headers(headers, true, true)
       request.tx_incr(formatted_headers.bytesize)
-      
+
       # assume chunked encoding
       Thread.current.backend.splice_chunks(
         io,
         @conn,
         formatted_headers,
         "0\r\n\r\n",
-        ->(len) { "#{len.to_s(16)}\r\n" },
+        CHUNK_LENGTH_PROC,
         "\r\n",
-        16384    
+        chunk_size
       )
     end
 
@@ -246,11 +203,15 @@ module Tipi
     # @param chunked [boolean] whether to use chunked transfer encoding
     # @return [void]
     def send_headers(request, headers, empty_response: false, chunked: true)
-      formatted_headers = format_headers(headers, !empty_response, @parser.http_minor == 1 && chunked)
+      formatted_headers = format_headers(headers, !empty_response, http1_1?(request) && chunked)
       request.tx_incr(formatted_headers.bytesize)
       @conn.write(formatted_headers)
     end
-    
+
+    def http1_1?(request)
+      request.headers[':protocol'] == 'http/1.1'
+    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.
@@ -267,7 +228,7 @@ module Tipi
       request.tx_incr(data.bytesize)
       @conn.write(data)
     end
-    
+
     def send_chunk_from_io(request, io, r, w, chunk_size)
       len = w.splice(io, chunk_size)
       if len > 0
@@ -289,12 +250,12 @@ module Tipi
       request.tx_incr(5)
       @conn << "0\r\n\r\n"
     end
-    
+
     def close
       @conn.shutdown if @conn.respond_to?(:shutdown) rescue nil
       @conn.close
     end
-    
+
     private
 
     INTERNAL_HEADER_REGEXP = /^:/.freeze
@@ -311,13 +272,13 @@ module Tipi
       lines = format_status_line(body, status, chunked)
       headers.each do |k, v|
         next if k =~ INTERNAL_HEADER_REGEXP
-        
+
         collect_header_lines(lines, k, v)
       end
       lines << CRLF
       lines
     end
-    
+
     def format_status_line(body, status, chunked)
       if !body
         empty_status_line(status)
@@ -325,7 +286,7 @@ module Tipi
         with_body_status_line(status, body, chunked)
       end
     end
-    
+
     def empty_status_line(status)
       if status == 204
         +"HTTP/1.1 #{status}\r\n"
@@ -333,7 +294,7 @@ module Tipi
         +"HTTP/1.1 #{status}\r\nContent-Length: 0\r\n"
       end
     end
-    
+
     def with_body_status_line(status, body, chunked)
       if chunked
         +"HTTP/1.1 #{status}\r\nTransfer-Encoding: chunked\r\n"

data/lib/tipi/http2_adapter.rb

@@ -3,18 +3,30 @@
 require 'http/2'
 require_relative './http2_stream'
 
+# patch to fix bug in HTTP2::Stream
+class HTTP2::Stream
+  def end_stream?(frame)
+    case frame[:type]
+    when :data, :headers, :continuation
+      frame[:flags]&.include?(:end_stream)
+    else false
+    end
+  end
+end
+
 module Tipi
   # HTTP2 server adapter
   class HTTP2Adapter
-    def self.upgrade_each(socket, opts, headers, &block)
-      adapter = new(socket, opts, headers)
+    def self.upgrade_each(socket, opts, headers, body, &block)
+      adapter = new(socket, opts, headers, body)
       adapter.each(&block)
     end
-    
-    def initialize(conn, opts, upgrade_headers = nil)
+
+    def initialize(conn, opts, upgrade_headers = nil, upgrade_body = nil)
       @conn = conn
       @opts = opts
       @upgrade_headers = upgrade_headers
+      @upgrade_body = upgrade_body
       @first = true
       @rx = (upgrade_headers && upgrade_headers[':rx']) || 0
       @tx = (upgrade_headers && upgrade_headers[':tx']) || 0
@@ -24,33 +36,34 @@ module Tipi
       @interface.on(:frame, &method(:send_frame))
       @streams = {}
     end
-    
+
     def send_frame(data)
       if @transfer_count_request
         @transfer_count_request.tx_incr(data.bytesize)
       end
       @conn << data
+    rescue Polyphony::BaseException
+      raise
     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
       @tx += UPGRADE_MESSAGE.bytesize
       settings = @upgrade_headers['http2-settings']
-      Fiber.current.schedule(nil)
-      @interface.upgrade(settings, @upgrade_headers, '')
+      @interface.upgrade(settings, @upgrade_headers, @upgrade_body || '')
     ensure
       @upgrade_headers = nil
     end
-    
+
     # Iterates over incoming requests
     def each(&block)
       @interface.on(:stream) { |stream| start_stream(stream, &block) }
@@ -60,7 +73,7 @@ module Tipi
         @rx += data.bytesize
         @interface << data
       end
-    rescue SystemCallError, IOError
+    rescue SystemCallError, IOError, HTTP2::Error::Error
       # ignore
     ensure
       finalize_client_loop
@@ -71,26 +84,26 @@ module Tipi
       @rx = 0
       count
     end
-    
+
     def get_tx_count
       count = @tx
       @tx = 0
       count
     end
-    
+
     def start_stream(stream, &block)
       stream = HTTP2StreamHandler.new(self, stream, @conn, @first, &block)
       @first = nil if @first
       @streams[stream] = true
     end
-    
+
     def finalize_client_loop
       @interface = nil
       @streams.each_key(&:stop)
       @conn.shutdown if @conn.respond_to?(:shutdown) rescue nil
       @conn.close
     end
-    
+
     def close
       @conn.shutdown if @conn.respond_to?(:shutdown) rescue nil
       @conn.close

data/lib/tipi/http2_stream.rb

@@ -8,15 +8,14 @@ module Tipi
   class HTTP2StreamHandler
     attr_accessor :__next__
     attr_reader :conn
-    
+
     def initialize(adapter, stream, conn, first, &block)
       @adapter = adapter
       @stream = stream
       @conn = conn
       @first = first
       @connection_fiber = Fiber.current
-      @stream_fiber = spin { |req| handle_request(req, &block) }
-      Thread.current.fiber_unschedule(@stream_fiber)
+      @stream_fiber = spin { run(&block) }
 
       # Stream callbacks occur on the connection fiber (see HTTP2Adapter#each).
       # The request handler is run on a separate fiber for each stream, allowing
@@ -33,20 +32,20 @@ module Tipi
       stream.on(:data, &method(:on_data))
       stream.on(:half_close, &method(:on_half_close))
     end
-    
-    def handle_request(request, &block)
+
+    def run(&block)
+      request = receive
       error = nil
       block.(request)
       @connection_fiber.schedule
-    rescue Polyphony::MoveOn
-      # ignore
+    rescue Polyphony::BaseException
+      raise
     rescue Exception => e
       error = e
     ensure
-      @done = true
       @connection_fiber.schedule error
     end
-    
+
     def on_headers(headers)
       @request = Qeweney::Request.new(headers.to_h, self)
       @request.rx_incr(@adapter.get_rx_count)
@@ -55,31 +54,21 @@ module Tipi
         @request.headers[':first'] = true
         @first = false
       end
-      @stream_fiber.schedule @request
+      @stream_fiber << @request
     end
 
     def on_data(data)
       data = data.to_s # chunks might be wrapped in a HTTP2::Buffer
-      if @waiting_for_body_chunk
-        @waiting_for_body_chunk = nil
-        @stream_fiber.schedule data
-      else
-        @request.buffer_body_chunk(data)
-      end
+
+      (@buffered_chunks ||= []) << data
+      @get_body_chunk_fiber&.schedule
     end
 
     def on_half_close
-      if @waiting_for_body_chunk
-        @waiting_for_body_chunk = nil
-        @stream_fiber.schedule
-      elsif @waiting_for_half_close
-        @waiting_for_half_close = nil
-        @stream_fiber.schedule
-      else
-        @request.complete!
-      end
+      @get_body_chunk_fiber&.schedule
+      @complete = true
     end
-    
+
     def protocol
       'h2'
     end
@@ -90,33 +79,40 @@ module Tipi
     ensure
       @adapter.unset_request_for_transfer_count(request)
     end
-    
-    def get_body_chunk(request)
-      # called in the context of the stream fiber
-      return nil if @request.complete?
-      
-      with_transfer_count(request) do
-        @waiting_for_body_chunk = true
-        # the chunk (or an exception) will be returned once the stream fiber is
-        # resumed 
+
+    def get_body_chunk(request, buffered_only = false)
+      @buffered_chunks ||= []
+      return @buffered_chunks.shift unless @buffered_chunks.empty?
+      return nil if @complete
+
+      begin
+        @get_body_chunk_fiber = Fiber.current
         suspend
+      ensure
+        @get_body_chunk_fiber = nil
       end
-    ensure
-      @waiting_for_body_chunk = nil
+      @buffered_chunks.shift
     end
-    
-    # Wait for request to finish
-    def consume_request(request)
-      return if @request.complete?
-      
-      with_transfer_count(request) do
-        @waiting_for_half_close = true
-        suspend
+
+    def get_body(request)
+      @buffered_chunks ||= []
+      return @buffered_chunks.join if @complete
+
+      while !@complete
+        begin
+          @get_body_chunk_fiber = Fiber.current
+          suspend
+        ensure
+          @get_body_chunk_fiber = nil
+        end
       end
-    ensure
-      @waiting_for_half_close = nil
+      @buffered_chunks.join
+    end
+
+    def complete?(request)
+      @complete
     end
-    
+
     # response API
     def respond(request, chunk, headers)
       headers[':status'] ||= Qeweney::Status::OK
@@ -153,10 +149,10 @@ module Tipi
         end
       end
     end
-    
+
     def send_headers(request, headers, empty_response: false)
       return if @headers_sent
-      
+
       headers[':status'] ||= (empty_response ? Qeweney::Status::NO_CONTENT : Qeweney::Status::OK).to_s
       with_transfer_count(request) do
         @stream.headers(transform_headers(headers), end_stream: false)
@@ -165,10 +161,10 @@ module Tipi
     rescue HTTP2::Error::StreamClosed
       # ignore
     end
-    
+
     def send_chunk(request, chunk, done: false)
       send_headers({}, false) unless @headers_sent
-      
+
       if chunk
         with_transfer_count(request) do
           @stream.data(chunk, end_stream: done)
@@ -179,7 +175,7 @@ module Tipi
     rescue HTTP2::Error::StreamClosed
       # ignore
     end
-    
+
     def finish(request)
       if @headers_sent
         @stream.close
@@ -192,10 +188,10 @@ module Tipi
     rescue HTTP2::Error::StreamClosed
       # ignore
     end
-    
+
     def stop
-      return if @done
-      
+      return if @complete
+
       @stream.close
       @stream_fiber.schedule(Polyphony::MoveOn.new)
     end