message-driver 0.4.0 → 0.5.0

data/lib/message_driver/adapters/in_memory_adapter.rb

@@ -14,16 +14,14 @@ module MessageDriver
 
       class Subscription < MessageDriver::Subscription::Base
         def unsubscribe
-          adapter.remove_subscription_for(destination.name)
+          adapter.remove_subscription_for(destination.name, self)
         end
 
         def deliver_message(message)
-          begin
-            consumer.call(message)
-          rescue => e
-            unless options[:error_handler].nil?
-              options[:error_handler].call(e, message)
-            end
+          consumer.call(message)
+        rescue => e
+          unless options[:error_handler].nil?
+            options[:error_handler].call(e, message)
           end
         end
       end
@@ -37,48 +35,61 @@ module MessageDriver
           message_queue.size
         end
 
-        def pop_message(_options={})
-          message_queue.shift
+        def consumer_count
+          adapter.consumer_count_for(name)
         end
 
-        def subscribe(options={}, &consumer)
-          subscription = Subscription.new(adapter, self, consumer, options)
-          adapter.set_subscription_for(name, subscription)
-          until (msg = pop_message).nil?
-            subscription.deliver_message(msg)
+        def pop_message(_options = {})
+          message = message_queue.shift
+          if message.nil?
+            nil
+          else
+            raw_body = message.body
+            b, h, p = middleware.on_consume(message.body, message.headers, message.properties)
+            Message.new(nil, b, h, p, raw_body)
           end
+        end
+
+        def subscribe(options = {}, &consumer)
+          subscription = Subscription.new(adapter, self, consumer, options)
+          adapter.add_subscription_for(name, subscription)
+          deliver_messages(subscription)
           subscription
         end
 
-        def publish(body, headers={}, properties={})
-          msg = Message.new(nil, body, headers, properties)
-          sub = subscription
-          if sub.nil?
-            message_queue << msg
-          else
-            sub.deliver_message(msg)
-          end
+        def publish(body, headers = {}, properties = {})
+          raw_body = body
+          b, h, p = middleware.on_publish(body, headers, properties)
+          msg = Message.new(nil, b, h, p, raw_body)
+          message_queue << msg
+          deliver_messages(subscription) if subscription
         end
 
         private
 
+        def deliver_messages(sub)
+          until (msg = pop_message).nil?
+            sub.deliver_message(msg)
+          end
+        end
+
         def message_queue
           adapter.message_queue_for(name)
         end
       end
 
-      def initialize(broker, _config={})
+      def initialize(broker, _config = {})
         @broker = broker
         @destinations = {}
-        @message_store = Hash.new { |h,k| h[k] = [] }
-        @subscriptions = {}
+        @message_store = Hash.new { |h, k| h[k] = [] }
+        @subscriptions = Hash.new { |h, k| h[k] = [] }
       end
 
       def build_context
         InMemoryContext.new(self)
       end
 
-      def create_destination(name, dest_options={}, message_props={})
+      def create_destination(name, dest_options = {}, message_props = {})
         destination = Destination.new(self, name, dest_options, message_props)
         @destinations[name] = destination
       end
@@ -88,15 +99,15 @@ module MessageDriver
 
         def_delegators :adapter, :create_destination
 
-        def publish(destination, body, headers={}, properties={})
+        def publish(destination, body, headers = {}, properties = {})
           destination.publish(body, headers, properties)
         end
 
-        def pop_message(destination, options={})
+        def pop_message(destination, options = {})
           destination.pop_message(options)
         end
 
-        def subscribe(destination, options={}, &consumer)
+        def subscribe(destination, options = {}, &consumer)
           destination.subscribe(options, &consumer)
         end
 
@@ -122,15 +133,21 @@ module MessageDriver
       end
 
       def subscription_for(name)
-        @subscriptions[name]
+        sub = @subscriptions[name].shift
+        @subscriptions[name].push sub
+        sub
+      end
+
+      def add_subscription_for(name, subscription)
+        @subscriptions[name].push subscription
       end
 
