http 3.1.0 → 5.3.1

data/lib/http/response/parser.rb

@@ -1,41 +1,63 @@
 # frozen_string_literal: true
 
+require "llhttp"
+
 module HTTP
   class Response
+    # @api private
     class Parser
-      attr_reader :headers
+      attr_reader :parser, :headers, :status_code, :http_version
 
       def initialize
-        @parser = HTTP::Parser.new(self)
+        @handler = Handler.new(self)
+        @parser = LLHttp::Parser.new(@handler, :type => :response)
         reset
       end
 
+      def reset
+        @parser.reset
+        @handler.reset
+        @header_finished = false
+        @message_finished = false
+        @headers = Headers.new
+        @chunk = nil
+        @status_code = nil
+        @http_version = nil
+      end
+
       def add(data)
-        @parser << data
+        parser << data
+
+        self
+      rescue LLHttp::Error => e
+        raise IOError, e.message
       end
+
       alias << add
 
-      def headers?
-        !!@headers
+      def mark_header_finished
+        @header_finished = true
+        @status_code = @parser.status_code
+        @http_version = "#{@parser.http_major}.#{@parser.http_minor}"
       end
 
-      def http_version
-        @parser.http_version.join(".")
+      def headers?
+        @header_finished
       end
 
-      def status_code
-        @parser.status_code
+      def add_header(name, value)
+        @headers.add(name, value)
       end
 
-      #
-      # HTTP::Parser callbacks
-      #
+      def mark_message_finished
+        @message_finished = true
+      end
 
-      def on_headers_complete(headers)
-        @headers = headers
+      def finished?
+        @message_finished
       end
 
-      def on_body(chunk)
+      def add_body(chunk)
         if @chunk
           @chunk << chunk
         else
@@ -57,20 +79,50 @@ module HTTP
         chunk
       end
 
-      def on_message_complete
-        @finished = true
-      end
+      class Handler < LLHttp::Delegate
+        def initialize(target)
+          @target = target
+          super()
+          reset
+        end
 
-      def reset
-        @parser.reset!
+        def reset
+          @reading_header_value = false
+          @field_value = +""
+          @field = +""
+        end
 
-        @finished = false
-        @headers  = nil
-        @chunk    = nil
-      end
+        def on_header_field(field)
+          append_header if @reading_header_value
+          @field << field
+        end
 
-      def finished?
-        @finished
+        def on_header_value(value)
+          @reading_header_value = true
+          @field_value << value
+        end
+
+        def on_headers_complete
+          append_header if @reading_header_value
+          @target.mark_header_finished
+        end
+
+        def on_body(body)
+          @target.add_body(body)
+        end
+
+        def on_message_complete
+          @target.mark_message_finished
+        end
+
+        private
+
+        def append_header
+          @target.add_header(@field, @field_value)
+          @reading_header_value = false
+          @field_value = +""
+          @field = +""
+        end
       end
     end
   end

data/lib/http/response/status.rb

@@ -58,7 +58,7 @@ module HTTP
       #   SYMBOLS[418] # => :im_a_teapot
       #
       # @return [Hash<Fixnum => Symbol>]
-      SYMBOLS = Hash[REASONS.map { |k, v| [k, symbolize(v)] }].freeze
+      SYMBOLS = REASONS.transform_values { |v| symbolize(v) }.freeze
 
       # Reversed {SYMBOLS} map.
       #
@@ -69,7 +69,7 @@ module HTTP
       #   SYMBOL_CODES[:im_a_teapot]           # => 418
       #
       # @return [Hash<Symbol => Fixnum>]
-      SYMBOL_CODES = Hash[SYMBOLS.map { |k, v| [v, k] }].freeze
+      SYMBOL_CODES = SYMBOLS.to_h { |k, v| [v, k] }.freeze
 
       # @return [Fixnum] status code
       attr_reader :code
@@ -132,7 +132,7 @@ module HTTP
       end
 
       SYMBOLS.each do |code, symbol|
-        class_eval <<-RUBY, __FILE__, __LINE__
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{symbol}?      # def bad_request?
             #{code} == code   #   400 == code
           end                 # end
