http 5.2.0 → 5.3.0

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

data/lib/http/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTP
-  VERSION = "5.2.0"
+  VERSION = "5.3.0"
 end

data/lib/http.rb

@@ -6,6 +6,7 @@ require "http/timeout/per_operation"
 require "http/timeout/global"
 require "http/chainable"
 require "http/client"
+require "http/retriable/client"
 require "http/connection"
 require "http/options"
 require "http/feature"

data/spec/lib/http/features/raise_error_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+RSpec.describe HTTP::Features::RaiseError do
+  subject(:feature) { described_class.new(ignore: ignore) }
+
+  let(:connection) { double }
+  let(:status) { 200 }
+  let(:ignore) { [] }
+
+  describe "#wrap_response" do
+    subject(:result) { feature.wrap_response(response) }
+
+    let(:response) do
+      HTTP::Response.new(
+        version:    "1.1",
+        status:     status,
+        headers:    {},
+        connection: connection,
+        request:    HTTP::Request.new(verb: :get, uri: "https://example.com")
+      )
+    end
+
+    context "when status is 200" do
+      it "returns original request" do
+        expect(result).to be response
+      end
+    end
+
+    context "when status is 399" do
+      let(:status) { 399 }
+
+      it "returns original request" do
+        expect(result).to be response
+      end
+    end
+
+    context "when status is 400" do
+      let(:status) { 400 }
+
+      it "raises" do
+        expect { result }.to raise_error(HTTP::StatusError, "Unexpected status code 400")
+      end
+    end
+
+    context "when status is 599" do
+      let(:status) { 599 }
+
+      it "raises" do
+        expect { result }.to raise_error(HTTP::StatusError, "Unexpected status code 599")
+      end
+    end
+
+    context "when error status is ignored" do
+      let(:status) { 500 }
+      let(:ignore) { [500] }
+
+      it "returns original request" do
+        expect(result).to be response
+      end
+    end
+  end
+end

data/spec/lib/http/headers/normalizer_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+RSpec.describe HTTP::Headers::Normalizer do
+  subject(:normalizer) { described_class.new }
+
+  include_context RSpec::Memory
+
+  describe "#call" do
+    it "normalizes the header" do
+      expect(normalizer.call("content_type")).to eq "Content-Type"
+    end
+
+    it "returns a non-frozen string" do
+      expect(normalizer.call("content_type")).not_to be_frozen
+    end
+
+    it "evicts the oldest item when cache is full" do
+      max_headers = (1..described_class::Cache::MAX_SIZE).map { |i| "Header#{i}" }
+      max_headers.each { |header| normalizer.call(header) }
+      normalizer.call("New-Header")
+      cache_store = normalizer.instance_variable_get(:@cache).instance_variable_get(:@store)
+      expect(cache_store.keys).to eq(max_headers[1..] + ["New-Header"])
+    end
+
+    it "retuns mutable strings" do
+      normalized_headers = Array.new(3) { normalizer.call("content_type") }
+
+      expect(normalized_headers)
+        .to satisfy { |arr| arr.uniq.size == 1 }
+        .and(satisfy { |arr| arr.map(&:object_id).uniq.size == normalized_headers.size })
+        .and(satisfy { |arr| arr.none?(&:frozen?) })
+    end
+
+    it "allocates minimal memory for normalization of the same header" do
+      normalizer.call("accept") # XXX: Ensure normalizer is pre-allocated
+
+      # On first call it is expected to allocate during normalization
+      expect { normalizer.call("content_type") }.to limit_allocations(
+        Array     => 1,
+        MatchData => 1,
+        String    => 6
+      )
+
+      # On subsequent call it is expected to only allocate copy of a cached string
+      expect { normalizer.call("content_type") }.to limit_allocations(
+        Array     => 0,
+        MatchData => 0,
+        String    => 1
+      )
+    end
+  end
+end

data/spec/lib/http/redirector_spec.rb

@@ -115,12 +115,13 @@ RSpec.describe HTTP::Redirector do
         expect(req_cookie).to eq request_cookies.shift
         hops.shift
       end
+
       expect(res.to_s).to eq "bar"
-      cookies = res.cookies.cookies.to_h { |c| [c.name, c.value] }
-      expect(cookies["foo"]).to eq "42"
-      expect(cookies["bar"]).to eq "53"
-      expect(cookies["baz"]).to eq "65"
-      expect(cookies["deleted"]).to eq nil
+      expect(res.cookies.cookies.to_h { |c| [c.name, c.value] }).to eq({
+        "foo" => "42",
+        "bar" => "53",
+        "baz" => "65"
+      })
     end
 
     it "returns original cookies in response" do

