activemessaging 0.6.0

data/lib/activemessaging/adapters/base.rb

@@ -0,0 +1,82 @@
+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
+
+        #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
+        def receive
+        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
+
+      # 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
+      end
+   
+    end
+  end
+end

data/lib/activemessaging/adapters/jms.rb

@@ -0,0 +1,237 @@
+
+if defined?(JRUBY_VERSION)
+#require 'java'
+include Java
+
+import javax.naming.InitialContext
+import javax.jms.MessageListener
+
+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, @password, @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_any
+          @consumers.find do |k, c|
+            message = c.receive(1)
+            return condition_message(message) unless message.nil?
+          end
+        end
+        
+        def receive queue_name=nil, headers={}
+          if queue_name.nil?
+            receive_any
+          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 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)
+          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,190 @@
+require 'reliable-msg'
+
+module ReliableMsg
+
+  class Client
+
+    def queue_manager
+      qm
+    end
+
+  end
+end
+
+
+module ActiveMessaging
+  module Adapters
+    module ReliableMsg
+
+      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
+
+        #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
+
+          @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
+
+          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
+            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
+        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
+      
+        def to_s
+          "<ReliableMessaging::Message id='#{id}' body='#{body}' headers='#{headers.inspect}' command='#{command}' >"
+        end
+      end
+   
+    end
+  end
+end