activemessaging 0.6.1 → 0.7.1

data/lib/activemessaging/adapters/base.rb

@@ -1,82 +1,70 @@
+require 'activemessaging/adapter'
+require 'activemessaging/base_message'
+
 module ActiveMessaging
   module Adapters
-    module Base
-
-
-      # use this as a base for implementing new connections
-      class Connection
-        include ActiveMessaging::Adapter
-
-        #use the register method to add the adapter to the configurable list of supported adapters
-        # register :generic
 
-        #configurable params
-        attr_accessor :reliable
+    # use this as a base for implementing new connections
+    class BaseConnection
+      include ActiveMessaging::Adapter
 
-        #generic init method needed by a13g
-        def initialize cfg
-        end
+      #use the register method to add the adapter to the configurable list of supported adapters
+      # register :base
 
-        # called to cleanly get rid of connection
-        def disconnect
-        end
+      #configurable params
+      attr_accessor :reliable
 
-        # destination_name string, headers hash
-        # subscribe to listen on a destination
-        def subscribe destination_name, message_headers={}
-        end
-
-        # destination_name string, headers hash
-        # unsubscribe to listen on a destination
-        def unsubscribe destination_name, message_headers={}
-        end
+      #generic init method needed by a13g
+      def initialize cfg
+      end
 
-        # destination_name string, body string, headers hash
-        # send a single message to a destination
-        def send destination_name, message_body, message_headers={}
-        end
+      # called to cleanly get rid of connection
+      def disconnect
+      end
 
-        # receive a single message from any of the subscribed destinations
-        # check each destination once, then sleep for poll_interval
-        def receive
-        end
+      # destination_name string, headers hash
+      # subscribe to listen on a destination
+      def subscribe destination_name, message_headers={}
+      end
 
-        # called after a message is successfully received and processed
-        def received message, headers={}
-        end
+      # destination_name string, headers hash
+      # unsubscribe to listen on a destination
+      def unsubscribe destination_name, message_headers={}
+      end
 
-        # called after a message is successfully received but unsuccessfully processed
-        # purpose is to return the message to the destination so receiving and processing and be attempted again 
-        def unreceive 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={}
       end
 
-      # I recommend having a destination object to represent each subscribed destination 
-      class Destination
-        attr_accessor :name
+      # receive a single message from any of the subscribed destinations
+      # check each destination once, then sleep for poll_interval
+      def receive
+      end
 
-        def to_s
-          "<Base::Destination name='#{name}'>"
-        end
+      # called after a message is successfully received and processed
+      def received message, headers={}
       end
 
-      # based on stomp message
-      # command = MESSAGE for successful message from adapter, ERROR for problem from adapter
-      # !!!! must have headers['destination'] = subscription.destination in order to match message to subscription in gateway!!!!
-      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
-          "<Base::Message body='#{body}' headers='#{headers.inspect}' command='#{command}' >"
-        end
+      # called after a message is successfully received but unsuccessfully processed
+      # purpose is to return the message to the destination so receiving and processing and be attempted again 
+      def unreceive message, headers={}
       end
-   
+      
     end
+
+    ## I recommend having a destination object to represent each subscribed destination 
+    # class Destination
+    #   attr_accessor :name
+    # 
+    #   def to_s
+    #     "<Base::Destination name='#{name}'>"
+    #   end
+    # end
+
+    ## You should also define your own message based on the BaseMessage class
+    # class Message < ActiveMessaging::BaseMessage
+    # end
+   
   end
 end

data/lib/activemessaging/adapters/beanstalk.rb

