message-driver 0.6.1 → 0.7.0

data/features/support/firewall_helper.rb

@@ -20,7 +20,7 @@ module FirewallHelper
         'sudo service rabbitmq-server start'
       ]
     }
-  }
+  }.freeze
 
   def block_broker_port
     run_commands(:setup)
@@ -35,7 +35,7 @@ module FirewallHelper
   def run_commands(step)
     COMMANDS[os][step].each do |cmd|
       result = system(cmd)
-      fail "command `#{cmd}` failed!" unless result
+      raise "command `#{cmd}` failed!" unless result
     end
   end
 

data/features/support/no_error_matcher.rb

@@ -6,7 +6,7 @@ RSpec::Matchers.define :have_no_errors do
   failure_message do |test_runner|
     err = test_runner.raised_error
     filtered = (err.backtrace || []).reject do |line|
-      Cucumber::Ast::StepInvocation::BACKTRACE_FILTER_PATTERNS.find { |p| line =~ p }
+      Cucumber::Formatter::BACKTRACE_FILTER_PATTERNS.find { |p| line =~ p }
     end
     (["#{err.class}: #{err}"] + filtered).join("\n  ")
   end

data/lib/message_driver/adapters/base.rb

@@ -10,7 +10,7 @@ module MessageDriver
       end
 
       def initialize(_broker, _configuration)
-        fail 'Must be implemented in subclass'
+        raise 'Must be implemented in subclass'
       end
 
       def new_context
@@ -20,7 +20,7 @@ module MessageDriver
       end
 
       def build_context
-        fail 'Must be implemented in subclass'
+        raise 'Must be implemented in subclass'
       end
 
       def reset_after_tests
@@ -31,7 +31,7 @@ module MessageDriver
         if @contexts
           ctxs = @contexts
           @contexts = []
-          ctxs.each { |ctx| ctx.invalidate }
+          ctxs.each(&:invalidate)
         end
       end
     end
@@ -47,20 +47,56 @@ module MessageDriver
         @valid = true
       end
 
-      def publish(_destination, _body, _headers = {}, _properties = {})
-        fail 'Must be implemented in subclass'
+      def publish(destination, body, headers = {}, properties = {})
+        handle_publish(destination, body, headers, properties)
       end
 
-      def pop_message(_destination, _options = {})
-        fail 'Must be implemented in subclass'
+      def pop_message(destination, options = {})
+        handle_pop_message(destination, options)
       end
 
-      def subscribe(_destination, _options = {}, &_consumer)
-        fail "#subscribe is not supported by #{adapter.class}"
+      def subscribe(destination, options = {}, &consumer)
+        handle_subscribe(destination, options, &consumer)
       end
 
-      def create_destination(_name, _dest_options = {}, _message_props = {})
-        fail 'Must be implemented in subclass'
+      def create_destination(name, dest_options = {}, message_props = {})
+        handle_create_destination(name, dest_options, message_props)
+      end
+
+      def ack_message(message, options = {})
+        handle_ack_message(message, options)
+      end
+
+      def nack_message(message, options = {})
+        handle_nack_message(message, options)
+      end
+
+      def begin_transaction(options = {})
+        handle_begin_transaction(options)
+      end
+
+      def commit_transaction(options = {})
+        handle_commit_transaction(options)
+      end
+
+      def rollback_transaction(options = {})
+        handle_rollback_transaction(options)
+      end
+
+      def message_count(destination)
+        handle_message_count(destination)
+      end
+
+      def consumer_count(destination)
+        handle_consumer_count(destination)
+      end
+
+      def in_transaction?
+        if supports_transactions?
+          raise 'must be implemented in subclass'
+        else
+          raise "#in_transaction? not supported by #{adapter.class}"
+        end
       end
 
       def valid?
@@ -82,6 +118,74 @@ module MessageDriver
       def supports_subscriptions?
         false
       end