@@ -141,6 +141,7 @@ module HTTP
 
       def __setobj__(obj)
         raise TypeError, "Expected #{obj.inspect} to respond to #to_i" unless obj.respond_to? :to_i
+
         @code = obj.to_i
       end
 

data/lib/http/response.rb

@@ -7,7 +7,6 @@ require "http/content_type"
 require "http/mime_type"
 require "http/response/status"
 require "http/response/inflater"
-require "http/uri"
 require "http/cookie_jar"
 require "time"
 
@@ -20,11 +19,14 @@ module HTTP
     # @return [Status]
     attr_reader :status
 
+    # @return [String]
+    attr_reader :version
+
     # @return [Body]
     attr_reader :body
 
-    # @return [URI, nil]
-    attr_reader :uri
+    # @return [Request]
+    attr_reader :request
 
     # @return [Hash]
     attr_reader :proxy_headers
@@ -38,45 +40,49 @@ module HTTP
     # @option opts [HTTP::Connection] :connection
     # @option opts [String] :encoding Encoding to use when reading body
     # @option opts [String] :body
-    # @option opts [String] :uri
+    # @option opts [HTTP::Request] request The request this is in response to.
+    # @option opts [String] :uri (DEPRECATED) used to populate a missing request
     def initialize(opts)
       @version       = opts.fetch(:version)
-      @uri           = HTTP::URI.parse(opts.fetch(:uri)) if opts.include? :uri
+      @request       = init_request(opts)
       @status        = HTTP::Response::Status.new(opts.fetch(:status))
       @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)
+        encoding = opts[:encoding] || charset || default_encoding
 
-        @body = Response::Body.new(stream, :encoding => encoding)
-      else
-        @body = opts.fetch(:body)
+        @body = Response::Body.new(connection, :encoding => encoding)
       end
     end
 
     # @!method reason
     #   @return (see HTTP::Response::Status#reason)
-    def_delegator :status, :reason
+    def_delegator :@status, :reason
 
     # @!method code
     #   @return (see HTTP::Response::Status#code)
-    def_delegator :status, :code
+    def_delegator :@status, :code
 
     # @!method to_s
     #   (see HTTP::Response::Body#to_s)
-    def_delegator :body, :to_s
+    def_delegator :@body, :to_s
     alias to_str to_s
 
     # @!method readpartial
     #   (see HTTP::Response::Body#readpartial)
-    def_delegator :body, :readpartial
+    def_delegator :@body, :readpartial
 
     # @!method connection
     #   (see HTTP::Response::Body#connection)
-    def_delegator :body, :connection
+    def_delegator :@body, :connection
+
+    # @!method uri
+    #   @return (see HTTP::Request#uri)
+    def_delegator :@request, :uri
 
     # Returns an Array ala Rack: `[status, headers, body]`
     #
@@ -132,8 +138,8 @@ module HTTP
     def_delegator :content_type, :charset
 
     def cookies
-      @cookies ||= headers.each_with_object CookieJar.new do |(k, v), jar|
-        jar.parse(v, uri) if k == Headers::SET_COOKIE
+      @cookies ||= headers.get(Headers::SET_COOKIE).each_with_object CookieJar.new do |v, jar|
+        jar.parse(v, uri)
       end
     end
 
@@ -148,12 +154,11 @@ module HTTP
 
     # Parse response body with corresponding MIME type adapter.
     #
-    # @param [#to_s] as Parse as given MIME type
-    #   instead of the one determined from headers
-    # @raise [HTTP::Error] if adapter not found
+    # @param type [#to_s] Parse as given MIME type.
+    # @raise (see MimeType.[])
     # @return [Object]
-    def parse(as = nil)
-      MimeType[as || mime_type].decode to_s
+    def parse(type = nil)
+      MimeType[type || mime_type].decode to_s
     end
 
     # Inspect a response
@@ -163,11 +168,24 @@ module HTTP
 
     private
 