@@ -0,0 +1,88 @@
+#
+# contributed by Al-Faisal El-Dajani on 11/04/2009
+#
+# One caveat: beanstalk does not accept the underscore '_' as a legal character in queue names. 
+# So in messaging.rb you'll need to modify your queue names to use something other than the underscore, a dash perhaps.
+# Accepting the underscore as a valid char in queue names is an open issue in beanstalk, and should be fixed in a future version.
+#
+
+require 'beanstalk-client'
+require 'activemessaging/adapters/base'
+
+module ActiveMessaging
+  module Adapters
+    module Beanstalk
+      
+      class Connection < ActiveMessaging::Adapters::BaseConnection
+        register :beanstalk
+        
+        attr_accessor :connection, :host, :port
+        
+        def initialize cfg
+          @host = cfg[:host] || 'localhost'
+          @port = cfg[:port] || 11300
+          
+          @connection = ::Beanstalk::Pool.new("#{@host}:#{@port}")
+        end
+        
+        def disconnect
+          @connection.close
+        end
+        
+        def subscribe tube, message_headers={}
+          @connection.watch(tube)
+        end
+        
+        def unsubscribe tube, message_headers={}
+          @connection.ignore(tube)
+        end
+        
+        def send tube, message, message_headers={}
+          priority = message_headers[:priority] || 65536
+          delay    = message_headers[:delay] || 0
+          ttr      = message_headers[:ttr] || 120
+          
+          @connection.use(tube)
+          @connection.put(message, priority, delay, ttr)
+        end
+        
+        def receive
+          message = @connection.reserve
+          Beanstalk::Message.new message
+        end
+        
+        def received message, message_headers={}
+          message.delete
+        end
+        
+        def unreceive message, message_headers={}
+          message.release
+        end
+        
+      end
+      
+      class Message < ActiveMessaging::BaseMessage
+        attr_accessor :beanstalk_job
+        
+        def initialize beanstalk_job
+          bsh = {
+            'destination' => beanstalk_job.stats['tube'],
+            'priority'    => beanstalk_job.pri,
+            'delay'       => beanstalk_job.delay,
+            'ttr'         => beanstalk_job.ttr
+          }
+          super(beanstalk_job.body, beanstalk_job.id, bsh, beanstalk_job.stats['tube'])
+          @beanstalk_job = beanstalk_job
+        end
+        
+        def delete
+          @beanstalk_job.delete
+        end
+        
+        def release
+          @beanstalk_job.release
+        end
+      end
+    end
+  end
+end

data/lib/activemessaging/adapters/jms.rb

@@ -25,7 +25,7 @@ module ActiveMessaging
             #this initialize is probably activemq specific. There might be a more generic
             #way of getting this without resorting to jndi lookup.
             eval <<-end_eval
-              @connection_factory = Java::#{cfg[:connection_factory]}.new(@login, @password, @url)
+              @connection_factory = Java::#{cfg[:connection_factory]}.new(@login, @passcode, @url)
             end_eval
           elsif cfg.has_key? :jndi
             @connection_factory = javax.naming.InitialContext.new().lookup(cfg[:jndi])
@@ -164,18 +164,18 @@ module ActiveMessaging
         def condition_message message
           message.class.class_eval { 
             alias_method :body, :text unless method_defined? :body
-            
-            def command
-              "MESSAGE"
-            end
-            
+
             def headers
               destination.to_s =~ %r{(queue|topic)://(.*)}
               puts "/#{$1}/#{$2}"
               {'destination' => "/#{$1}/#{$2}"}
             end
             
-          } unless message.nil? || message.respond_to?(:command)
+            def matches_subscription?(subscription)
+              self.headers['destination'].to_s == subscription.value.to_s
+            end
+            
+          } unless message.nil? || message.respond_to?(:headers)
           message
         end
         

data/lib/activemessaging/adapters/reliable_msg.rb

@@ -1,5 +1,8 @@
 require 'reliable-msg'
 
+require 'activemessaging/adapters/base'
+
+# add access to the queue_manager to use for adding transactions
 module ReliableMsg
 
   class Client
@@ -14,177 +17,170 @@ end
 
 module ActiveMessaging
   module Adapters
