aptible-resource 0.3.8 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a3754a5511515adb9046e4880d742c872779fb6d
-  data.tar.gz: 113ad8d809c64b1b7cfdafd5c522ad598f161d37
+  metadata.gz: dded993c5744f3cdda2e692ac1ad19dc5d45a334
+  data.tar.gz: d2351212650888e95d0ae6847a0d02cd82f4eaad
 SHA512:
-  metadata.gz: a3e134dc2dcbec98c6717577eb8e9500b3d0aacfd53921b21d0703f76340217951dfe54e30ac53c5e30e7a32b561e874b1743b38383eb702b9857a071c154f74
-  data.tar.gz: 3a30508f4289cfe2075e0852fee14f529cc9211e2723e7617c13e9f85f8c7eb226dbf29246146c3003c0865b1fad79adf9c0d94e36af8575dee8f4e95f9dc141
+  metadata.gz: 4a0e35ad0dd2a1e845edbcd42e74c7242ad1be592dc78fb61f8f102ead28eeb279aa435cb2fb2508a06c482a228e7717a78ef9c2c1d24bff427f4da2b76f2c39
+  data.tar.gz: 3e65e843ce94ba3a907683639c4b9dad74a8f8926cb14fb4cf536405d5fe48c3a968494e485a587ecbf5f55f875a4143235ec05da86351645cc7ae15dbf824dc

data/aptible-resource.gemspec

@@ -33,5 +33,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec', '~> 2.0'
   spec.add_development_dependency 'pry'
-  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'webmock', '~> 2.3.2'
 end

data/lib/aptible/resource.rb

@@ -1,12 +1,15 @@
 require 'aptible/resource/version'
 require 'aptible/resource/base'
 require 'aptible/resource/default_retry_coordinator'
+require 'aptible/resource/null_retry_coordinator'
 require 'gem_config'
 
 module Aptible
   module Resource
     include GemConfig::Base
 
+    RETRY_COORDINATOR_OVERRIDE = :override_retry_coordinator_class
+
     with_configuration do
       has :retry_coordinator_class,
           classes: [Class],
@@ -16,5 +19,26 @@ module Aptible
           classes: [String],
           default: "aptible-resource #{Aptible::Resource::VERSION}"
     end
+
+    class << self
+      def without_retry(&block)
+        override_retry_coordinator_class(
+          Aptible::Resource::NullRetryCoordinator, &block
+        )
+      end
+
+      def override_retry_coordinator_class(klass)
+        Thread.current[RETRY_COORDINATOR_OVERRIDE] = klass
+        yield if block_given?
+      ensure
+        Thread.current[RETRY_COORDINATOR_OVERRIDE] = nil
+      end
+
+      def retry_coordinator_class
+        override = Thread.current[RETRY_COORDINATOR_OVERRIDE]
+        return override if override
+        configuration.retry_coordinator_class
+      end
+    end
   end
 end

data/lib/aptible/resource/base.rb

@@ -12,9 +12,6 @@ require 'aptible/resource/adapter'
 require 'aptible/resource/errors'
 require 'aptible/resource/boolean'
 
-# Open errors that make sense
-require 'aptible/resource/ext/faraday'
-
 module Aptible
   module Resource
     # rubocop:disable ClassLength
@@ -289,6 +286,11 @@ module Aptible
 
       def delete
         super
+      rescue HyperResource::ServerError
+        raise
+      rescue HyperResource::ClientError => e
+        # Already deleted
+        raise unless e.response.status == 404
       rescue HyperResource::ResponseError
         # HyperResource/Faraday choke on empty response bodies
         nil

data/lib/aptible/resource/default_retry_coordinator.rb

@@ -1,14 +1,36 @@
 module Aptible
   module Resource
     class DefaultRetryCoordinator
-      attr_reader :resource
+      attr_reader :resource, :retry_schedule
+
+      IDEMPOTENT_METHODS = [
+        # Idempotent as per RFC
+        :delete, :get, :head, :options, :put,
+        # Idempotent on our APIs
+        :patch
+      ].freeze
+      RETRY_ERRORS = [Faraday::Error, HyperResource::ServerError].freeze
 
       def initialize(resource)
         @resource = resource
+        @retry_schedule = new_retry_schedule
+      end
+
+      def retry?(method, err)
+        # rubocop:disable Style/CaseEquality
+        return false unless RETRY_ERRORS.any? { |c| c === err }
+        return false unless IDEMPOTENT_METHODS.include?(method)
+        retry_in = retry_schedule.shift
+        return false if retry_in.nil?
+        sleep retry_in
+        true
+        # rubocop:enable Style/CaseEquality
       end
 
