http 3.3.0 → 4.4.1

data/lib/http/request.rb

@@ -66,6 +66,8 @@ module HTTP
     # Scheme is normalized to be a lowercase symbol e.g. :http, :https
     attr_reader :scheme
 
+    attr_reader :uri_normalizer
+
     # "Request URI" as per RFC 2616
     # http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html
     attr_reader :uri
@@ -73,25 +75,25 @@ module HTTP
 
     # @option opts [String] :version
     # @option opts [#to_s] :verb HTTP request method
+    # @option opts [#call] :uri_normalizer (HTTP::URI::NORMALIZER)
     # @option opts [HTTP::URI, #to_s] :uri
     # @option opts [Hash] :headers
     # @option opts [Hash] :proxy
     # @option opts [String, Enumerable, IO, nil] :body
     def initialize(opts)
-      @verb   = opts.fetch(:verb).to_s.downcase.to_sym
-      @uri    = normalize_uri(opts.fetch(:uri))
+      @verb           = opts.fetch(:verb).to_s.downcase.to_sym
+      @uri_normalizer = opts[:uri_normalizer] || HTTP::URI::NORMALIZER
+
+      @uri    = @uri_normalizer.call(opts.fetch(:uri))
       @scheme = @uri.scheme.to_s.downcase.to_sym if @uri.scheme
 
       raise(UnsupportedMethodError, "unknown method: #{verb}") unless METHODS.include?(@verb)
       raise(UnsupportedSchemeError, "unknown scheme: #{scheme}") unless SCHEMES.include?(@scheme)
 
       @proxy   = opts[:proxy] || {}
-      @body    = request_body(opts[:body], opts)
       @version = opts[:version] || "1.1"
-      @headers = HTTP::Headers.coerce(opts[:headers] || {})
-
-      @headers[Headers::HOST]        ||= default_host_header_value
-      @headers[Headers::USER_AGENT]  ||= USER_AGENT
+      @headers = prepare_headers(opts[:headers])
+      @body    = prepare_body(opts[:body])
     end
 
     # Returns new Request with updated uri
@@ -100,12 +102,13 @@ module HTTP
       headers.delete(Headers::HOST)
 
       self.class.new(
-        :verb    => verb,
-        :uri     => @uri.join(uri),
-        :headers => headers,
-        :proxy   => proxy,
-        :body    => body,
-        :version => version
+        :verb           => verb,
+        :uri            => @uri.join(uri),
+        :headers        => headers,
+        :proxy          => proxy,
+        :body           => body.source,
+        :version        => version,
+        :uri_normalizer => uri_normalizer
       )
     end
 
@@ -184,15 +187,20 @@ module HTTP
       using_proxy? ? proxy[:proxy_port] : port
     end
 
-    private
-
-    # Transforms body to an object suitable for streaming.
-    def request_body(body, opts)
-      body = Request::Body.new(body) unless body.is_a?(Request::Body)
-      body = opts[:auto_deflate].deflated_body(body) if opts[:auto_deflate]
-      body
+    # Human-readable representation of base request info.
+    #
+    # @example
+    #
+    #     req.inspect
+    #     # => #<HTTP::Request/1.1 GET https://example.com>
+    #
+    # @return [String]
+    def inspect
+      "#<#{self.class}/#{@version} #{verb.to_s.upcase} #{uri}>"
     end
 
+    private
+
     # @!attribute [r] host
     #   @return [String]
     def_delegator :@uri, :host
@@ -208,17 +216,17 @@ module HTTP
       PORTS[@scheme] != port ? "#{host}:#{port}" : host
     end
 
-    # @return [HTTP::URI] URI with all componentes but query being normalized.
-    def normalize_uri(uri)
-      uri = HTTP::URI.parse uri
+    def prepare_body(body)
+      body.is_a?(Request::Body) ? body : Request::Body.new(body)
+    end
 
-      HTTP::URI.new(
-        :scheme     => uri.normalized_scheme,
-        :authority  => uri.normalized_authority,
-        :path       => uri.normalized_path,
-        :query      => uri.query,
-        :fragment   => uri.normalized_fragment
-      )
+    def prepare_headers(headers)
+      headers = HTTP::Headers.coerce(headers || {})
+
+      headers[Headers::HOST]        ||= default_host_header_value
+      headers[Headers::USER_AGENT]  ||= USER_AGENT
+
+      headers
     end
   end
 end

data/lib/http/request/body.rb

@@ -35,14 +35,43 @@ module HTTP
           yield @source
         elsif @source.respond_to?(:read)
           IO.copy_stream(@source, ProcIO.new(block))