-      def set_subscription_for(name, subscription)
-        @subscriptions[name] = subscription
+      def remove_subscription_for(name, subscription)
+        @subscriptions[name].delete(subscription)
       end
 
-      def remove_subscription_for(name)
-        @subscriptions.delete(name)
+      def consumer_count_for(name)
+        @subscriptions[name].size
       end
     end
   end

data/lib/message_driver/adapters/stomp_adapter.rb

@@ -19,6 +19,11 @@ module MessageDriver
       end
 
       class Destination < MessageDriver::Destination::Base
+        def queue_path
+          @queue_path ||= begin
+            name.start_with?('/') ? name : "/queue/#{name}"
+          end
+        end
       end
 
       attr_reader :config, :poll_timeout
@@ -43,29 +48,26 @@ module MessageDriver
 
         def_delegators :adapter, :with_connection, :poll_timeout
 
-        #def subscribe(destination, consumer)
-        #destination.subscribe(&consumer)
-        #end
+        # def subscribe(destination, consumer)
+        # destination.subscribe(&consumer)
+        # end
 
-        def create_destination(name, dest_options={}, message_props={})
-          unless name.start_with?('/')
-            name = "/queue/#{name}"
-          end
+        def create_destination(name, dest_options = {}, message_props = {})
           Destination.new(adapter, name, dest_options, message_props)
         end
 
-        def publish(destination, body, headers={}, _properties={})
+        def publish(destination, body, headers = {}, _properties = {})
           with_connection do |connection|
-            connection.publish(destination.name, body, headers)
+            connection.publish(destination.queue_path, body, headers)
           end
         end
 
-        def pop_message(destination, options={})
+        def pop_message(destination, options = {})
           with_connection do |connection|
             sub_id = connection.uuid
             msg = nil
             count = 0
-            connection.subscribe(destination.name, options, sub_id)
+            connection.subscribe(destination.queue_path, options, sub_id)
             while msg.nil? && count < max_poll_count
               msg = connection.poll
               if msg.nil?
@@ -73,7 +75,7 @@ module MessageDriver
                 sleep 0.1
               end
             end
-            connection.unsubscribe(destination.name, options, sub_id)
+            connection.unsubscribe(destination.queue_path, options, sub_id)
             Message.new(self, msg) if msg
           end
         end
@@ -90,26 +92,22 @@ module MessageDriver
       end
 
       def with_connection
-        begin
-          @connection ||= open_connection
-          yield @connection
-        rescue SystemCallError, IOError => e
-          raise MessageDriver::ConnectionError.new(e)
-        end
+        @connection ||= open_connection
+        yield @connection
+      rescue SystemCallError, IOError => e
+        raise MessageDriver::ConnectionError.new(e)
       end
 
       def stop
         super
-        if @connection
-          @connection.disconnect
-        end
+        @connection.disconnect if @connection
       end
 
       private
 
       def open_connection
         conn = Stomp::Connection.new(@config)
-        raise MessageDriver::ConnectionError, conn.connection_frame.to_s unless conn.open?
+        fail MessageDriver::ConnectionError, conn.connection_frame.to_s unless conn.open?
         conn
       end
 
@@ -117,7 +115,8 @@ module MessageDriver
         required = Gem::Requirement.create('~> 1.3.1')
         current = Gem::Version.create(Stomp::Version::STRING)
         unless required.satisfied_by? current
-          raise MessageDriver::Error, 'stomp 1.3.1 or a later version of the 1.3.x series is required for the stomp adapter'
+          fail MessageDriver::Error,
+               'stomp 1.3.1 or a later version of the 1.3.x series is required for the stomp adapter'
         end
       end
     end

data/lib/message_driver/broker.rb

@@ -9,7 +9,7 @@ module MessageDriver
     class << self
       def configure(name = DEFAULT_BROKER_NAME, options)
         if brokers.keys.include? name
-          raise BrokerAlreadyConfigured, "there is already a broker named #{name} configured"
+          fail BrokerAlreadyConfigured, "there is already a broker named #{name} configured"
         end
         brokers[name] = new(name, options)
       end