-      def retry?(_error)
-        false
+      private
+
+      def new_retry_schedule
+        [0.2, 0.8, 2]
       end
     end
   end

data/lib/aptible/resource/null_retry_coordinator.rb

@@ -0,0 +1,12 @@
+module Aptible
+  module Resource
+    class NullRetryCoordinator
+      def initialize(_)
+      end
+
+      def retry?(_, _)
+        false
+      end
+    end
+  end
+end

data/lib/aptible/resource/version.rb

@@ -1,5 +1,5 @@
 module Aptible
   module Resource
-    VERSION = '0.3.8'.freeze
+    VERSION = '0.4.0'.freeze
   end
 end

data/lib/hyper_resource.rb

@@ -10,6 +10,7 @@ require 'hyper_resource/adapter'
 require 'hyper_resource/adapter/hal_json'
 
 require 'hyper_resource/modules/http'
+require 'hyper_resource/modules/http/wrap_errors'
 require 'hyper_resource/modules/internal_attributes'
 
 require 'rubygems' if RUBY_VERSION[0..2] == '1.8'

data/lib/hyper_resource/attributes.rb

@@ -59,6 +59,7 @@ class HyperResource
     ## Returns a hash of the attributes and values which have been changed
     ## since creation time.
     def changed_attributes
+      return {} if @_hr_changed.nil?
       @_hr_changed.select{|k,v| v}.keys.inject({}) {|h,k| h[k]=self[k]; h}
     end
 

data/lib/hyper_resource/exceptions.rb

@@ -27,7 +27,7 @@ class HyperResource
           message = "#{message} (#{error})"
         end
       elsif self.response
-        message = "#{message} (\"#{self.response.inspect}\")"
+        message = "#{message} (#{response.body})"
       end
 
       super(message, attrs)

data/lib/hyper_resource/modules/http.rb

@@ -78,8 +78,8 @@ class HyperResource
             builder.basic_auth(*ba)
           end
 
+          builder.use WrapErrors # This has to be first!
           builder.request :url_encoded
-          builder.request :retry
           builder.adapter Faraday.default_adapter
         end
       end
@@ -88,32 +88,35 @@ class HyperResource
 
       def execute_request
         raise 'execute_request needs a block!' unless block_given?
-        retry_coordinator = Aptible::Resource.configuration
-                                             .retry_coordinator_class.new(self)
+        retry_coordinator = Aptible::Resource.retry_coordinator_class.new(self)
 
         n_retry = 0
+
         begin
-          finish_up(yield)
-        rescue HyperResource::ResponseError => e
+          begin
+            finish_up(yield)
+          rescue HyperResource::ResponseError => e
+            raise WrapErrors::WrappedError.new(e.response.env.method, e)
+          end
+        rescue WrapErrors::WrappedError => e
           n_retry += 1
-          raise e if n_retry > MAX_COORDINATOR_RETRIES
-          retry if retry_coordinator.retry?(e)
-          raise e
+          raise e.err if n_retry > MAX_COORDINATOR_RETRIES
+          retry if retry_coordinator.retry?(e.method, e.err)
+          raise e.err
         end
       end
 
       def finish_up(response)
+        body = adapter_error = nil
+
         begin
           body = adapter.deserialize(response.body) unless response.body.nil?
         rescue StandardError => e
-          raise HyperResource::ResponseError.new(
-            'Error when deserializing response body',
-            response: response,
-            cause: e
-          )
+          adapter_error = e
         end
 
         status = response.status
+
         if status / 100 == 2
         elsif status / 100 == 3
           raise 'HyperResource does not handle redirects'
@@ -133,6 +136,14 @@ class HyperResource
 
         end
 
+        if adapter_error
+          raise HyperResource::ResponseError.new(
+            'Error when deserializing response body',
+            response: response,
+            cause: e
+          )
+        end
+
         # Unfortunately, HyperResource insists on having response and body
         # be attributes..
         self.response = response

data/lib/hyper_resource/modules/http/wrap_errors.rb

@@ -0,0 +1,22 @@
+class HyperResource
+  module Modules
+    module HTTP
+      class WrapErrors < Faraday::Middleware
+        class WrappedError < StandardError
+          attr_reader :method, :err
+
+          def initialize(method, err)
+            @method = method
+            @err = err
+          end
+        end
+
+        def call(env)
+          @app.call(env)
+        rescue StandardError => e
+          raise WrappedError.new(env.method, e)
+        end
+      end
+    end
+  end
+end