+
+      def handle_create_destination(_name, _dest_options = {}, _message_props = {})
+        raise 'Must be implemented in subclass'
+      end
+
+      def handle_publish(_destination, _body, _headers = {}, _properties = {})
+        raise 'Must be implemented in subclass'
+      end
+
+      def handle_pop_message(_destination, _options = {})
+        raise 'Must be implemented in subclass'
+      end
+
+      def handle_subscribe(_destination, _options = {}, &_consumer)
+        if supports_subscriptions?
+          raise 'Must be implemented in subclass'
+        else
+          raise "#subscribe is not supported by #{adapter.class}"
+        end
+      end
+
+      def handle_ack_message(_message, _options = {})
+        if supports_client_acks?
+          raise 'Must be implemented in subclass'
+        else
+          raise "#ack_message is not supported by #{adapter.class}"
+        end
+      end
+
+      def handle_nack_message(_message, _options = {})
+        if supports_client_acks?
+          raise 'Must be implemented in subclass'
+        else
+          raise "#nack_message is not supported by #{adapter.class}"
+        end
+      end
+
+      def handle_begin_transaction(_options = {})
+        if supports_transactions?
+          raise 'Must be implemented in subclass'
+        else
+          raise "transactions are not supported by #{adapter.class}"
+        end
+      end
+
+      def handle_commit_transaction(_options = {})
+        if supports_transactions?
+          raise 'Must be implemented in subclass'
+        else
+          raise "transactions are not supported by #{adapter.class}"
+        end
+      end
+
+      def handle_rollback_transaction(_options = {})
+        if supports_transactions?
+          raise 'Must be implemented in subclass'
+        else
+          raise "transactions are not supported by #{adapter.class}"
+        end
+      end
+
+      def handle_message_count(destination)
+        raise "#message_count is not supported by #{destination.class}"
+      end
+
+      def handle_consumer_count(destination)
+        raise "#consumer_count is not supported by #{destination.class}"
+      end
     end
   end
 end

data/lib/message_driver/adapters/bunny_adapter.rb

@@ -25,7 +25,7 @@ module MessageDriver
           raw_headers = properties[:headers]
           raw_headers = {} if raw_headers.nil?
           b, h, p = destination.middleware.on_consume(payload, raw_headers, properties)
-          super(ctx, b, h, p, raw_body)
+          super(ctx, destination, b, h, p, raw_body)
           @delivery_info = delivery_info
         end
 
@@ -59,10 +59,10 @@ module MessageDriver
         def after_initialize(adapter_context)
           if @dest_options[:no_declare]
             if @name.empty?
-              fail MessageDriver::Error, 'server-named queues must be declared, but you provided :no_declare => true'
+              raise MessageDriver::Error, 'server-named queues must be declared, but you provided :no_declare => true'
             end
             if @dest_options[:bindings]
-              fail MessageDriver::Error, 'queues with bindings must be declared, but you provided :no_declare => true'
+              raise MessageDriver::Error, 'queues with bindings must be declared, but you provided :no_declare => true'
             end
           else
             adapter_context.with_channel(false) do |ch|
@@ -73,7 +73,7 @@ module MessageDriver
 
         def bunny_queue(channel, options = {})
           opts = @dest_options.dup
-          opts.merge!(passive: options[:passive]) if options.key? :passive
+          opts[:passive] = options[:passive] if options.key? :passive
           queue = channel.queue(@name, opts)
           handle_queue_init(queue) if options.fetch(:init, false)
           queue
@@ -83,7 +83,7 @@ module MessageDriver
           @name = queue.name
           if (bindings = @dest_options[:bindings])
             bindings.each do |bnd|
-              fail MessageDriver::Error, "binding #{bnd.inspect} must provide a source!" unless bnd[:source]
+              raise MessageDriver::Error, "binding #{bnd.inspect} must provide a source!" unless bnd[:source]
               queue.bind(bnd[:source], bnd[:args] || {})
             end
           end
@@ -97,24 +97,24 @@ module MessageDriver
           @name
         end
 
