activemessaging 0.6.1 → 0.7.1

data/lib/activemessaging/adapters/stomp.rb

@@ -1,41 +1,82 @@
 require 'stomp'
 
+require 'activemessaging/adapters/base'
+
 module ActiveMessaging
   module Adapters
     module Stomp
-
-      class Connection < ::Stomp::Connection
-        include ActiveMessaging::Adapter
+      
+      class Connection < ActiveMessaging::Adapters::BaseConnection
         register :stomp
 
-        attr_accessor :reliable, :retryMax, :deadLetterQueue
+        attr_accessor :stomp_connection, :retryMax, :deadLetterQueue, :configuration
 
         def initialize(cfg)
           @retryMax = cfg[:retryMax] || 0
           @deadLetterQueue = cfg[:deadLetterQueue] || nil
-          
+        
           cfg[:login] ||= ""
           cfg[:passcode] ||= ""
           cfg[:host] ||= "localhost"
           cfg[:port] ||= "61613"
-          cfg[:reliable] ||= TRUE
+          cfg[:reliable]  = cfg[:reliable].nil? ? TRUE : cfg[:reliable].nil?
           cfg[:reconnectDelay] ||= 5
           cfg[:clientId] ||= nil
-          
-          if cfg[:clientId]
-            super(cfg[:login],cfg[:passcode],cfg[:host],cfg[:port].to_i,cfg[:reliable],cfg[:reconnectDelay],cfg[:clientId])
-          else
-            super(cfg[:login],cfg[:passcode],cfg[:host],cfg[:port].to_i,cfg[:reliable],cfg[:reconnectDelay])
-          end
 
+          # hold on to the config
+          @configuration = cfg
+
+          # create a new stomp connection
+          connect_headers = {}
+          connect_headers['client-id'] = cfg[:clientId] if cfg[:clientId]
+          @stomp_connection = ::Stomp::Connection.new(cfg[:login],cfg[:passcode],cfg[:host],cfg[:port].to_i,cfg[:reliable],cfg[:reconnectDelay], connect_headers)
         end
-        
+      
+        # called to cleanly get rid of connection
+        def disconnect
+          @stomp_connection.disconnect
+        end
+
+        # destination_name string, headers hash
+        # subscribe to listen on a destination
+        def subscribe destination_name, message_headers={}
+          @stomp_connection.subscribe(destination_name, message_headers)
+        end
+
+        # destination_name string, headers hash
+        # unsubscribe to listen on a destination
+        def unsubscribe destination_name, message_headers={}
+          @stomp_connection.unsubscribe(destination_name, message_headers)
+        end
+
+        # destination_name string, body string, headers hash
+        # send a single message to a destination
+        def send destination_name, message_body, message_headers={}
+          stomp_publish(destination_name, message_body, message_headers)
+        end
+
+        # receive a single message from any of the subscribed destinations
+        # check each destination once, then sleep for poll_interval
+        def receive
+          m = @stomp_connection.receive
+          Message.new(m) if m
+        end
+      
         def received message, headers={}
           #check to see if the ack mode for this subscription is auto or client
           # if the ack mode is client, send an ack
           if (headers[:ack] === 'client')
-            ack_headers = message.headers.has_key?(:transaction) ? message.headers[:transaction] : {}
-            ack message.headers['message-id'], ack_headers
+            ack_headers = message.headers.has_key?(:transaction) ? { :transaction=>message.headers[:transaction]} : {}
+            @stomp_connection.ack(message.headers['message-id'], ack_headers)
+          end
+        end
+        
+        # send has been deprecated in latest stomp gem (as it should be)
+        def stomp_publish(destination_name="", message_body="", message_headers={})
+          if @stomp_connection.respond_to?(:publish)
+            @stomp_connection.publish(destination_name, message_body, message_headers)
+          else
+            @stomp_connection.send(destination_name, message_body, message_headers)
           end
         end
 
@@ -44,7 +85,7 @@ module ActiveMessaging
           transaction_id = "transaction-#{message.headers['message-id']}-#{retry_count}"
 
           # start a transaction, send the message back to the original destination