data/spec/aptible/resource/base_spec.rb

@@ -32,7 +32,7 @@ describe Aptible::Resource::Base do
       end
 
       [Api, Api::Mainframe].each do |klass|
-        allow_any_instance_of(klass).to receive(:find_by_url) do |u, _|
+        allow_any_instance_of(klass).to receive(:find_by_url) do |_, u, _|
           calls << u
           page = pages[u]
           raise "Accessed unexpected URL #{u}" if page.nil?
@@ -267,6 +267,18 @@ describe Aptible::Resource::Base do
     end
   end
 
+  describe '#delete' do
+    it 'allows an empty response' do
+      stub_request(:delete, subject.root_url).to_return(body: '', status: 200)
+      expect(subject.delete).to be_nil
+    end
+
+    it 'ignores 404s' do
+      stub_request(:delete, subject.root_url).to_return(body: '', status: 404)
+      expect(subject.delete).to be_nil
+    end
+  end
+
   context '.has_many' do
     let(:mainframe) { Api::Mainframe.new }
     let(:mainframes_link) { HyperResource::Link.new(href: '/mainframes') }
@@ -401,7 +413,7 @@ describe Aptible::Resource::Base do
 
     context 'retry_coordinator_class' do
       it 'should not retry if the proc returns false' do
-        configure_new_coordinator { define_method(:retry?) { |_e| false } }
+        configure_new_coordinator { define_method(:retry?) { |_, _e| false } }
 
         stub_request(:get, 'foo.com')
           .to_return(body: { error: 'foo' }.to_json, status: 401).then
@@ -412,7 +424,7 @@ describe Aptible::Resource::Base do
       end
 
       it 'should retry if the proc returns true' do
-        configure_new_coordinator { define_method(:retry?) { |_e| true } }
+        configure_new_coordinator { define_method(:retry?) { |_, _e| true } }
 
         stub_request(:get, 'foo.com')
           .to_return(body: { error: 'foo' }.to_json, status: 401).then
@@ -426,7 +438,7 @@ describe Aptible::Resource::Base do
         failures = 0
 
         configure_new_coordinator do
-          define_method(:retry?) { |_e| failures += 1 || true }
+          define_method(:retry?) { |_, _e| failures += 1 || true }
         end
 
         stub_request(:get, 'foo.com')
@@ -454,7 +466,7 @@ describe Aptible::Resource::Base do
 
         configure_new_coordinator do
           define_method(:initialize) { |r| resource = r }
-          define_method(:retry?) { |e| (exception = e) && false }
+          define_method(:retry?) { |_, e| (exception = e) && false }
         end
 
         stub_request(:get, 'foo.com')
@@ -472,7 +484,7 @@ describe Aptible::Resource::Base do
         retry_was_called = false
 
         configure_new_coordinator do
-          define_method(:retry?) do |_e|
+          define_method(:retry?) do |_, _e|
             resource.token = 'bar'
             # resource.headers['Authorization'] = 'Bearer bar'
             retry_was_called = true
@@ -495,7 +507,7 @@ describe Aptible::Resource::Base do
         n = 0
 
         configure_new_coordinator do
-          define_method(:retry?) { |_e| n += 1 || true }
+          define_method(:retry?) { |_, _e| n += 1 || true }
         end
 
         stub_request(:get, 'foo.com')