-    module ReliableMsg
+    class ReliableMsgConnection < ActiveMessaging::Adapters::BaseConnection
 
       THREAD_OLD_TXS = :a13g_reliable_msg_old_txs
 
       QUEUE_PARAMS = [:expires,:delivery,:priority,:max_deliveries,:drb_uri,:tx_timeout,:connect_count]
       TOPIC_PARAMS = [:expires,:drb_uri,:tx_timeout,:connect_count]
 
-      class Connection
-        include ActiveMessaging::Adapter
+      register :reliable_msg
 
-        register :reliable_msg
+      #configurable params
+      attr_accessor :subscriptions, :destinations, :poll_interval, :current_subscription, :tx_timeout
 
-        #configurable params
-        attr_accessor :reliable, :subscriptions, :destinations, :poll_interval, :current_subscription, :tx_timeout
+      #generic init method needed by a13g
+      def initialize cfg
+        @poll_interval = cfg[:poll_interval]  || 1
+        @reliable = cfg[:reliable]            || true
+        @tx_timeout = cfg[:tx_timeout]        || ::ReliableMsg::Client::DEFAULT_TX_TIMEOUT
 
-        #generic init method needed by a13g
-        def initialize cfg
-          @poll_interval = cfg[:poll_interval]  || 1
-          @reliable = cfg[:reliable]            || true
-          @tx_timeout = cfg[:tx_timeout]        || ::ReliableMsg::Client::DEFAULT_TX_TIMEOUT
+        @subscriptions = {}
+        @destinations = {}
+        @current_subscription = 0
+      end
 
-          @subscriptions = {}
-          @destinations = {}
-          @current_subscription = 0
-        end
+      # called to cleanly get rid of connection
+      def disconnect
+        nil
+      end
 
-        # called to cleanly get rid of connection
-        def disconnect
-          nil
-        end
-
-        # destination_name string, headers hash
-        # subscribe to listen on a destination
-        # use '/destination-type/name' convetion, like stomp
-        def subscribe destination_name, message_headers={}
-          get_or_create_destination(destination_name, message_headers)
-          if subscriptions.has_key? destination_name
-            subscriptions[destination_name].add
-          else
-            subscriptions[destination_name] = Subscription.new(destination_name, message_headers)
-          end
+      # destination_name string, headers hash
+      # subscribe to listen on a destination
+      # use '/destination-type/name' convetion, like stomp
+      def subscribe destination_name, message_headers={}
+        get_or_create_destination(destination_name, message_headers)
+        if subscriptions.has_key? destination_name
+          subscriptions[destination_name].add
+        else
+          subscriptions[destination_name] = Subscription.new(destination_name, message_headers)
         end
+      end
 
-        # destination_name string, headers hash
-        # unsubscribe to listen on a destination
-        def unsubscribe destination_name, message_headers={}
-          subscriptions[destination_name].remove
-          subscriptions.delete(destination_name) if subscriptions[destination_name].count <= 0
-        end
+      # destination_name string, headers hash
+      # unsubscribe to listen on a destination
+      def unsubscribe destination_name, message_headers={}
+        subscriptions[destination_name].remove
+        subscriptions.delete(destination_name) if subscriptions[destination_name].count <= 0
+      end
 
-        # destination_name string, body string, headers hash
-        # send a single message to a destination
-        def send destination_name, message_body, message_headers={}
-          dest = get_or_create_destination(destination_name)
-          begin
-            dest.put message_body, message_headers
-          rescue Object=>err
-            raise err unless reliable
-            puts "send failed, will retry in #{@poll_interval} seconds"
-            sleep @poll_interval
-          end
-        end
-        
-        def get_or_create_destination destination_name, message_headers={}
-          return destinations[destination_name] if destinations.has_key? destination_name
-          dd = /^\/(queue|topic)\/(.*)$/.match(destination_name)
-          rm_class = dd[1].titleize
-          message_headers.delete("id")
-          dest_headers = message_headers.reject {|k,v| rm_class == 'Queue' ? !QUEUE_PARAMS.include?(k) : !TOPIC_PARAMS.include?(k)}
-          rm_dest = "ReliableMsg::#{rm_class}".constantize.new(dd[2], dest_headers)
-          destinations[destination_name] = rm_dest
+      # destination_name string, body string, headers hash
+      # send a single message to a destination
+      def send destination_name, message_body, message_headers={}
+        dest = get_or_create_destination(destination_name)
+        begin
+          dest.put message_body, message_headers
+        rescue Object=>err
+          raise err unless reliable
+          puts "send failed, will retry in #{@poll_interval} seconds"
+          sleep @poll_interval
         end