data/spec/lib/http/retriable/delay_calculator_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+RSpec.describe HTTP::Retriable::DelayCalculator do
+  let(:response) do
+    HTTP::Response.new(
+      status:  200,
+      version: "1.1",
+      headers: {},
+      body:    "Hello world!",
+      request: HTTP::Request.new(verb: :get, uri: "http://example.com")
+    )
+  end
+
+  def call_delay(iterations, **options)
+    described_class.new(options).call(iterations, response)
+  end
+
+  def call_retry_header(value, **options)
+    response.headers["Retry-After"] = value
+    described_class.new(options).call(rand(1...100), response)
+  end
+
+  it "prevents negative sleep time" do
+    expect(call_delay(20, delay: -20)).to eq 0
+  end
+
+  it "backs off exponentially" do
+    expect(call_delay(1)).to be_between 0, 1
+    expect(call_delay(2)).to be_between 1, 2
+    expect(call_delay(3)).to be_between 3, 4
+    expect(call_delay(4)).to be_between 7, 8
+    expect(call_delay(5)).to be_between 15, 16
+  end
+
+  it "can have a maximum wait time" do
+    expect(call_delay(1, max_delay: 5)).to be_between 0, 1
+    expect(call_delay(5, max_delay: 5)).to eq 5
+  end
+
+  it "respects Retry-After headers as integer" do
+    delay_time = rand(6...2500)
+    header_value = delay_time.to_s
+    expect(call_retry_header(header_value)).to eq delay_time
+    expect(call_retry_header(header_value, max_delay: 5)).to eq 5
+  end
+
+  it "respects Retry-After headers as rfc2822 timestamp" do
+    delay_time = rand(6...2500)
+    header_value = (Time.now.gmtime + delay_time).to_datetime.rfc2822.sub("+0000", "GMT")
+    expect(call_retry_header(header_value)).to be_within(1).of(delay_time)
+    expect(call_retry_header(header_value, max_delay: 5)).to eq 5
+  end
+
+  it "respects Retry-After headers as rfc2822 timestamp in the past" do
+    delay_time = rand(6...2500)
+    header_value = (Time.now.gmtime - delay_time).to_datetime.rfc2822.sub("+0000", "GMT")
+    expect(call_retry_header(header_value)).to eq 0
+  end
+
+  it "does not error on invalid Retry-After header" do
+    [ # invalid strings
+      "This is a string with a number 5 in it",
+      "8 Eight is the first digit in this string",
+      "This is a string with a #{Time.now.gmtime.to_datetime.rfc2822} timestamp in it"
+    ].each do |header_value|
+      expect(call_retry_header(header_value)).to eq 0
+    end
+  end
+end