data/spec/aptible/resource/retry_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+# With webmock (fake connections), to check how we handle timeouts.
+describe Aptible::Resource::Base do
+  let(:body) do
+    { 'hello' => '1', '_links' => { 'self' => { 'href' => href } } }
+  end
+  let(:json_body) { JSON.unparse(body) }
+  let(:href) { 'https://resource.example.com/mainframes/1' }
+
+  subject do
+    stub = stub_request(:get, href).to_return(body: json_body)
+    begin
+      Api::Mainframe.find(1)
+    ensure
+      remove_request_stub(stub)
+    end
+  end
+
+  let(:sleeps) { [] }
+
+  def time_slept
+    sleeps.sum
+  end
+
+  before do
+    allow_any_instance_of(Aptible::Resource::DefaultRetryCoordinator)
+      .to receive(:sleep) { |_, t| sleeps << t }
+  end
+
+  context 'server errors' do
+    shared_examples 'retry examples' do |method|
+      context "#{method.to_s.upcase} requests" do
+        it 'should retry a server error' do
+          stub_request(method, href)
+            .to_return(body: { error: 'foo' }.to_json, status: 500).then
+            .to_return(body: json_body)
+
+          expect(subject.public_send(method).body).to eq(body)
+        end
+
+        it 'should retry a server error with no body' do
+          stub_request(method, href)
+            .to_return(body: '', status: 502).then
+            .to_return(body: json_body)
+
+          expect(subject.public_send(method).body).to eq(body)
+        end
+
+        it 'should eventually give up' do
+          stub_request(method, href)
+            .to_return(body: { error: 'foo' }.to_json, status: 500)
+
+          expect { subject.public_send(method) }
+            .to raise_error(HyperResource::ServerError)
+        end
+
+        it 'should not retry a client error' do
+          stub_request(method, href)
+            .to_return(body: { error: 'foo' }.to_json, status: 400).then
+            .to_return(body: json_body)
+
+          expect { subject.public_send(method) }
+            .to raise_error(HyperResource::ClientError)
+        end
+
+        it 'should not retry parse errors' do
+          stub_request(method, href)
+            .to_return(body: 'boo', status: 400).then
+            .to_return(body: json_body)
+
+          expect { subject.public_send(method) }
+            .to raise_error(HyperResource::ResponseError)
+        end
+      end
+    end
+
+    include_examples 'retry examples', :delete
+    include_examples 'retry examples', :get
+    include_examples 'retry examples', :put
+    include_examples 'retry examples', :patch
+
+    context 'POST requests' do
+      it 'should not retry a server error' do
+        stub_request(:post, href)
+          .to_return(body: { error: 'foo' }.to_json, status: 504).then
+          .to_return(body: json_body)
+
+        expect { subject.post }
+          .to raise_error(HyperResource::ServerError)
+
+        expect(time_slept).to eq(0)
+      end
+    end
+
+    context 'retry coordinator overrides' do
+      before do
+        stub_request(:get, href)
+          .to_return(body: { error: 'foo' }.to_json, status: 500).then
+          .to_return(body: { status: 'ok' }.to_json, status: 200)
+      end
+
+      it 'should be overridden by override_retry_coordinator_class ' do
+        expect do
+          klass = Aptible::Resource::NullRetryCoordinator
+          Aptible::Resource.override_retry_coordinator_class(klass) do
+            subject.get
+          end
+        end.to raise_error(HyperResource::ServerError)
+      end
+
+      it 'should disable retries with override_retry_coordinator_class' do
+        expect { Aptible::Resource.without_retry { subject.get } }
+          .to raise_error(HyperResource::ServerError)
+      end
+    end
+  end
+
+  context 'network errors' do
+    context 'with mock connections' do
+      it 'should retry timeout errors' do
+        stub_request(:get, href)
+          .to_timeout.then
+          .to_timeout.then
+          .to_return(body: json_body)
+
+        expect(subject.get.body).to eq(body)
+      end
+
+      it 'should retry timeout errors (Errno::ETIMEDOUT)' do
+        stub_request(:get, href)
+          .to_raise(Errno::ETIMEDOUT).then
+          .to_raise(Errno::ETIMEDOUT).then
+          .to_return(body: json_body)
+
+        expect(subject.get.body).to eq(body)
+      end
+
+      it 'should retry timeout errors (Net::OpenTimeout)' do
+        stub_request(:get, href)
+          .to_raise(Net::OpenTimeout).then
+          .to_raise(Net::OpenTimeout).then
+          .to_return(body: json_body)
+
+        expect(subject.get.body).to eq(body)
+      end
+
+      it 'should retry connection errors' do
+        stub_request(:get, href)
+          .to_raise(Errno::ECONNREFUSED).then
+          .to_raise(Errno::ECONNREFUSED).then
+          .to_return(body: json_body)
+
+        expect(subject.get.body).to eq(body)
+      end
+
+      it 'should not retry POSTs' do
+        stub_request(:post, href)
+          .to_timeout.then
+          .to_return(body: json_body)
+
+        expect { subject.post }.to raise_error(Faraday::ConnectionFailed)
+      end
+    end
+
+    context 'without connections' do
+      around do |example|
+        WebMock.allow_net_connect!
+        example.run
+        WebMock.disable_net_connect!
+      end
+
+      it 'default to 10 seconds of timeout and retries 4 times' do
+        # This really relies on how exactly MRI implements Net::HTTP open
+        # timeouts
+        skip 'MRI implementation-specific' if RUBY_PLATFORM == 'java'
+
+        expect(Timeout).to receive(:timeout)
+          .with(10, Net::OpenTimeout)
+          .exactly(4).times
+          .and_raise(Net::OpenTimeout)
+
+        expect { subject.get }.to raise_error(Faraday::ConnectionFailed)
+        expect(sleeps.size).to eq(3)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -20,4 +20,8 @@ WebMock.disable_net_connect!
 RSpec.configure do |config|
   config.before { Aptible::Resource.configuration.reset }
   config.before { WebMock.reset! }