-        def message_count
-          adapter.broker.client.current_adapter_context.with_channel(false) do |ch|
+        def handle_message_count
+          current_adapter_context.with_channel(false) do |ch|
             bunny_queue(ch, passive: true).message_count
           end
         end
 
         def subscribe(options = {}, &consumer)
-          adapter.broker.client.current_adapter_context.subscribe(self, options, &consumer)
+          current_adapter_context.subscribe(self, options, &consumer)
         end
 
-        def consumer_count
-          adapter.broker.client.current_adapter_context.with_channel(false) do |ch|
+        def handle_consumer_count
+          current_adapter_context.with_channel(false) do |ch|
             bunny_queue(ch, passive: true).consumer_count
           end
         end
 
         def purge
-          adapter.broker.client.current_adapter_context.with_channel(false) do |ch|
+          current_adapter_context.with_channel(false) do |ch|
             bunny_queue(ch).purge
           end
         end
@@ -125,14 +125,14 @@ module MessageDriver
           if (declare = @dest_options[:declare])
             adapter_context.with_channel(false) do |ch|
               type = declare.delete(:type)
-              fail MessageDriver::Error, 'you must provide a valid exchange type' unless type
+              raise MessageDriver::Error, 'you must provide a valid exchange type' unless type
               ch.exchange_declare(@name, type, declare)
             end
           end
           if (bindings = @dest_options[:bindings])
             adapter_context.with_channel(false) do |ch|
               bindings.each do |bnd|
-                fail MessageDriver::Error, "binding #{bnd.inspect} must provide a source!" unless bnd[:source]
+                raise MessageDriver::Error, "binding #{bnd.inspect} must provide a source!" unless bnd[:source]
                 ch.exchange_bind(bnd[:source], @name, bnd[:args] || {})
               end
             end
@@ -145,8 +145,8 @@ module MessageDriver
 
         def start
           unless destination.is_a? QueueDestination
-            fail MessageDriver::Error,
-                 'subscriptions are only supported with QueueDestinations'
+            raise MessageDriver::Error,
+                  'subscriptions are only supported with QueueDestinations'
           end
           @sub_ctx = adapter.new_subscription_context(self)
           @error_handler = options[:error_handler]
@@ -158,7 +158,7 @@ module MessageDriver
                               when :transactional
                                 TransactionalAckHandler.new(self)
                               else
-                                fail MessageDriver::Error, "unrecognized :ack option #{options[:ack]}"
+                                raise MessageDriver::Error, "unrecognized :ack option #{options[:ack]}"
                               end
           start_subscription
         end
@@ -305,14 +305,14 @@ module MessageDriver
           @require_commit = false
         end
 
-        def create_destination(name, dest_options = {}, message_props = {})
+        def handle_create_destination(name, dest_options = {}, message_props = {})
           dest =  case type = dest_options.delete(:type)
                   when :exchange
                     ExchangeDestination.new(adapter, name, dest_options, message_props)
                   when :queue, nil
                     QueueDestination.new(adapter, name, dest_options, message_props)
                   else
-                    fail MessageDriver::Error, "invalid destination type #{type}"
+                    raise MessageDriver::Error, "invalid destination type #{type}"
                   end
           dest.after_initialize(self)
           dest
@@ -322,33 +322,29 @@ module MessageDriver
           true
         end
 
-        def begin_transaction(options = {})
+        def handle_begin_transaction(options = {})
           if in_transaction?
-            fail MessageDriver::TransactionError,
-                 "you can't begin another transaction, you are already in one!"
+            raise MessageDriver::TransactionError,
+                  "you can't begin another transaction, you are already in one!"
           end
           @in_transaction = true
           @in_confirms_transaction = true if options[:type] == :confirm_and_wait
         end
 
-        def commit_transaction
+        def handle_commit_transaction(_ = nil)
           if !in_transaction? && !@require_commit
-            fail MessageDriver::TransactionError,
-                 "you can't finish the transaction unless you already in one!"
+            raise MessageDriver::TransactionError,
+                  "you can't finish the transaction unless you already in one!"
           end
           begin
             if @in_confirms_transaction