+      end
+      
+      def get_or_create_destination destination_name, message_headers={}
+        return destinations[destination_name] if destinations.has_key? destination_name
+        dd = /^\/(queue|topic)\/(.*)$/.match(destination_name)
+        rm_class = dd[1].titleize
+        message_headers.delete("id")
+        dest_headers = message_headers.reject {|k,v| rm_class == 'Queue' ? !QUEUE_PARAMS.include?(k) : !TOPIC_PARAMS.include?(k)}
+        rm_dest = "ReliableMsg::#{rm_class}".constantize.new(dd[2], dest_headers)
+        destinations[destination_name] = rm_dest
+      end
 
-        # receive a single message from any of the subscribed destinations
-        # check each destination once, then sleep for poll_interval
-        def receive
-
-          raise "No subscriptions to receive messages from." if (subscriptions.nil? || subscriptions.empty?)
-          start = current_subscription
-          while true
-            self.current_subscription = ((current_subscription < subscriptions.length-1) ? current_subscription + 1 : 0)
-            sleep poll_interval if (current_subscription == start)
-            destination_name = subscriptions.keys.sort[current_subscription]
-            destination = destinations[destination_name]
-            unless destination.nil?
-              # from the way we use this, assume this is the start of a transaction, 
-              # there should be no current transaction
-              ctx = Thread.current[::ReliableMsg::Client::THREAD_CURRENT_TX]
-              raise "There should not be an existing reliable-msg transaction. #{ctx.inspect}" if ctx
-
-              # start a new transaction
-              @tx = {:qm=>destination.queue_manager}
-              @tx[:tid] = @tx[:qm].begin @tx_timeout
-              Thread.current[::ReliableMsg::Client::THREAD_CURRENT_TX] = @tx
-              begin
-
-                # now call a get on the destination - it will use the transaction
-                #the commit or the abort will occur in the received or unreceive methods
-                reliable_msg = destination.get subscriptions[destination_name].headers[:selector]
-                @tx[:qm].commit(@tx[:tid]) if reliable_msg.nil?
-
-              rescue Object=>err
-                #abort the transaction on error
-                @tx[:qm].abort(@tx[:tid])
-
-                raise err unless reliable
-                puts "receive failed, will retry in #{@poll_interval} seconds"
-                sleep poll_interval
-              end
-              return Message.new(reliable_msg.id, reliable_msg.object, reliable_msg.headers, destination_name, 'MESSAGE', @tx) if reliable_msg
-              
-              Thread.current[::ReliableMsg::Client::THREAD_CURRENT_TX] = nil
+      # receive a single message from any of the subscribed destinations
+      # check each destination once, then sleep for poll_interval
+      def receive
+
+        raise "No subscriptions to receive messages from." if (subscriptions.nil? || subscriptions.empty?)
+        start = current_subscription
+        while true
+          self.current_subscription = ((current_subscription < subscriptions.length-1) ? current_subscription + 1 : 0)
+          sleep poll_interval if (current_subscription == start)
+          destination_name = subscriptions.keys.sort[current_subscription]
+          destination = destinations[destination_name]
+          unless destination.nil?
+            # from the way we use this, assume this is the start of a transaction, 
+            # there should be no current transaction
+            ctx = Thread.current[::ReliableMsg::Client::THREAD_CURRENT_TX]
+            raise "There should not be an existing reliable-msg transaction. #{ctx.inspect}" if ctx
+
+            # start a new transaction
+            @tx = {:qm=>destination.queue_manager}
+            @tx[:tid] = @tx[:qm].begin @tx_timeout
+            Thread.current[::ReliableMsg::Client::THREAD_CURRENT_TX] = @tx
+            begin
+
+              # now call a get on the destination - it will use the transaction
+              #the commit or the abort will occur in the received or unreceive methods
+              reliable_msg = destination.get subscriptions[destination_name].headers[:selector]
+              @tx[:qm].commit(@tx[:tid]) if reliable_msg.nil?
+
+            rescue Object=>err
+              #abort the transaction on error
+              @tx[:qm].abort(@tx[:tid])
+
+              raise err unless reliable
+              puts "receive failed, will retry in #{@poll_interval} seconds"
+              sleep poll_interval
             end