+
+  config.mock_with :rspec do |mocks|
+    mocks.yield_receiver_to_any_instance_implementation_blocks = true
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aptible-resource
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.4.0
 platform: ruby
 authors:
 - Frank Macreery
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-28 00:00:00.000000000 Z
+date: 2017-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uri_template
@@ -174,16 +174,16 @@ dependencies:
   name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.3.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.3.2
 description: Foundation classes for Aptible resource server gems
 email:
 - frank@macreery.com
@@ -206,7 +206,7 @@ files:
 - lib/aptible/resource/boolean.rb
 - lib/aptible/resource/default_retry_coordinator.rb
 - lib/aptible/resource/errors.rb
-- lib/aptible/resource/ext/faraday.rb
+- lib/aptible/resource/null_retry_coordinator.rb
 - lib/aptible/resource/version.rb
 - lib/hyper_resource.rb
 - lib/hyper_resource/adapter.rb
@@ -216,12 +216,13 @@ files:
 - lib/hyper_resource/link.rb
 - lib/hyper_resource/links.rb
 - lib/hyper_resource/modules/http.rb
+- lib/hyper_resource/modules/http/wrap_errors.rb
 - lib/hyper_resource/modules/internal_attributes.rb
 - lib/hyper_resource/objects.rb
 - lib/hyper_resource/response.rb
 - lib/hyper_resource/version.rb
 - spec/aptible/resource/base_spec.rb
-- spec/aptible/resource/network_spec.rb
+- spec/aptible/resource/retry_spec.rb
 - spec/fixtures/api.rb
 - spec/fixtures/mainframe.rb
 - spec/fixtures/token.rb
@@ -252,7 +253,7 @@ specification_version: 4
 summary: Foundation classes for Aptible resource server gems
 test_files:
 - spec/aptible/resource/base_spec.rb
-- spec/aptible/resource/network_spec.rb
+- spec/aptible/resource/retry_spec.rb
 - spec/fixtures/api.rb
 - spec/fixtures/mainframe.rb
 - spec/fixtures/token.rb

data/lib/aptible/resource/ext/faraday.rb

@@ -1,5 +0,0 @@
-Faraday::Adapter::NetHttp.class_eval do |cls|
-  # Work around https://github.com/lostisland/faraday/issues/561 by treating
-  # connection timeouts as... timeouts.
-  cls::NET_HTTP_EXCEPTIONS.delete Net::OpenTimeout if defined?(Net::OpenTimeout)
-end

data/spec/aptible/resource/network_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-# With webmock (fake connections), to check how we handle timeouts.
-describe Aptible::Resource::Base do
-  let(:body) { { 'hello' => '1' } }
-  let(:json_body) { JSON.unparse(body) }
-  let(:domain) { 'api.aptible.com' }
-
-  subject { Api.new(root: "http://#{domain}") }
-
-  context 'with mock connections' do
-    it 'should retry timeout errors' do
-      stub_request(:get, domain)
-        .to_timeout.then
-        .to_timeout.then
-        .to_return(body: json_body)
-
-      expect(subject.get.body).to eq(body)
-    end
-
-    it 'should not retry POSTs' do
-      stub_request(:post, domain)
-        .to_timeout.then
-        .to_return(body: json_body)
-
-      expect { subject.post }.to raise_error(Faraday::TimeoutError)
-    end
-  end
-
-  context 'without connections' do
-    around do |example|
-      WebMock.allow_net_connect!
-      example.run
-      WebMock.disable_net_connect!
-    end
-
-    it 'default to 10 seconds of timeout and retry 3 times' do
-      # This really relies on how exactly MRI implements Net::HTTP open timeouts
-      skip 'MRI implementation-specific' if RUBY_PLATFORM == 'java'
-
-      expect(Timeout).to receive(:timeout)
-        .with(10, Net::OpenTimeout)
-        .exactly(3).times
-        .and_raise(Net::OpenTimeout)
-
-      expect { subject.all }.to raise_error(Faraday::Error::TimeoutError)
-    end
-  end
-end