-          @source.rewind if @source.respond_to?(:rewind)
+          rewind(@source)
         elsif @source.is_a?(Enumerable)
           @source.each(&block)
         end
+
+        self
+      end
+
+      # Request bodies are equivalent when they have the same source.
+      def ==(other)
+        self.class == other.class && self.source == other.source # rubocop:disable Style/RedundantSelf
       end
 
       private
 
+      def rewind(io)
+        io.rewind if io.respond_to? :rewind
+      rescue Errno::ESPIPE, Errno::EPIPE
+        # Pipe IOs respond to `:rewind` but fail when you call it.
+        #
+        # Calling `IO#rewind` on a pipe, fails with *ESPIPE* on MRI,
+        # but *EPIPE* on jRuby.
+        #
+        # - **ESPIPE** -- "Illegal seek."
+        #   Invalid seek operation (such as on a pipe).
+        #
+        # - **EPIPE** -- "Broken pipe."
+        #   There is no process reading from the other end of a pipe. Every
+        #   library function that returns this error code also generates
+        #   a SIGPIPE signal; this signal terminates the program if not handled
+        #   or blocked. Thus, your program will never actually see EPIPE unless
+        #   it has handled or blocked SIGPIPE.
+        #
+        # See: https://www.gnu.org/software/libc/manual/html_node/Error-Codes.html
+        nil
+      end
+
       def validate_source_type!
         return if @source.is_a?(String)
         return if @source.respond_to?(:read)

data/lib/http/request/writer.rb

@@ -60,22 +60,32 @@ module HTTP
         @request_header.join(CRLF) + CRLF * 2
       end
 
+      # Writes HTTP request data into the socket.
       def send_request
-        # It's important to send the request in a single write call when
-        # possible in order to play nicely with Nagle's algorithm. Making
-        # two writes in a row triggers a pathological case where Nagle is
-        # expecting a third write that never happens.
+        each_chunk { |chunk| write chunk }
+      rescue Errno::EPIPE
+        # server doesn't need any more data
+        nil
+      end
+
+      # Yields chunks of request data that should be sent to the socket.
+      #
+      # It's important to send the request in a single write call when possible
+      # in order to play nicely with Nagle's algorithm. Making two writes in a
+      # row triggers a pathological case where Nagle is expecting a third write
+      # that never happens.
+      def each_chunk
         data = join_headers
 
         @body.each do |chunk|
           data << encode_chunk(chunk)
-          write(data)
+          yield data
           data.clear
         end
 
-        write(data) unless data.empty?
+        yield data unless data.empty?
 
-        write(CHUNKED_END) if chunked?
+        yield CHUNKED_END if chunked?
       end
 
       # Returns the chunk encoded for to the specified "Transfer-Encoding" header.
@@ -100,6 +110,10 @@ module HTTP
           break unless data.bytesize > length
           data = data.byteslice(length..-1)
         end
+      rescue Errno::EPIPE
+        raise
+      rescue IOError, SocketError, SystemCallError => ex
+        raise ConnectionError, "error writing to socket: #{ex}", ex.backtrace
       end
     end
   end

data/lib/http/response.rb

@@ -20,6 +20,9 @@ module HTTP
     # @return [Status]
     attr_reader :status
 
+    # @return [String]
+    attr_reader :version
+
     # @return [Body]
     attr_reader :body
 
@@ -46,14 +49,13 @@ module HTTP
       @headers       = HTTP::Headers.coerce(opts[:headers] || {})
       @proxy_headers = HTTP::Headers.coerce(opts[:proxy_headers] || {})
 
-      if opts.include?(:connection)
+      if opts.include?(:body)
+        @body = opts.fetch(:body)
+      else
         connection = opts.fetch(:connection)
         encoding   = opts[:encoding] || charset || Encoding::BINARY
-        stream     = body_stream_for(connection, opts)
 
-        @body = Response::Body.new(stream, :encoding => encoding)
-      else
-        @body = opts.fetch(:body)
+        @body = Response::Body.new(connection, :encoding => encoding)
       end
     end
 
@@ -160,15 +162,5 @@ module HTTP
     def inspect
       "#<#{self.class}/#{@version} #{code} #{reason} #{headers.to_h.inspect}>"
     end
-
-    private
-
-    def body_stream_for(connection, opts)
-      if opts[:auto_inflate]
-        opts[:auto_inflate].stream_for(connection, self)
-      else
-        connection
-      end
-    end
   end
 end

data/lib/http/response/parser.rb

@@ -1,41 +1,69 @@
 # frozen_string_literal: true
 
+require "http-parser"
+
 module HTTP
   class Response
+    # @api private
+    #
+    # NOTE(ixti): This class is a subject of future refactoring, thus don't
+    #   expect this class API to be stable until this message disappears and
+    #   class is not marked as private anymore.
     class Parser
       attr_reader :headers
 
       def initialize