-    def body_stream_for(connection, opts)
-      if opts[:auto_inflate]
-        opts[:auto_inflate].stream_for(connection, self)
+    def default_encoding
+      return Encoding::UTF_8 if mime_type == "application/json"
+
+      Encoding::BINARY
+    end
+
+    # Initialize an HTTP::Request from options.
+    #
+    # @return [HTTP::Request]
+    def init_request(opts)
+      raise ArgumentError, ":uri is for backwards compatibilty and conflicts with :request" \
+        if opts[:request] && opts[:uri]
+
+      # For backwards compatibilty
+      if opts[:uri]
+        HTTP::Request.new(:uri => opts[:uri], :verb => :get)
       else
-        connection
+        opts.fetch(:request)
       end
     end
   end

data/lib/http/retriable/client.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "http/retriable/performer"
+
+module HTTP
+  module Retriable
+    # Retriable version of HTTP::Client.
+    #
+    # @see http://www.rubydoc.info/gems/http/HTTP/Client
+    class Client < HTTP::Client
+      # @param [Performer] performer
+      # @param [HTTP::Options, Hash] options
+      def initialize(performer, options)
+        @performer = performer
+        super(options)
+      end
+
+      # Overriden version of `HTTP::Client#make_request`.
+      #
+      # Monitors request/response phase with performer.
+      #
+      # @see http://www.rubydoc.info/gems/http/HTTP/Client:perform
+      def perform(req, options)
+        @performer.perform(self, req) { super(req, options) }
+      end
+
+      private
+
+      # Overriden version of `HTTP::Chainable#branch`.
+      #
+      # @return [HTTP::Retriable::Client]
+      def branch(options)
+        Retriable::Client.new(@performer, options)
+      end
+    end
+  end
+end