data/spec/lib/http/retriable/performer_spec.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+RSpec.describe HTTP::Retriable::Performer do
+  let(:client) do
+    HTTP::Client.new
+  end
+
+  let(:response) do
+    HTTP::Response.new(
+      status:  200,
+      version: "1.1",
+      headers: {},
+      body:    "Hello world!",
+      request: request
+    )
+  end
+
+  let(:request) do
+    HTTP::Request.new(
+      verb: :get,
+      uri:  "http://example.com"
+    )
+  end
+
+  let(:perform_spy) { { counter: 0 } }
+  let(:counter_spy) { perform_spy[:counter] }
+
+  before do
+    stub_const("CustomException", Class.new(StandardError))
+  end
+
+  def perform(options = {}, client_arg = client, request_arg = request, &block)
+    # by explicitly overwriting the default delay, we make a much faster test suite
+    default_options = { delay: 0 }
+    options = default_options.merge(options)
+
+    HTTP::Retriable::Performer
+      .new(options)
+      .perform(client_arg, request_arg) do
+        perform_spy[:counter] += 1
+        block ? yield : response
+      end
+  end
+
+  def measure_wait
+    t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    result = yield
+    t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    [t2 - t1, result]
+  end
+
+  describe "#perform" do
+    describe "expected exception" do
+      it "retries the request" do
+        expect do
+          perform(exceptions: [CustomException], tries: 2) do
+            raise CustomException
+          end
+        end.to raise_error HTTP::OutOfRetriesError
+
+        expect(counter_spy).to eq 2
+      end
+    end
+
+    describe "unexpected exception" do
+      it "does not retry the request" do
+        expect do
+          perform(exceptions: [], tries: 2) do
+            raise CustomException
+          end
+        end.to raise_error CustomException
+
+        expect(counter_spy).to eq 1
+      end
+    end
+
+    describe "expected status codes" do
+      def response(**options)
+        HTTP::Response.new(
+          {
+            status:  200,
+            version: "1.1",
+            headers: {},
+            body:    "Hello world!",
+            request: request
+          }.merge(options)
+        )
+      end
+
+      it "retries the request" do
+        expect do
+          perform(retry_statuses: [200], tries: 2)
+        end.to raise_error HTTP::OutOfRetriesError
+
+        expect(counter_spy).to eq 2
+      end
+
+      describe "status codes can be expressed in many ways" do
+        [
+          301,
+          [200, 301, 485],
+          250...400,
+          [250...Float::INFINITY],
+          ->(status_code) { status_code == 301 },
+          [->(status_code) { status_code == 301 }]
+        ].each do |retry_statuses|
+          it retry_statuses.to_s do
+            expect do
+              perform(retry_statuses: retry_statuses, tries: 2) do
+                response(status: 301)
+              end
+            end.to raise_error HTTP::OutOfRetriesError
+          end
+        end
+      end
+    end
+
+    describe "unexpected status code" do
+      it "does not retry the request" do
+        expect(
+          perform(retry_statuses: [], tries: 2)
+        ).to eq response
+
+        expect(counter_spy).to eq 1
+      end
+    end
+
+    describe "on_retry callback" do
+      it "calls the on_retry callback on each retry with exception" do
+        callback_call_spy = 0
+
+        callback_spy = proc do |callback_request, error, callback_response|
+          expect(callback_request).to eq request
+          expect(error).to be_a HTTP::TimeoutError
+          expect(callback_response).to be_nil
+          callback_call_spy += 1
+        end
+
+        expect do
+          perform(tries: 3, on_retry: callback_spy) do
+            raise HTTP::TimeoutError
+          end
+        end.to raise_error HTTP::OutOfRetriesError
+
+        expect(callback_call_spy).to eq 2
+      end
+
+      it "calls the on_retry callback on each retry with response" do
+        callback_call_spy = 0
+
+        callback_spy = proc do |callback_request, error, callback_response|
+          expect(callback_request).to eq request
+          expect(error).to be_nil
+          expect(callback_response).to be response
+          callback_call_spy += 1
+        end
+
+        expect do
+          perform(retry_statuses: [200], tries: 3, on_retry: callback_spy)
+        end.to raise_error HTTP::OutOfRetriesError
+
+        expect(callback_call_spy).to eq 2
+      end
+    end
+
+    describe "delay option" do
+      let(:timing_slack) { 0.05 }
+
+      it "can be a positive number" do
+        time, = measure_wait do
+          perform(delay: 0.1, tries: 3, should_retry: ->(*) { true })
+        rescue HTTP::OutOfRetriesError
+        end
+        expect(time).to be_within(timing_slack).of(0.2)
+      end
+
+      it "can be a proc number" do
+        time, = measure_wait do
+          perform(delay: ->(attempt) { attempt / 10.0 }, tries: 3, should_retry: ->(*) { true })
+        rescue HTTP::OutOfRetriesError
+        end
+        expect(time).to be_within(timing_slack).of(0.3)
+      end
+
+      it "receives correct retry number when a proc" do
+        retry_count = 0
+        retry_proc = proc do |attempt|
+          expect(attempt).to eq(retry_count).and(be > 0)
+          0
+        end
+        begin
+          perform(delay: retry_proc, should_retry: ->(*) { true }) do
+            retry_count += 1
+            response
+          end
+        rescue HTTP::OutOfRetriesError
+        end
+      end
+    end
+
+    describe "should_retry option" do
+      it "decides if the request should be retried" do # rubocop:disable RSpec/MultipleExpectations
+        retry_proc = proc do |req, err, res, attempt|
+          expect(req).to eq request
+          if res
+            expect(err).to be_nil
+            expect(res).to be response
+          else
+            expect(err).to be_a CustomException
+            expect(res).to be_nil
+          end
+
+          attempt < 5
+        end
+
+        begin
+          perform(should_retry: retry_proc) do
+            rand < 0.5 ? response : raise(CustomException)
+          end
+        rescue CustomException
+        end
+
+        expect(counter_spy).to eq 5
+      end
+
+      it "raises the original error if not retryable" do
+        retry_proc = ->(*) { false }
+
+        expect do
+          perform(should_retry: retry_proc) do
+            raise CustomException
+          end
+        end.to raise_error CustomException
+
+        expect(counter_spy).to eq 1
+      end
+
+      it "raises HTTP::OutOfRetriesError if retryable" do
+        retry_proc = ->(*) { true }
+
+        expect do
+          perform(should_retry: retry_proc) do
+            raise CustomException
+          end
+        end.to raise_error HTTP::OutOfRetriesError
+
+        expect(counter_spy).to eq 5
+      end
+    end
+  end
+
+  describe "connection closing" do
+    let(:client) { double(:client) }
+
+    it "does not close the connection if we get a propper response" do
+      expect(client).not_to receive(:close)
+      perform
+    end
+
+    it "closes the connection after each raiseed attempt" do
+      expect(client).to receive(:close).exactly(3).times
+      begin
+        perform(should_retry: ->(*) { true }, tries: 3)
+      rescue HTTP::OutOfRetriesError
+      end
+    end
+
+    it "closes the connection on an unexpected exception" do
+      expect(client).to receive(:close)
+      begin
+        perform do
+          raise CustomException
+        end
+      rescue CustomException
+      end
+    end
+  end
+
+  describe HTTP::OutOfRetriesError do
+    it "has the original exception as a cause if available" do
+      err = nil
+      begin
+        perform(exceptions: [CustomException]) do
+          raise CustomException
+        end
+      rescue described_class => e
+        err = e
+      end
+      expect(err.cause).to be_a CustomException
+    end
+
+    it "has the last raiseed response as an attribute" do
+      err = nil
+      begin
+        perform(should_retry: ->(*) { true })
+      rescue described_class => e
+        err = e
+      end
+      expect(err.response).to be response
+    end
+  end
+end