-          self.begin(transaction_id)
+          @stomp_connection.begin(transaction_id)
           begin
 
             if @retryMax > 0
@@ -53,6 +94,8 @@ module ActiveMessaging
               retry_headers.delete('content-length')
               retry_headers.delete('content-type')
               
+              retry_destination = retry_headers.delete('destination')
+            
               if retry_count < @retryMax
                 # now send the message back to the destination
                 #  set the headers for message id, priginal message id, and retry count
@@ -65,13 +108,15 @@ module ActiveMessaging
                 retry_headers['a13g-retry-count'] = retry_count + 1
 
                 # send the updated message to retry in the same transaction
-                self.send retry_headers['destination'], message.body, retry_headers
+                self.stomp_publish(retry_destination, message.body, retry_headers)
 
               elsif retry_count >= @retryMax && @deadLetterQueue
-                # send the 'poison pill' message to the dead letter queue
+                # send the 'poison pill' message to the dead letter queue - make it persistent by default
                 retry_headers['a13g-original-destination'] = retry_headers.delete('destination')
+                retry_headers['persistent'] = true
                 retry_headers.delete('message-id')
-                self.send @deadLetterQueue, message.body, retry_headers
+
+                self.stomp_publish(@deadLetterQueue, message.body, retry_headers)
               end
 
             end
@@ -79,14 +124,14 @@ module ActiveMessaging
             #check to see if the ack mode is client, and if it is, ack it in this transaction
             if (headers[:ack] === 'client')
               # ack the original message
-              self.ack message.headers['message-id'], message.headers.stringify_keys.merge('transaction'=>transaction_id)
+              @stomp_connection.ack(message.headers['message-id'], message.headers.stringify_keys.merge('transaction'=>transaction_id))
             end
 
             # now commit the transaction
-            self.commit transaction_id
+            @stomp_connection.commit transaction_id
           rescue Exception=>exc
             # if there is an error, try to abort the transaction, then raise the error
-            self.abort transaction_id
+            @stomp_connection.abort transaction_id
             raise exc
           end
 
@@ -94,6 +139,29 @@ module ActiveMessaging
 
       end
       
+      class Message < ActiveMessaging::BaseMessage
+
+        def initialize(msg)
+          super(msg.body, msg.headers['message-id'], msg.headers, msg.headers['destination'])
+        end
+
+        def matches_subscription?(subscription)
+          # if the subscription has been specified in the headers, rely on this
+          if self.headers['subscription'] && subscription.subscribe_headers['id']
+            self.headers['subscription'].to_s == subscription.subscribe_headers['id'].to_s
+            
+          # see if the destination uses a wildcard representation
+          elsif subscription.destination.wildcard
+            self.destination.to_s =~ subscription.destination.wildcard
+            
+          # no subscription id? no wildcard? use the name of the destination as a straight match
+          else
+            self.destination.to_s == subscription.destination.value.to_s
+          end
+        end
+
+      end
+
     end
   end
 end

data/lib/activemessaging/adapters/test.rb

@@ -1,11 +1,10 @@
-require 'activemessaging/adapter'
+require 'activemessaging/adapters/base'
 
 module ActiveMessaging
   module Adapters
     module Test
     
-      class Connection
-        include ActiveMessaging::Adapter
+      class Connection < ActiveMessaging::Adapters::BaseConnection
         register :test
         
         attr_accessor :config, :subscriptions, :destinations, :connected, :received_messages, :unreceived_messages
@@ -42,7 +41,7 @@ module ActiveMessaging
         def send destination_name, message_body, message_headers={}
           open_destination destination_name
           destination = find_destination destination_name
-          destination.send Message.new(message_headers, nil, message_body, nil, destination)
+          destination.send Message.new(message_body, nil, message_headers, destination_name)
         end
         
         def receive
@@ -52,15 +51,6 @@ module ActiveMessaging
           destination.receive unless destination.nil?
         end
         
