gz_activemessaging 0.13.1

data/lib/activemessaging/adapters/base.rb

@@ -0,0 +1,71 @@
+require 'activemessaging/adapter'
+require 'activemessaging/base_message'
+
+module ActiveMessaging
+  module Adapters
+
+    # use this as a base for implementing new connections
+    class BaseConnection
+      include ActiveMessaging::Adapter
+
+      #use the register method to add the adapter to the configurable list of supported adapters
+      # register :base
+
+      #configurable params
+      attr_accessor :reliable
+
+      #generic init method needed by a13g
+      def initialize cfg
+      end
+
+      # called to cleanly get rid of connection
+      def disconnect
+      end
+
+      # 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
+
+      # destination_name string, body string, headers hash
+      # send a single message to a destination
+      def send 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
+      # adding options,optionally, so a poller can get certain messages (e.g. by priority)
+      def receive(options={})
+      end
+
+      # called after a message is successfully received and processed
+      def received 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
+      
+    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(options={})
+          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

@@ -0,0 +1,243 @@
+if defined?(JRUBY_VERSION)
+#require 'java'
+include Java
+require 'activemq'
+
+begin
+  java_import javax.naming.InitialContext
+  java_import javax.jms.MessageListener
+rescue NameError
+  raise LoadError, "ActiveMessaging::Adapter::Jms needs Jave EE classes on the CLASSPATH"
+end
+
+module ActiveMessaging
+  module Adapters
+    module Jms
+    
+      class Connection
+        include ActiveMessaging::Adapter
+        register :jms
+        
+        attr_accessor :reliable, :connection, :session, :producers, :consumers
+        
+        def initialize cfg={}
+          @url = cfg[:url]
+          @login = cfg[:login]
+          @passcode = cfg[:passcode]
+          #initialize our connection factory
+          if cfg.has_key? :connection_factory
+            #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, @passcode, @url)
+            end_eval
+          elsif cfg.has_key? :jndi
+            @connection_factory = javax.naming.InitialContext.new().lookup(cfg[:jndi])
+          else
+            raise "Either jndi or connection_factory has to be set in the config."
+          end
+          raise "Connection factory could not be initialized." if @connection_factory.nil?
+          
+          @connection = @connection_factory.create_connection()
+          @session = @connection.createSession(false, 1)
+          @destinations = []
+          @producers = {}
+          @consumers = {}
+          @connection.start
+        end
+        
+        def subscribe queue_name, headers={}
+          queue_name = check_destination_type queue_name, headers
+          find_or_create_consumer queue_name, headers
+        end
+        
+        def unsubscribe queue_name, headers={}
+          queue_name = check_destination_type queue_name, headers
+          consumer = @consumers[queue_name]
+          unless consumer.nil?
+            consumer.close
+            @consumers.delete queue_name
+          end
+        end
+        
+        def send queue_name, body, headers={}
+          queue_name = check_destination_type queue_name, headers
+          producer = find_or_create_producer queue_name, headers.symbolize_keys
+          message = @session.create_text_message body
+          headers.stringify_keys.each do |key, value|
+            if ['id', 'message-id', 'JMSMessageID'].include? key
+              message.setJMSMessageID value.to_s
+            elsif ['correlation-id', 'JMSCorrelationID'].include? key
+              message.setJMSCorrelationID value.to_s
+            elsif ['expires', 'JMSExpiration'].include? key
+              message.setJMSExpiration value.to_i
+            elsif ['persistent', 'JMSDeliveryMode'].include? key
+              message.setJMSDeliveryMode(value ? 2 : 1)
+            elsif ['priority', 'JMSPriority'].include? key
+              message.setJMSPriority value.to_i
+            elsif ['reply-to', 'JMSReplyTo'].include? key
+              message.setJMSReplyTo value.to_s
+            elsif ['type', 'JMSType'].include? key
+              message.setJMSType value.to_s
+            else #is this the most appropriate thing to do here?
+              message.set_string_property key, value.to_s
+            end
+          end
+          producer.send message
+        end
+
+        def receive(options={})
+          queue_name = options[:queue_name]
+          headers = options[:headers] || {}
+          receive_message(queue_name, headers)
+        end
+
+        def receive_message(queue_name=nil, headers={})
+          if queue_name.nil?
+            @consumers.find do |k, c|
+              message = c.receive(1)
+              return condition_message(message) unless message.nil?
+            end
+          else
+            consumer = subscribe(queue_name, headers)
+            message = consumer.receive(1)
+            unsubscribe(queue_name, headers)
+            condition_message(message)
+          end
+        end
+        
+        def received message, headers={}
+          #do nothing
+        end
+        
+        def unreceive message, headers={}
+          # do nothing
+        end
+
+        def close
+          @consumers.each {|k, c| c.stop }
+          @connection.stop
+          @session.close
+          @connection.close
+          @connection = nil
+          @session = nil
+          @consumers = {}
+          @producers = {}
+        end
+        
+        def find_or_create_producer queue_name, headers={}
+          producer = @producers[queue_name]
+          if producer.nil?
+            destination = find_or_create_destination queue_name, headers
+            producer = @session.create_producer destination
+          end
+          producer
+        end
+        
+        def find_or_create_consumer queue_name, headers={}
+          consumer = @consumers[queue_name]
+          if consumer.nil?
+            destination = find_or_create_destination queue_name, headers
+            if headers.symbolize_keys.has_key? :selector
+              consumer = @session.create_consumer destination, headers.symbolize_keys[:selector]
+            else
+              consumer = @session.create_consumer destination
+            end
+            
+            @consumers[queue_name] = consumer
+          end
+          consumer
+        end
+        
+        def find_or_create_destination queue_name, headers={}
+          destination = find_destination queue_name, headers[:destination_type]
+          if destination.nil?
+            if headers.symbolize_keys[:destination_type] == :topic
+              destination = @session.create_topic(queue_name.to_s)
+              @destinations << destination
+            elsif headers.symbolize_keys[:destination_type] == :queue
+              destination = @session.create_queue(queue_name.to_s)
+              @destinations << destination
+            else
+              raise "headers[:destination_type] must be either :queue or :topic.  was #{headers[:destination_type]}"
+            end
+          end
+          destination
+        end
+        
+        protected
+        
+        def condition_message message
+          message.class.class_eval { 
+            alias_method :body, :text unless method_defined? :body
+
+            def headers
+              destination.to_s =~ %r{(queue|topic)://(.*)}
+              puts "/#{$1}/#{$2}"
+              {'destination' => "/#{$1}/#{$2}"}
+            end
+            
+            def matches_subscription?(subscription)
+              self.headers['destination'].to_s == subscription.value.to_s
+            end
+            
+          } unless message.nil? || message.respond_to?(:headers)
+          message
+        end
+        
+        def check_destination_type queue_name, headers
+          stringy_h = headers.stringify_keys
+          if queue_name =~ %r{^/(topic|queue)/(.*)$}  && !stringy_h.has_key?('destination_type')
+            headers['destination_type'] = $1.to_sym
+            return $2
+          else
+            raise "Must specify destination type either with either 'headers[\'destination_type\']=[:queue|:topic]' or /[topic|queue]/destination_name for queue name '#{queue_name}'" unless [:topic, :queue].include? stringy_h['destination_type']
+          end
+        end
+        
+        def find_destination queue_name, type
+          @destinations.find do |d| 
+            if d.is_a?(javax.jms.Topic) && type == :topic
+              d.topic_name == queue_name
+            elsif d.is_a?(javax.jms.Queue) && type == :queue
+              d.queue_name == queue_name
+            end
+          end
+        end
+      end
+#      
+#      class RubyMessageListener
+#         include javax.jms.MessageListener
+# 
+#         def initialize(connection, destination, name)
+#           @connection = connection
+#           @destination = destination
+#           @name = name
+#         end
+# 
+#         def onMessage(msg)
+#           headers = {}
+#           enm = msg.getPropertyNames
+#           while enm.hasMoreElements
+#             key = enm.nextElement
+#             headers[key.to_s] = msg.getStringProperty(key)
+#           end
+#           Gateway.dispatch(JMSRecvMessage.new(headers,msg.text,@name))
+#         rescue => e
+#           STDERR.puts "something went really wrong with a message: #{e.inspect}"
+#        end
+#      end
+#      
+#      class JMSRecvMessage < ActiveMessaging::Adapters::Base::Message
+#         def initialize(headers, body, name, command='MESSAGE')
+#           @headers = headers
+#           @body = body
+#           @command =  command
+#           @headers['destination'] = name
+#         end
+#       end
+    end
+  end
+end
+
+end

data/lib/activemessaging/adapters/reliable_msg.rb

@@ -0,0 +1,186 @@
+require 'reliable-msg'
+
+require 'activemessaging/adapters/base'
+
+# add access to the queue_manager to use for adding transactions
+module ReliableMsg
+
+  class Client
+
+    def queue_manager
+      qm
+    end
+
+  end
+end
+
+
+module ActiveMessaging
+  module Adapters
+    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]
+
+      register :reliable_msg
+
+      #configurable params
+      attr_accessor :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
+
+        @subscriptions = {}
+        @destinations = {}
+        @current_subscription = 0
+      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
+      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
+      end
+
+      # receive a single message from any of the subscribed destinations
+      # check each destination once, then sleep for poll_interval
+      def receive(options={})
+
+        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
+        
+      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
+      end
+
+      def remove
+        @count -= 1
+      end
+
+    end
+
+    class Message < ActiveMessaging::BaseMessage
+      attr_accessor :transaction
+      
+      def initialize body, id, headers, destination, transaction=nil
+        super(body, id, headers, destination)
+        @transaction = transaction
+      end
+    
+    end
+   
+  end
+end