data/lib/http/retriable/delay_calculator.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module HTTP
+  module Retriable
+    # @api private
+    class DelayCalculator
+      def initialize(opts)
+        @max_delay = opts.fetch(:max_delay, Float::MAX).to_f
+        if (delay = opts[:delay]).respond_to?(:call)
+          @delay_proc = opts.fetch(:delay)
+        else
+          @delay = delay
+        end
+      end
+
+      def call(iteration, response)
+        delay = if response && (retry_header = response.headers["Retry-After"])
+                  delay_from_retry_header(retry_header)
+                else
+                  calculate_delay_from_iteration(iteration)
+                end
+
+        ensure_dealy_in_bounds(delay)
+      end
+
+      RFC2822_DATE_REGEX = /^
+        (?:Sun|Mon|Tue|Wed|Thu|Fri|Sat),\s+
+        (?:0[1-9]|[1-2]?[0-9]|3[01])\s+
+        (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+
+        (?:19[0-9]{2}|[2-9][0-9]{3})\s+
+        (?:2[0-3]|[0-1][0-9]):(?:[0-5][0-9]):(?:60|[0-5][0-9])\s+
+        GMT
+      $/x
+
+      # Spec for Retry-After header
+      # https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
+      def delay_from_retry_header(value)
+        value = value.to_s.strip
+
+        case value
+        when RFC2822_DATE_REGEX then DateTime.rfc2822(value).to_time - Time.now.utc
+        when /^\d+$/            then value.to_i
+        else 0
+        end
+      end
+
+      def calculate_delay_from_iteration(iteration)
+        if @delay_proc
+          @delay_proc.call(iteration)
+        elsif @delay
+          @delay
+        else
+          delay = (2**(iteration - 1)) - 1
+          delay_noise = rand
+          delay + delay_noise
+        end
+      end
+
+      def ensure_dealy_in_bounds(delay)
+        delay.clamp(0, @max_delay)
+      end
+    end
+  end
+end

data/lib/http/retriable/errors.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module HTTP
+  # Retriable performance ran out of attempts
+  class OutOfRetriesError < Error
+    attr_accessor :response
+
+    attr_writer :cause
+
+    def cause
+      @cause || super
+    end
+  end
+end

data/lib/http/retriable/performer.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "date"
+require "http/retriable/errors"
+require "http/retriable/delay_calculator"
+require "openssl"
+
+module HTTP
+  module Retriable
+    # Request performing watchdog.
+    # @api private
+    class Performer
+      # Exceptions we should retry
+      RETRIABLE_ERRORS = [
+        HTTP::TimeoutError,
+        HTTP::ConnectionError,
+        IO::EAGAINWaitReadable,
+        Errno::ECONNRESET,
+        Errno::ECONNREFUSED,
+        Errno::EHOSTUNREACH,
+        OpenSSL::SSL::SSLError,
+        EOFError,
+        IOError
+      ].freeze
+
+      # @param [Hash] opts
+      # @option opts [#to_i] :tries (5)
+      # @option opts [#call, #to_i] :delay (DELAY_PROC)
+      # @option opts [Array(Exception)] :exceptions (RETRIABLE_ERRORS)
+      # @option opts [Array(#to_i)] :retry_statuses
+      # @option opts [#call] :on_retry
+      # @option opts [#to_f] :max_delay (Float::MAX)
+      # @option opts [#call] :should_retry
+      def initialize(opts)
+        @exception_classes = opts.fetch(:exceptions, RETRIABLE_ERRORS)
+        @retry_statuses = opts[:retry_statuses]
+        @tries = opts.fetch(:tries, 5).to_i
+        @on_retry = opts.fetch(:on_retry, ->(*) {})
+        @should_retry_proc = opts[:should_retry]
+        @delay_calculator = DelayCalculator.new(opts)
+      end
+
+      # Watches request/response execution.
+      #
+      # If any of {RETRIABLE_ERRORS} occur or response status is `5xx`, retries
+      # up to `:tries` amount of times. Sleeps for amount of seconds calculated
+      # with `:delay` proc before each retry.
+      #
+      # @see #initialize
+      # @api private
+      def perform(client, req, &block)
+        1.upto(Float::INFINITY) do |attempt| # infinite loop with index
+          err, res = try_request(&block)
+
+          if retry_request?(req, err, res, attempt)
+            begin
+              wait_for_retry_or_raise(req, err, res, attempt)
+            ensure
+              # Some servers support Keep-Alive on any response. Thus we should
+              # flush response before retry, to avoid state error (when socket
+              # has pending response data and we try to write new request).
+              # Alternatively, as we don't need response body here at all, we
+              # are going to close client, effectivle closing underlying socket
+              # and resetting client's state.
+              client.close
+            end
+          elsif err
+            client.close
+            raise err
+          elsif res
+            return res
+          end
+        end
+      end
+
+      def calculate_delay(iteration, response)
+        @delay_calculator.call(iteration, response)
+      end
+
+      private
+
+      # rubocop:disable Lint/RescueException
+      def try_request
+        err, res = nil
+
+        begin
+          res = yield
+        rescue Exception => e
+          err = e
+        end
+
+        [err, res]
+      end
+      # rubocop:enable Lint/RescueException
+
+      def retry_request?(req, err, res, attempt)
+        if @should_retry_proc
+          @should_retry_proc.call(req, err, res, attempt)
+        elsif err
+          retry_exception?(err)
+        else
+          retry_response?(res)
+        end
+      end
+
+      def retry_exception?(err)
+        @exception_classes.any? { |e| err.is_a?(e) }
+      end
+
+      def retry_response?(res)
+        return false unless @retry_statuses
+
+        response_status = res.status.to_i
+        retry_matchers = [@retry_statuses].flatten
+
+        retry_matchers.any? do |matcher|
+          case matcher
+          when Range then matcher.cover?(response_status)
+          when Numeric then matcher == response_status
+          else matcher.call(response_status)
+          end
+        end
+      end
+
+      def wait_for_retry_or_raise(req, err, res, attempt)
+        if attempt < @tries
+          @on_retry.call(req, err, res)
+          sleep calculate_delay(attempt, res)
+        else
+          res&.flush
+          raise out_of_retries_error(req, res, err)
+        end
+      end
+
+      # Builds OutOfRetriesError
+      #
+      # @param request [HTTP::Request]
+      # @param status [HTTP::Response, nil]
+      # @param exception [Exception, nil]
+      def out_of_retries_error(request, response, exception)
+        message = "#{request.verb.to_s.upcase} <#{request.uri}> failed"
+
+        message += " with #{response.status}" if response
+        message += ":#{exception}" if exception
+
+        HTTP::OutOfRetriesError.new(message).tap do |ex|
+          ex.cause = exception
+          ex.response = response
+        end
+      end
+    end
+  end
+end