-        # should not be 2 defs for receive, this isn't java, ya know? -Andrew
-        # def receive destination_name, headers={}
-        #   subscribe destination_name, headers
-        #   destination = find_destination destination_name
-        #   message = destination.receive
-        #   unsubscribe destination_name, headers
-        #   message
-        # end
-        
         def received message, headers={}
           @received_messages << message
         end
@@ -71,8 +61,9 @@ module ActiveMessaging
         
         #test helper methods
         def find_message destination_name, body
+          
           all_messages.find do |m|
-            m.headers['destination'] == destination_name && if body.is_a?(Regexp)
+            m.destination == destination_name && if body.is_a?(Regexp)
               m.body =~ body
             else
               m.body == body.to_s
@@ -138,18 +129,9 @@ module ActiveMessaging
         end
       end
       
-      class Message
-        attr_accessor :headers, :body, :command
-        
-        def initialize headers, id, body, response, destination, command='MESSAGE'
-          @headers, @body, @command =  headers, body, command
-          headers['destination'] = destination.name
-        end
-      
-        def to_s
-          "<Test::Message body='#{body}' headers='#{headers.inspect}' command='#{command}' >"
-        end
+      class Message < ActiveMessaging::BaseMessage
       end
+      
     end
   end
 end

data/lib/activemessaging/adapters/wmq.rb

@@ -19,18 +19,16 @@
 #
 require 'wmq/wmq'
 
+require 'activemessaging/adapters/base'
+
 module ActiveMessaging
   module Adapters
     module Adapter
 
       # Connection class needed by a13g
-      class Connection
-        include ActiveMessaging::Adapter
+      class Connection < ActiveMessaging::Adapters::BaseConnection
         register :wmq
 
-        # Needed by a13g but never used within this adapter
-        attr_accessor :reliable
-
         # Generic init method needed by a13g
         def initialize(cfg)
           # Set default values
@@ -147,22 +145,15 @@ module ActiveMessaging
 
       # Message class needed by a13g (based on the same Message class in Stomp adapter)
       # Contains a reference to the MQ message object ;-) !
-      class Message
-        # Accessors needed by a13g
-        attr_accessor :headers, :body, :command, :wmq_message
+      class Message < ActiveMessaging::BaseMessage
+
+        attr_accessor :wmq_message
         
         def initialize(wmq_message, q_name)
+          super(wmq_message.data, wmq_message.descriptor[:msg_id], {'destination' => q_name}, q_name)
           @wmq_message = wmq_message
-
-          # Needed by a13g
-          @headers = {'destination' => q_name}
-          @body = wmq_message.data
-          @command = 'MESSAGE'
         end
 
-        def to_s
-          "<Adapter::Message headers=#{@headers.inspect} body='#{@body}' command='#{@command}' wmq_message=#{@wmq_message}>"
-        end
       end
       
       private

data/lib/activemessaging/base_message.rb

@@ -0,0 +1,19 @@
+module ActiveMessaging
+
+  class BaseMessage
+    attr_accessor :body, :id, :headers, :destination
+
+    def initialize(body=nil, id=nil, headers={}, destination=nil)
+      @body, @id, @headers, @destination = body, id, headers, destination
+    end
+    
+    def matches_subscription?(subscription)
+      self.destination.to_s == subscription.destination.value.to_s
+    end
+
+    def to_s      
+      "<#{self.class.name} id='#{id}' headers='#{headers.inspect}' body='#{body}' >"
+    end
+  end
+
+end

data/lib/activemessaging/gateway.rb

@@ -189,13 +189,14 @@ module ActiveMessaging
 
       def prepare_application
         if defined? Rails
-          Dispatcher.prepare_application_for_dispatch
+          # Dispatcher.prepare_application_for_dispatch
+          ActiveRecord::Base.verify_active_connections!
         end
       end
 
       def reset_application
         if defined? Rails
-          Dispatcher.reset_application_after_dispatch
+          # Dispatcher.reset_application_after_dispatch
         end
       end
       
@@ -215,39 +216,33 @@ module ActiveMessaging
       end
 
       def _dispatch(message)