@@ -21,7 +21,8 @@ module MessageDriver
       def broker(name = DEFAULT_BROKER_NAME)
         result = brokers[name]
         if result.nil?
-          raise BrokerNotConfigured, "There is no broker named #{name} configured. The configured brokers are #{brokers.keys}"
+          fail BrokerNotConfigured,
+               "There is no broker named #{name} configured. The configured brokers are #{brokers.keys}"
         end
         result
       end
@@ -65,11 +66,11 @@ module MessageDriver
       private
 
       def brokers
-        @brokers ||= { }
+        @brokers ||= {}
       end
 
       def clients
-        @clients ||= { }
+        @clients ||= {}
       end
 
       def each_broker
@@ -107,36 +108,36 @@ module MessageDriver
     end
 
     def restart
-      unless stopped?
-        @adapter.stop
-      end
+      @adapter.stop unless stopped?
       @adapter = resolve_adapter(@configuration[:adapter], @configuration)
       @stopped = false
     end
 
-    def dynamic_destination(dest_name, dest_options={}, message_props={})
+    def dynamic_destination(dest_name, dest_options = {}, message_props = {})
       client.dynamic_destination(dest_name, dest_options, message_props)
     end
 
-    def destination(key, dest_name, dest_options={}, message_props={})
-      dest = self.dynamic_destination(dest_name, dest_options, message_props)
+    def destination(key, dest_name, dest_options = {}, message_props = {})
+      dest = dynamic_destination(dest_name, dest_options, message_props)
       @destinations[key] = dest
     end
 
     def consumer(key, &block)
-      raise MessageDriver::Error, 'you must provide a block' unless block_given?
+      fail MessageDriver::Error, 'you must provide a block' unless block_given?
       @consumers[key] = block
     end
 
     def find_destination(destination_name)
       destination = @destinations[destination_name]
-      raise MessageDriver::NoSuchDestinationError, "no destination #{destination_name} has been configured" if destination.nil?
+      if destination.nil?
+        fail MessageDriver::NoSuchDestinationError, "no destination #{destination_name} has been configured"
+      end
       destination
     end
 
     def find_consumer(consumer_name)
       consumer = @consumers[consumer_name]
-      raise MessageDriver::NoSuchConsumerError, "no consumer #{consumer_name} has been configured" if consumer.nil?
+      fail MessageDriver::NoSuchConsumerError, "no consumer #{consumer_name} has been configured" if consumer.nil?
       consumer
     end
 
@@ -145,7 +146,7 @@ module MessageDriver
     def resolve_adapter(adapter, options)
       case adapter
       when nil
-        raise 'you must specify an adapter'
+        fail 'you must specify an adapter'
       when Symbol, String
         resolve_adapter(find_adapter_class(adapter), options)
       when Class
@@ -153,7 +154,7 @@ module MessageDriver
       when MessageDriver::Adapters::Base
         adapter
       else
-        raise "adapter must be a MessageDriver::Adapters::Base, but this object is a #{adapter.class}"
+        fail "adapter must be a MessageDriver::Adapters::Base, but this object is a #{adapter.class}"
       end
     end
 
@@ -163,7 +164,11 @@ module MessageDriver
       adapter_method = "#{adapter_name}_adapter"
 
       unless respond_to?(adapter_method)
-        raise "the adapter #{adapter_name} must provide MessageDriver::Broker##{adapter_method} that returns the adapter class"
+        fail ['the adapter',
+              adapter_name,
+              'must provide',
+              "MessageDriver::Broker##{adapter_method}",
+              'that returns the adapter class'].join(' ')
       end
 
       send(adapter_method)

data/lib/message_driver/client.rb

@@ -5,35 +5,33 @@ module MessageDriver
     include Logging
     extend self
 
-    def publish(destination, body, headers={}, properties={})
-      dest = find_destination(destination)
-      current_adapter_context.publish(dest, body, headers, properties)
+    def publish(destination, body, headers = {}, properties = {})
+      find_destination(destination).publish(body, headers, properties)
     end
 