-        @parser = HTTP::Parser.new(self)
+        @state  = HttpParser::Parser.new_instance { |i| i.type = :response }
+        @parser = HttpParser::Parser.new(self)
+
         reset
       end
 
+      # @return [self]
       def add(data)
-        @parser << data
+        # XXX(ixti): API doc of HttpParser::Parser is misleading, it says that
+        #   it returns boolean true if data was parsed successfully, but instead
+        #   it's response tells if there was an error; So when it's `true` that
+        #   means parse failed, and `false` means parse was successful.
+        #   case of success.
+        return self unless @parser.parse(@state, data)
+
+        raise IOError, "Could not parse data"
       end
       alias << add
 
       def headers?
-        !!@headers
+        @finished[:headers]
       end
 
       def http_version
-        @parser.http_version.join(".")
+        @state.http_version
       end
 
       def status_code
-        @parser.status_code
+        @state.http_status
       end
 
       #
       # HTTP::Parser callbacks
       #
 
-      def on_headers_complete(headers)
-        @headers = headers
+      def on_header_field(_response, field)
+        append_header if @reading_header_value
+        @field << field
+      end
+
+      def on_header_value(_response, value)
+        @reading_header_value = true
+        @field_value << value
+      end
+
+      def on_headers_complete(_reposse)
+        append_header if @reading_header_value
+        @finished[:headers] = true
       end
 
-      def on_body(chunk)
+      def on_body(_response, chunk)
         if @chunk
           @chunk << chunk
         else
@@ -57,20 +85,32 @@ module HTTP
         chunk
       end
 
-      def on_message_complete
-        @finished = true
+      def on_message_complete(_response)
+        @finished[:message] = true
       end
 
       def reset
-        @parser.reset!
-
-        @finished = false
-        @headers  = nil
-        @chunk    = nil
+        @state.reset!
+
+        @finished             = Hash.new(false)
+        @headers              = HTTP::Headers.new
+        @reading_header_value = false
+        @field                = +""
+        @field_value          = +""
+        @chunk                = nil
       end
 
       def finished?
-        @finished
+        @finished[:message]
+      end
+
+      private
+
+      def append_header
+        @headers.add(@field, @field_value)
+        @reading_header_value = false
+        @field_value          = +""
+        @field                = +""
       end
     end
   end

data/lib/http/timeout/global.rb

@@ -3,27 +3,25 @@
 require "timeout"
 require "io/wait"
 
-require "http/timeout/per_operation"
+require "http/timeout/null"
 
 module HTTP
   module Timeout
-    class Global < PerOperation
-      attr_reader :time_left, :total_timeout
-
+    class Global < Null
       def initialize(*args)
         super
-        reset_counter
+
+        @timeout = @time_left = options.fetch(:global_timeout)
       end
 
       # To future me: Don't remove this again, past you was smarter.
       def reset_counter
-        @time_left = connect_timeout + read_timeout + write_timeout
-        @total_timeout = time_left
+        @time_left = @timeout
       end
 
       def connect(socket_class, host, port, nodelay = false)
         reset_timer
-        ::Timeout.timeout(time_left, TimeoutError) do
+        ::Timeout.timeout(@time_left, TimeoutError) do
           @socket = socket_class.open(host, port)
           @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) if nodelay
         end
@@ -37,11 +35,11 @@ module HTTP
         begin
           @socket.connect_nonblock
         rescue IO::WaitReadable
-          IO.select([@socket], nil, nil, time_left)
+          IO.select([@socket], nil, nil, @time_left)
           log_time
           retry
         rescue IO::WaitWritable
-          IO.select(nil, [@socket], nil, time_left)
+          IO.select(nil, [@socket], nil, @time_left)
           log_time
           retry
         end
@@ -105,13 +103,13 @@ module HTTP
 
       # Wait for a socket to become readable
       def wait_readable_or_timeout
-        @socket.to_io.wait_readable(time_left)
+        @socket.to_io.wait_readable(@time_left)
         log_time
       end
 
       # Wait for a socket to become writable
       def wait_writable_or_timeout
-        @socket.to_io.wait_writable(time_left)
+        @socket.to_io.wait_writable(@time_left)
         log_time
       end
 
@@ -123,8 +121,8 @@ module HTTP
 
       def log_time
         @time_left -= (Time.now - @started)
-        if time_left <= 0
-          raise TimeoutError, "Timed out after using the allocated #{total_timeout} seconds"
+        if @time_left <= 0
+          raise TimeoutError, "Timed out after using the allocated #{@timeout} seconds"
         end
 
         reset_timer