-              unless @rollback_only || @channel.nil?
-                @channel.wait_for_confirms
-              end
-            else
-              if is_transactional? && valid? && !@need_channel_reset && @require_commit
-                handle_errors do
-                  if @rollback_only
-                    @channel.tx_rollback
-                  else
-                    @channel.tx_commit
-                  end
+              @channel.wait_for_confirms unless @rollback_only || @channel.nil?
+            elsif is_transactional? && valid? && !@need_channel_reset && @require_commit
+              handle_errors do
+                if @rollback_only
+                  @channel.tx_rollback
+                else
+                  @channel.tx_commit
                 end
               end
             end
@@ -360,7 +356,7 @@ module MessageDriver
           end
         end
 
-        def rollback_transaction
+        def handle_rollback_transaction(_ = nil)
           @rollback_only = true
           commit_transaction
         end
@@ -368,13 +364,13 @@ module MessageDriver
         def transactional?
           @is_transactional
         end
-        alias_method :is_transactional?, :transactional?
+        alias is_transactional? transactional?
 
         def in_transaction?
           @in_transaction
         end
 
-        def publish(destination, body, headers = {}, properties = {})
+        def handle_publish(destination, body, headers = {}, properties = {})
           body, exchange, routing_key, props = *destination.publish_params(body, headers, properties)
           confirm = props.delete(:confirm)
           confirm = false if confirm.nil?
@@ -387,8 +383,8 @@ module MessageDriver
           end
         end
 
-        def pop_message(destination, options = {})
-          fail MessageDriver::Error, "You can't pop a message off an exchange" if destination.is_a? ExchangeDestination
+        def handle_pop_message(destination, options = {})
+          raise MessageDriver::Error, "You can't pop a message off an exchange" if destination.is_a? ExchangeDestination
 
           with_channel(false) do |ch|
             queue = ch.queue(destination.name, passive: true)
@@ -406,13 +402,13 @@ module MessageDriver
           true
         end
 
-        def ack_message(message, _options = {})
+        def handle_ack_message(message, _options = {})
           with_channel(true) do |ch|
             ch.ack(message.delivery_tag)
           end
         end
 
-        def nack_message(message, options = {})
+        def handle_nack_message(message, options = {})
           requeue = options.fetch(:requeue, true)
           with_channel(true) do |ch|
             ch.reject(message.delivery_tag, requeue)
@@ -423,12 +419,28 @@ module MessageDriver
           true
         end
 
-        def subscribe(destination, options = {}, &consumer)
+        def handle_subscribe(destination, options = {}, &consumer)
           sub = Subscription.new(adapter, destination, consumer, options)
           sub.start
           sub
         end
 
+        def handle_message_count(destination)
+          if destination.respond_to?(:handle_message_count)
+            destination.handle_message_count
+          else
+            super
+          end
+        end
+
+        def handle_consumer_count(destination)
+          if destination.respond_to?(:handle_consumer_count)
+            destination.handle_consumer_count
+          else
+            super
+          end
+        end
+
         def invalidate(in_unsubscribe = false)
           super()
           unless @subscription.nil? || in_unsubscribe
@@ -488,8 +500,8 @@ module MessageDriver
         end
 
         def with_channel(require_commit = true)
-          fail MessageDriver::TransactionRollbackOnly if @rollback_only
-          fail MessageDriver::Error, 'this adapter context is not valid!' unless valid?
+          raise MessageDriver::TransactionRollbackOnly if @rollback_only
+          raise MessageDriver::Error, 'this adapter context is not valid!' unless valid?
           ensure_channel
           @require_commit ||= require_commit
           if in_transaction?
@@ -535,7 +547,7 @@ module MessageDriver
         required = Gem::Requirement.create('>= 1.7.0')
         current = Gem::Version.create(Bunny::VERSION)
         unless required.satisfied_by? current
-          fail MessageDriver::Error, 'bunny 1.7.0 or later is required for the bunny adapter'
+          raise MessageDriver::Error, 'bunny 1.7.0 or later is required for the bunny adapter'
         end
       end
     end