excon-middleware-aws-exponential_backoff 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 79088f6ebcd87310329c1c8ce66dc3c3aa7184c9
+  data.tar.gz: 19f90d70c7292dd6f9d902260dec0297dcd744b1
+SHA512:
+  metadata.gz: 165f925409e1d286e97aa3a43aefe56214ed16f22e36aedf58af75f17f7f2bad8725d4c485d47f2ce9ceca22ba53262a1e605ae11d965fe527793428a576fc6a
+  data.tar.gz: fb60aa48496cbb24c24d38bd2b156e2c0caae1c6f576a90b4bda775f5a241801cc5ee6ddfc18e28d9b9868dbf46daed75763e6b30f05f56a00754b29c91492b6

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in excon-middleware-aws-exponential_backoff.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Michael Hale
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,38 @@
+# Excon::Middleware::AWS::ExponentialBackoff
+
+Excon middleware to exponentially backoff calling AWS APIs when throttled or experiencing errors.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'excon-middleware-aws-exponential_backoff'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install excon-middleware-aws-exponential_backoff
+
+## Usage
+
+This gem is intended to be used with fog and excon when communicating with AWS APIs.
+
+```ruby
+require "fog"
+require "excon/middleware/aws/exponential_backoff/include"
+
+10.times do
+  p Fog::DNS::AWS.new(aws_access_key_id: 'key', aws_secret_access_key: 'secret').list_hosted_zones
+end
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/mikehale/excon-middleware-aws-exponential_backoff/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/excon-middleware-aws-exponential_backoff.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'excon/middleware/aws/exponential_backoff/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "excon-middleware-aws-exponential_backoff"
+  spec.version       = Excon::Middleware::AWS::ExponentialBackoff::VERSION
+  spec.authors       = ["Michael Hale"]
+  spec.email         = ["mike@hales.ws"]
+  spec.summary       = %q{Excon middleware to exponentially backoff calling AWS APIs when throttled or experiencing errors.}
+  spec.homepage      = "https://github.com/mikehale/excon-middleware-aws-exponential_backoff"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_dependency "excon"
+end

data/lib/excon/middleware/aws/exponential_backoff.rb

@@ -0,0 +1,98 @@
+require 'excon'
+require "excon/middleware/aws/exponential_backoff/version"
+
+module Excon
+  module Middleware
+    module AWS
+      class ExponentialBackoff < Excon::Middleware::Base
+        MILLISECOND            = 1.0/1000
+        SLEEP_FACTOR           = MILLISECOND * 100
+        ERROR_CODE_REGEX       = Regexp.new(/<Code>([^<]+)<\/Code>/mi)
+        THROTTLING_ERROR_CODES = %w[
+                                   Throttling
+                                   ThrottlingException
+                                   ProvisionedThroughputExceededException
+                                   RequestThrottled
+                                   RequestLimitExceeded
+                                   BandwidthLimitExceeded
+        ]
+        SERVER_ERROR_CLASSES   = [
+                                  Excon::Errors::InternalServerError,
+                                  Excon::Errors::BadGateway,
+                                  Excon::Errors::ServiceUnavailable,
+                                  Excon::Errors::GatewayTimeout
+                                 ]
+        VALID_MIDDLEWARE_KEYS = [
+                                 :backoff
+                                ]
+
+        def error_call(datum)
+          datum[:backoff] ||= {}
+          datum[:backoff][:max_retries] ||= 0
+          datum[:backoff][:max_delay] ||= 30
+          datum[:backoff][:retry_count] = 0
+
+          if (throttle?(datum) || server_error?(datum)) && should_retry?(datum)
+            do_backoff(datum)
+          else
+            do_handoff(datum)
+          end
+        end
+
+        def do_handoff(datum)
+          @stack.error_call(datum)
+        end
+
+        def do_backoff(datum)
+          do_sleep(sleep_time(datum), datum)
+          datum[:backoff][:retry_count] += 1
+          connection = datum.delete(:connection)
+          datum.reject! { |key, _| !(Excon::VALID_REQUEST_KEYS + VALID_MIDDLEWARE_KEYS).include?(key)  }
+          connection.request(datum)
+        end
+
+        def do_sleep(sleep_time, datum)
+          if datum.has_key?(:instrumentor)
+            datum[:instrumentor].instrument("#{datum[:instrumentor_name]}.backoff", datum) do
+              sleep sleep_time
+            end
+          else
+            sleep sleep_time
+          end
+        end
+
+        def sleep_time(datum)
+          exponential_wait = (2 ** datum[:backoff][:retry_count] + rand(0.0)) * SLEEP_FACTOR
+          [
+           exponential_wait, 
+           datum[:backoff][:max_delay]
+          ].min.round(2)
+        end
+
+        def should_retry?(datum)
+          # Always retry if max_retries is 0.
+          datum[:backoff][:max_retries] == 0 ||
+            datum[:backoff][:retry_count] < datum[:backoff][:max_retries]
+        end
+
+        def throttle?(datum)
+          datum[:error].kind_of?(Excon::Errors::BadRequest) &&
+            THROTTLING_ERROR_CODES.include?(extract_error_code(datum[:error].response.body))
+
+
+        end
+
+        def server_error?(datum)
+          SERVER_ERROR_CLASSES.any? { |ex| datum[:error].kind_of?(ex) }
+        end
+
+        def extract_error_code(body)
+          match = ERROR_CODE_REGEX.match(body)
+          if match && code = match[1]
+            code.strip if code
+          end
+        end
+      end
+    end
+  end
+end

data/lib/excon/middleware/aws/exponential_backoff/include.rb

@@ -0,0 +1,2 @@
+require "excon/middleware/aws/exponential_backoff"
+Excon.defaults[:middlewares] << Excon::Middleware::AWS::ExponentialBackoff

data/lib/excon/middleware/aws/exponential_backoff/version.rb

@@ -0,0 +1,11 @@
+require "excon"
+
+module Excon
+  module Middleware
+    module AWS
+      class ExponentialBackoff < Excon::Middleware::Base
+        VERSION = "0.0.1"
+      end
+    end
+  end
+end

data/spec/exponential_backoff_spec.rb

@@ -0,0 +1,106 @@
+require "spec_helper"
+
+class Stack
+  def error_call(datum); end
+  def request_call(datum); end
+  def response_call(datum); end
+end
+
+RSpec.describe Excon::Middleware::AWS::ExponentialBackoff do
+  let(:stack) { Stack.new }
+  subject { Excon::Middleware::AWS::ExponentialBackoff.new(stack) }
+
+  it { is_expected.to respond_to :error_call }
+
+  it "delays exponentially longer" do
+    wait1 = subject.sleep_time(backoff: {max_delay: 10, retry_count: 0 })
+    wait2 = subject.sleep_time(backoff: {max_delay: 10, retry_count: 1 })
+    wait3 = subject.sleep_time(backoff: {max_delay: 10, retry_count: 2 })
+    expect(wait3).to be > wait2
+    expect(wait2).to be > wait1
+    expect(wait1).to be > 0
+  end
+
+  it "should not exceed max_delay" do
+    expect(subject.sleep_time(backoff: {max_delay: 1, retry_count: 10 })).to be 1.0
+  end
+
+  it "always retries if max_retries is 0" do
+    expect(subject.should_retry?(backoff: {max_retries: 0})).to be true
+  end
+
+  it "retries if retry_count is < max_retries" do
+    expect(subject.should_retry?(backoff: {retry_count:0, max_retries: 1})).to be true
+    expect(subject.should_retry?(backoff: {retry_count:1, max_retries: 1})).to be false
+  end
+
+  it "backs off when throttled" do
+    throttled = Excon::Errors.status_error({}, throttling_response)
+    redirect = Excon::Errors.status_error({}, Excon::Response.new(status: 302))
+    bad_request = Excon::Errors.status_error({}, Excon::Response.new(status: 400))
+
+    expect(subject.throttle?(error: throttled)).to be true
+    expect(subject.throttle?(error: redirect)).to be false
+    expect(subject.throttle?(error: bad_request)).to be false
+  end
+
+  it "backs off when there is a server error" do
+    expect(subject.server_error?(error: Excon::Errors.status_error({}, Excon::Response.new(status: 500)))).to be true
+    expect(subject.server_error?(error: Excon::Errors.status_error({}, Excon::Response.new(status: 501)))).to be false
+    expect(subject.server_error?(error: Excon::Errors.status_error({}, Excon::Response.new(status: 502)))).to be true
+    expect(subject.server_error?(error: Excon::Errors.status_error({}, Excon::Response.new(status: 503)))).to be true
+    expect(subject.server_error?(error: Excon::Errors.status_error({}, Excon::Response.new(status: 504)))).to be true
+  end
+
+  it "should call do_backoff when throttled" do
+    throttled = Excon::Errors.status_error({}, throttling_response)
+    expect(subject).to receive(:do_backoff)
+    subject.error_call(error: throttled)
+  end
+
+  it "should call do_handoff when not throttled" do
+    bad_request = Excon::Errors.status_error({}, Excon::Response.new(status: 400))
+    expect(subject).to receive(:do_handoff)
+    subject.error_call(error: bad_request)
+  end
+
+  it "hands off correctly" do
+    datum = {}
+    expect(stack).to receive(:error_call).with(datum)
+    subject.do_handoff(datum)
+  end
+
+  context :do_backoff do
+    let(:connection) { double("connection") }
+    let(:datum) {
+      {
+       backoff: {
+                 retry_count: 1,
+                 max_delay: 10
+                },
+       connection: connection
+      }
+    }
+
+    before do
+      allow(connection).to receive(:request)
+      allow(subject).to receive(:do_sleep)
+    end
+
+    it "increments the request_count" do
+      subject.do_backoff(datum)
+      expect(datum[:backoff][:retry_count]).to be 2
+    end
+
+    it "restarts request call with a reset connection" do
+      expect(connection).to receive(:request).with({backoff: {max_delay: 10, retry_count: 2}})
+      subject.do_backoff(datum.merge(ignored_stuff: :foo))
+    end
+
+    it "sleeps for the specified time" do
+      allow(subject).to receive(:sleep_time) { 1.1 }
+      expect(subject).to receive(:do_sleep).with(1.1, datum)
+      subject.do_backoff(datum)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,49 @@
+require "excon/middleware/aws/exponential_backoff"
+
+module AWSErrorHelper
+  def throttling_response
+    body = %(
+      <ErrorResponse xmlns="http://some-service.amazonaws.com/doc/2010-05-15/">
+        <Error>
+          <Type>Sender</Type>
+          <Code>Throttling</Code>
+          <Message>Rate exceeded</Message>
+        </Error>
+      </ErrorResponse>
+    )
+
+    Excon::Response.new(status: 400, body: body)
+  end
+
+  def request_time_too_skewed_response
+    body = %(
+      <Error>
+        <Code>RequestTimeTooSkewed</Code>
+        <Message>The difference between the request time and the current time is too large.</Message>
+        <ServerTime>2006-11-10T13:43:55Z</ServerTime>
+        <MaxAllowedSkewMilliseconds>900000</MaxAllowedSkewMilliseconds>
+        <RequestTime>Fri, 10 Nov 2006 13:28:46 GMT</RequestTime>
+      </Error>
+    )
+
+    Excon::Response.new(status: 400, body: body)
+  end
+end
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+  config.disable_monkey_patching!
+  config.warnings = true
+  config.order = :random
+  Kernel.srand config.seed
+
+  config.include AWSErrorHelper
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: excon-middleware-aws-exponential_backoff
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Michael Hale
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- mike@hales.ws
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- excon-middleware-aws-exponential_backoff.gemspec
+- lib/excon/middleware/aws/exponential_backoff.rb
+- lib/excon/middleware/aws/exponential_backoff/include.rb
+- lib/excon/middleware/aws/exponential_backoff/version.rb
+- spec/exponential_backoff_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/mikehale/excon-middleware-aws-exponential_backoff
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Excon middleware to exponentially backoff calling AWS APIs when throttled
+  or experiencing errors.
+test_files:
+- spec/exponential_backoff_spec.rb
+- spec/spec_helper.rb