pebbles-river 0.3.4 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 849ea26964c3aa0eca352aafc7642748c4eb587f
-  data.tar.gz: f94b8412cffeffc29b4bffcddef89aaf7a7c91d4
+  metadata.gz: b095f1ed2b6aff2c1d4916c73503981169c7ac5a
+  data.tar.gz: f69bdbd2bc4cef2a857bc84555eb83342b1ed699
 SHA512:
-  metadata.gz: 795e37fc7303ae8811a3ee0754090ac6b4c4938cb1d51e760dc7c76fecf95dd00651ab400e5ace6370939d0760b79af60486bbd2508b7c1d82fb4ad49972b8ec
-  data.tar.gz: bfdd4900bb2eb74905cc3b6e0eab54251910c0fab32f49c750ca0ec24b3715ea351e72d593f3cbbfec9f7ff798817c28c515d689e4387ae836e50b94c7da580b
+  metadata.gz: e8e8da724df5dcaafd4d1f1acdb9a0b5dc7fa2a93e2cb01af110f5522a42b203bc011e8c2953f4f50057840cee1a9e0d1aa6a9f659c99f01a80926c67def385a
+  data.tar.gz: 49e9212ea4c0b3db87894dc15f6d9b2769e8f947f164cdcc1213dd7bf5d71321c9f27de4baccf078e0da9b85b64684baaadea8cbf9fac4fe95fe162ecaf9246c

data/lib/pebbles/river/river.rb

@@ -46,9 +46,7 @@ module Pebbles
         if @channel
           begin
             @channel.close
-          rescue Bunny::ChannelAlreadyClosed
-            # Ignore
-          rescue *CONNECTION_EXCEPTIONS
+          rescue Bunny::Exception
             # Ignore
           end
           @channel = nil
@@ -56,7 +54,7 @@ module Pebbles
         if @session
           begin
             @session.stop
-          rescue *CONNECTION_EXCEPTIONS
+          rescue Bunny::Exception
             # Ignore
           end
           @session = nil
@@ -112,9 +110,9 @@ module Pebbles
             retry_count = 0
             begin
               yield
-            rescue *CONNECTION_EXCEPTIONS => exception
+            rescue Bunny::Exception => e
               disconnect
-              last_exception = exception
+              last_exception = e
               retry_count += 1
               backoff(retry_count)
               retry

data/lib/pebbles/river/version.rb

@@ -1,5 +1,5 @@
 module Pebbles
   module River
-    VERSION = '0.3.4'
+    VERSION = '0.3.5'
   end
 end

data/lib/pebbles/river/worker.rb

@@ -136,23 +136,23 @@ module Pebbles
         def process_message(delivery_info, properties, content)
           begin
             message = Message.new(content, delivery_info, queue)
-          rescue => exception
+          rescue => e
             ignore_exceptions do
               reject(delivery_info)
             end
-            raise exception
+            raise e
           else
             begin
               result = @handler.call(message)
-            rescue *CONNECTION_EXCEPTIONS
+            rescue Bunny::Exception
               raise
-            rescue => exception
+            rescue => e
               if @managed_acking
                 ignore_exceptions do
                   reject(delivery_info)
                 end
               end
-              raise exception
+              raise e
             else
               if @managed_acking
                 case result
@@ -177,26 +177,19 @@ module Pebbles
         def with_exceptions(&block)
           begin
             yield
-          rescue *CONNECTION_EXCEPTIONS => exception
-            if @logger
-              @logger.error("Connection error (#{exception.class}): #{exception}")
-            end
-            @rate_limiter.increment
-            @queue = nil
-            @river.disconnect
+          rescue Bunny::Exception
+            raise
           rescue Timeout::Error
             if @logger
               @logger.error("Timeout polling for messages (ignoring)")
             end
-          rescue => exception
+          rescue => e
             if @logger
-              @logger.error("Exception (#{exception.class}) while handling message: #{exception}")
+              @logger.error("Exception (#{e.class}) while handling message: #{e}")
             end
-
             @rate_limiter.increment
-
             ignore_exceptions do
-              @on_exception.call(exception)
+              @on_exception.call(e)
             end
           end
         end

data/lib/pebbles/river.rb

@@ -18,12 +18,6 @@ require_relative "river/daemon_helper"
 
 module Pebbles::River
 
-  CONNECTION_EXCEPTIONS = [
-    Bunny::Exception,
-    # These should be caught by Bunny, but apparently aren't.
-    Errno::ECONNRESET
-  ].freeze
-
   def self.rabbitmq_options
     @rabbitmq_options ||= {}.freeze
   end

data/spec/lib/river_spec.rb

@@ -11,17 +11,6 @@ describe Pebbles::River::River do
     Pebbles::River::River.new(environment: 'whatever')
   end
 
-  CONNECTION_EXCEPTIONS = [
-    Bunny::ConnectionError,
-    Bunny::ConnectionClosedError,
-    Bunny::ChannelAlreadyClosed,
-    Bunny::ForcedChannelCloseError,
-    Bunny::ForcedConnectionCloseError,
-    Bunny::ServerDownError,
-    Bunny::ProtocolError,
-    Errno::ECONNRESET
-  ]
-
   after(:each) do
     if (channel = subject.channel)
       channel.queues.each do |name, queue|
@@ -100,73 +89,6 @@ describe Pebbles::River::River do
       JSON.parse(payload)['uid'].should eq('klass:path$1')
     end
 