-        case message.command
-        when 'ERROR'
-          ActiveMessaging.logger.error('Error from messaging infrastructure: ' + message.headers['message'])
-        when 'MESSAGE'
-          abort = false
-          processed = false
-
-          subscriptions.each do |key, subscription| 
-            if subscription.matches?(message) then
-              processed = true
-              routing = {
-                :receiver=>subscription.processor_class, 
-                :destination=>subscription.destination,
-                :direction => :incoming
-              }
-              begin
-                execute_filter_chain(:incoming, message, routing) do |m|
-                  result = subscription.processor_class.new.process!(m)
-                end
-              rescue ActiveMessaging::AbortMessageException
-                abort_message subscription, message
-                abort = true
-                return
-              ensure
-                acknowledge_message subscription, message unless abort
+        abort = false
+        processed = false
+
+        subscriptions.each do |key, subscription| 
+          if message.matches_subscription?(subscription) then
+            processed = true
+            routing = {
+              :receiver=>subscription.processor_class, 
+              :destination=>subscription.destination,
+              :direction => :incoming
+            }
+            begin
+              execute_filter_chain(:incoming, message, routing) do |m|
+                result = subscription.processor_class.new.process!(m)
               end
+            rescue ActiveMessaging::AbortMessageException
+              abort_message subscription, message
+              abort = true
+              return
+            ensure
+              acknowledge_message subscription, message unless abort
             end
           end
-
-          ActiveMessaging.logger.error("No-one responded to #{message}") unless processed
-        else 
-          ActiveMessaging.logger.error('Unknown message command: ' + message.inspect)
         end
+
+        ActiveMessaging.logger.error("No-one responded to #{message}") unless processed
+
       end
 
       # acknowledge_message is called when the message has been processed w/o error by at least one processor
@@ -268,7 +263,7 @@ module ActiveMessaging
 
       def destination destination_name, destination, publish_headers={}, broker='default'
         raise "You already defined #{destination_name} to #{named_destinations[destination_name].value}" if named_destinations.has_key?(destination_name)
-        named_destinations[destination_name] = Destination.new destination_name, destination, publish_headers, broker
+        named_destinations[destination_name] = Destination.new(destination_name, destination, publish_headers, broker)
       end
       
       alias queue destination
@@ -385,16 +380,10 @@ module ActiveMessaging
       @destination, @processor_class, @subscribe_headers = destination, processor_class, subscribe_headers
       subscribe_headers['id'] = processor_class.name.underscore unless subscribe_headers.key? 'id'
     end
-    
-    def matches?(message)
-      message.headers['destination'].to_s == @destination.value.to_s
-    end
-    
+
     def subscribe
       ActiveMessaging.logger.error "=> Subscribing to #{destination.value} (processed by #{processor_class})"
       Gateway.connection(@destination.broker_name).subscribe(@destination.value, subscribe_headers) 
-      # FIXME (uwe): Not sure why this needs to happen here
-      @processor = @processor_class.new
     end
 
     def unsubscribe
@@ -406,15 +395,23 @@ module ActiveMessaging
   class Destination
     DEFAULT_PUBLISH_HEADERS = { :persistent=>true }
 
-    attr_accessor :name, :value, :publish_headers, :broker_name
+    attr_accessor :name, :value, :publish_headers, :broker_name, :wildcard
 
     def initialize(name, value, publish_headers, broker_name)
       @name, @value, @publish_headers, @broker_name = name, value, publish_headers, broker_name
       @publish_headers.reverse_merge! DEFAULT_PUBLISH_HEADERS
+      @wildcard = wildcard_match_exp_for(value) if (value =~ /\*/)
     end
     
     def to_s
-      "#{broker_name}: #{name} => '#{value}'"
+      "<destination: #{broker_name} :#{name}=>'#{value}'>"
+    end
+    
+    private
+    
+    def wildcard_match_exp_for(destination)
+      exp = destination.to_s.gsub(/[.]/, '\.').gsub(/[*]/, '[^.*]+').gsub(/([>].*$)/, '.*') + '$'
+      Regexp.new(exp)
     end
 
   end