+            return Message.new(reliable_msg.object, reliable_msg.id, reliable_msg.headers, destination_name, @tx) if reliable_msg
+            
+            Thread.current[::ReliableMsg::Client::THREAD_CURRENT_TX] = nil
           end
         end
+      end
 
-        # called after a message is successfully received and processed
-        def received message, headers={}
-          begin
-            message.transaction[:qm].commit(message.transaction[:tid]) 
-          rescue Object=>ex
-            puts "received failed: #{ex.message}"
-          ensure
-            Thread.current[::ReliableMsg::Client::THREAD_CURRENT_TX] = nil
-          end
-          
+      # called after a message is successfully received and processed
+      def received message, headers={}
+        begin
+          message.transaction[:qm].commit(message.transaction[:tid]) 
+        rescue Object=>ex
+          puts "received failed: #{ex.message}"
+        ensure
+          Thread.current[::ReliableMsg::Client::THREAD_CURRENT_TX] = nil
         end
         
-        # called after a message is successfully received and processed
-        def unreceive message, headers={}
-          begin
-            message.transaction[:qm].abort(message.transaction[:tid])
-          rescue Object=>ex
-            puts "unreceive failed: #{ex.message}"
-          ensure
-            Thread.current[::ReliableMsg::Client::THREAD_CURRENT_TX] = nil
-          end
-        end
-
       end
       
-      class Subscription
-        attr_accessor :name, :headers, :count
-        
-        def initialize(destination, headers={}, count=1)
-          @destination, @headers, @count = destination, headers, count
-        end
-        
-        def add
-          @count += 1
+      # called after a message is successfully received and processed
+      def unreceive message, headers={}
+        begin
+          message.transaction[:qm].abort(message.transaction[:tid])
+        rescue Object=>ex
+          puts "unreceive failed: #{ex.message}"
+        ensure
+          Thread.current[::ReliableMsg::Client::THREAD_CURRENT_TX] = nil
         end
+      end
 
-        def remove
-          @count -= 1
-        end
+    end
+    
+    class Subscription
+      attr_accessor :name, :headers, :count
+      
+      def initialize(destination, headers={}, count=1)
+        @destination, @headers, @count = destination, headers, count
+      end
+      
+      def add
+        @count += 1
+      end
 
+      def remove
+        @count -= 1
       end
 
-      class Message
-        attr_accessor :id, :body, :headers, :command, :transaction
-        
-        def initialize id, body, headers, destination_name, command='MESSAGE', transaction=nil
-          @id, @body, @headers, @command, @transaction =  id, body, headers, command, transaction
-          headers['destination'] = destination_name
-        end
+    end
+
+    class Message < ActiveMessaging::BaseMessage
+      attr_accessor :transaction
       
-        def to_s
-          "<ReliableMessaging::Message id='#{id}' body='#{body}' headers='#{headers.inspect}' command='#{command}' >"
-        end
+      def initialize body, id, headers, destination, transaction=nil
+        super(body, id, headers, destination)
+        @transaction = transaction
       end
-   
+    
     end
+   
   end
 end