-    def pop_message(destination, options={})
-      dest = find_destination(destination)
-      current_adapter_context.pop_message(dest, options)
+    def pop_message(destination, options = {})
+      find_destination(destination).pop_message(options)
     end
 
-    def subscribe(destination_name, consumer_name, options={})
+    def subscribe(destination_name, consumer_name, options = {})
       consumer =  find_consumer(consumer_name)
       subscribe_with(destination_name, options, &consumer)
     end
 
-    def subscribe_with(destination_name, options={}, &consumer)
+    def subscribe_with(destination_name, options = {}, &consumer)
       destination = find_destination(destination_name)
       current_adapter_context.subscribe(destination, options, &consumer)
     end
 
-    def dynamic_destination(dest_name, dest_options={}, message_props={})
+    def dynamic_destination(dest_name, dest_options = {}, message_props = {})
       current_adapter_context.create_destination(dest_name, dest_options, message_props)
     end
 
-    def ack_message(message, options={})
+    def ack_message(message, options = {})
       message.ack(options)
     end
 
-    def nack_message(message, options={})
+    def nack_message(message, options = {})
       message.nack(options)
     end
 
@@ -54,7 +52,7 @@ module MessageDriver
       broker.find_consumer(consumer)
     end
 
-    def with_message_transaction(options={})
+    def with_message_transaction(options = {})
       wrapper = fetch_context_wrapper
       wrapper.increment_transaction_depth
       begin
@@ -84,13 +82,14 @@ module MessageDriver
       end
     end
 
-    def current_adapter_context(initialize=true)
+    def current_adapter_context(initialize = true)
       ctx = fetch_context_wrapper(initialize)
       ctx.nil? ? nil : ctx.ctx
     end
 
     def with_adapter_context(adapter_context)
-      old_ctx, Thread.current[adapter_context_key] = fetch_context_wrapper(false), build_context_wrapper(adapter_context)
+      old_ctx = fetch_context_wrapper(false)
+      Thread.current[adapter_context_key] = build_context_wrapper(adapter_context)
       begin
         yield
       ensure
@@ -132,7 +131,7 @@ module MessageDriver
 
     private
 
-    def fetch_context_wrapper(initialize=true)
+    def fetch_context_wrapper(initialize = true)
       wrapper = Thread.current[adapter_context_key]
       if wrapper.nil? || !wrapper.valid?
         if initialize
@@ -149,7 +148,7 @@ module MessageDriver
       Thread.current[adapter_context_key] = wrapper
     end
 
-    def build_context_wrapper(ctx=adapter.new_context)
+    def build_context_wrapper(ctx = adapter.new_context)
       ContextWrapper.new(ctx)
     end
 

data/lib/message_driver/destination.rb

@@ -10,24 +10,42 @@ module MessageDriver
         @message_props = message_props
       end
 
-      def publish(body, headers={}, properties={})
-        adapter.broker.client.publish(self, body, headers, properties)
+      def publish(body, headers = {}, properties = {})
+        current_adapter_context.publish(self, body, headers, properties)
       end
 
-      def pop_message(options={})
-        adapter.broker.client.pop_message(self, options)
+      def pop_message(options = {})
+        current_adapter_context.pop_message(self, options)
       end
 
       def after_initialize(_adapter_context)
-        #does nothing, feel free to override as needed
+        # does nothing, feel free to override as needed
       end
 
       def message_count
-        raise "#message_count is not supported by #{self.class}"
+        fail "#message_count is not supported by #{self.class}"
       end
 
-      def subscribe(&_consumer)
-        raise "#subscribe is not supported by #{self.class}"
+      def subscribe(_options = {}, &_consumer)
+        fail "#subscribe is not supported by #{self.class}"
+      end
+
+      def consumer_count
+        fail "#consumer_count is not supported by #{self.class}"
+      end
+
+      def middleware
+        @middleware ||= Middleware::MiddlewareStack.new(self)
+      end
+
+      private
+
+      def current_adapter_context
+        adapter.broker.client.current_adapter_context
+      end
+
+      def client
+        @client ||= adapter.broker.client
       end
     end
   end