-    CONNECTION_EXCEPTIONS.each do |exception_class|
-      context "on temporary failure with #{exception_class}" do
-        it "reconnects and retries sending until success" do
-          exchange = double('exchange')
-
-          count = 0
-          exchange.stub(:publish) do
-            count += 1
-            if count < 3
-              raise create_exception(exception_class)
-            end
-          end
-
-          subject.stub(:connect) { }
-          subject.stub(:exchange) { exchange }
-          subject.stub(:sleep) { }
-          Timeout.stub(:timeout) { |&block|
-            block.call
-          }
-          expect(Timeout).to receive(:timeout).at_least(1).times
-
-          expect(subject).to receive(:sleep).at_least(2).times
-          expect(subject).to receive(:connect).exactly(3).times
-          expect(subject).to receive(:disconnect).exactly(3).times
-
-          expect(exchange).to receive(:publish).at_least(2).times
-
-          subject.publish(event: 'explode', uid: 'thing:rspec$1')
-        end
-      end
-    end
-
-    CONNECTION_EXCEPTIONS.each do |exception_class|
-      context "on permanent failure with #{exception_class}" do
-        it "retries with exponential backoff until timeout and gives up with SendFailure" do
-          exchange = double('exchange')
-          exchange.stub(:publish) do
-            raise create_exception(exception_class)
-          end
-          subject.stub(:exchange) { exchange }
-
-          count, sleeps = 0, []
-          subject.stub(:sleep) { |t|
-            count += 1
-            if count >= 10
-              raise Timeout::Error
-            end
-            sleeps.push(t)
-          }
-
-          Timeout.stub(:timeout) { |&block|
-            block.call
-          }
-          expect(Timeout).to receive(:timeout).at_least(1).times
-
-          expect(subject).to receive(:disconnect).at_least(11).times
-
-          expect(-> { subject.publish({event: 'explode', uid: 'thing:rspec$1'})}).to raise_error do |e|
-            expect(e).to be_instance_of Pebbles::River::SendFailure
-            expect(e.connection_exception.class).to eq exception_class
-          end
-
-          expect(sleeps[0, 9]).to eq [1, 2, 4, 8, 10, 10, 10, 10, 10]
-        end
-      end
-    end
-
     context 'on connection timeout' do
       it "gives up with SendFailure" do
         exchange = double('exchange')

data/spec/lib/worker_spec.rb

@@ -203,71 +203,36 @@ describe Worker do
         end
       end
 
-      [
-        Bunny::ConnectionError,
-        Bunny::ChannelAlreadyClosed,
-        Bunny::ForcedChannelCloseError,
-        Bunny::ForcedConnectionCloseError,
-        Bunny::ServerDownError,
-        Bunny::ProtocolError,
-        Errno::ECONNRESET
-      ].each do |exception_class|
-        context "connection exception #{exception_class}" do
-          let :exception do
-            create_exception(exception_class)
-          end
-
-          let :handler do
-            handler = double('handler')
-            allow(handler).to receive(:call) {
-              raise exception
-            }
-            handler
-          end
-
-          it "performs connection reset on #{exception_class}" do
-            expect(handler).to receive(:call).with(message)
+      context "connection exception" do
+        let :exception do
+          Bunny::ConnectionError.new("error!")
+        end
 
-            expect(river).to receive(:connected?).with(no_args).at_least(1).times
-            expect(river).to_not receive(:connect)
-            expect(river).to receive(:queue).with({name: 'foo'})
-            expect(river).to receive(:disconnect).at_least(1).times
+        let :handler do
+          handler = double('handler')
+          allow(handler).to receive(:call) {
+            raise exception
+          }
+          handler
+        end
 
+        it "re-raises exception" do
+          expect(handler).to receive(:call).with(message)
+          expect(->() {
             subject.new(handler, queue: {name: 'foo'}).run_once
-          end
-
-          it "does not call #on_exception on connection error" do
-            on_exception_callback = double('on_connection_error')
-            on_exception_callback.stub(:call) { }
-            expect(on_exception_callback).to_not receive(:call)
-
-            expect(handler).to receive(:call).at_least(1).times
-
-            expect(river).to receive(:connected?).with(no_args).at_least(1).times
-            expect(river).to_not receive(:connect)
-            expect(river).to receive(:disconnect).at_least(1).times
+          }).to raise_error(Bunny::ConnectionError)
+        end
 
+        it "does not call #on_exception on connection error" do
+          on_exception_callback = double('on_connection_error')
+          on_exception_callback.stub(:call) { }
+          expect(on_exception_callback).to_not receive(:call)
+          expect(handler).to receive(:call).at_least(1).times
+          expect(->() {
             subject.new(handler,
               queue: {name: 'foo'},
               on_exception: on_exception_callback).run_once
-          end
-
-          it "logs error to logger" do
-            expect(handler).to receive(:call).with(message)
-
-            logger = double('logger')
-            logger.stub(:error) { }
-
-            # TODO: Test exception contents here
-            expect(logger).to receive(:error).
-              with(/.*/).at_least(1).times
-
-            river.stub(:disconnect)
-
-            subject.new(handler,
-              queue: {name: 'foo'},
-              logger: logger).run_once
-          end
+          }).to raise_error(Bunny::ConnectionError)
         end
       end
 

data/spec/spec_helper.rb

@@ -8,21 +8,6 @@ SimpleCov.start
 
 require_relative '../lib/pebbles/river'
 
-module SpecHelpers
-  def create_exception(exception_class)
-    # TODO: Using #allocate here because Bunny has a whole bunch
-    #   of exceptions; the one comparison against ECONNRESET is sad
-    #   and could be generalized
-    if exception_class == Errno::ECONNRESET
-      raise exception_class.new
-    else
-      raise exception_class.allocate
-    end
-  end
-end
-
 RSpec.configure do |config|
   config.mock_with :rspec
-  config.include SpecHelpers
 end
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pebbles-river
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
 platform: ruby
 authors:
 - Alexander Staubo