activemessaging 0.6.0

data/lib/activemessaging/adapters/stomp.rb

@@ -0,0 +1,99 @@
+require 'stomp'
+
+module ActiveMessaging
+  module Adapters
+    module Stomp
+
+      class Connection < ::Stomp::Connection
+        include ActiveMessaging::Adapter
+        register :stomp
+
+        attr_accessor :reliable, :retryMax, :deadLetterQueue
+
+        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[: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
+
+        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
+          end
+        end
+
+        def unreceive message, headers={} 
+          retry_count = message.headers['a13g-retry-count'].to_i || 0
+          transaction_id = "transaction-#{message.headers['message-id']}-#{retry_count}"
+
+          # start a transaction, send the message back to the original destination
+          self.begin(transaction_id)
+          begin
+
+            if @retryMax > 0
+              retry_headers = message.headers.stringify_keys
+              retry_headers['transaction']= transaction_id
+              retry_headers.delete('content-length')
+              retry_headers.delete('content-type')
+              
+              if retry_count < @retryMax
+                # now send the message back to the destination
+                #  set the headers for message id, priginal message id, and retry count
+                retry_headers['a13g-original-message-id'] = retry_headers['message-id'] unless retry_headers.has_key?('a13g-original-message-id')
+                retry_headers.delete('message-id')
+
+                retry_headers['a13g-original-timestamp'] = retry_headers['timestamp'] unless retry_headers.has_key?('a13g-original-timestamp')
+                retry_headers.delete('timestamp')
+
+                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
+
+              elsif retry_count >= @retryMax && @deadLetterQueue
+                # send the 'poison pill' message to the dead letter queue
+                retry_headers['a13g-original-destination'] = retry_headers.delete('destination')
+                retry_headers.delete('message-id')
+                self.send @deadLetterQueue, message.body, retry_headers
+              end
+
+            end
+
+            #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)
+            end
+
+            # now commit the transaction
+            self.commit transaction_id
+          rescue Exception=>exc
+            # if there is an error, try to abort the transaction, then raise the error
+            self.abort transaction_id
+            raise exc
+          end
+
+        end
+
+      end
+      
+    end
+  end
+end

data/lib/activemessaging/adapters/test.rb

@@ -0,0 +1,155 @@
+require 'activemessaging/adapter'
+
+module ActiveMessaging
+  module Adapters
+    module Test
+    
+      class Connection
+        include ActiveMessaging::Adapter
+        register :test
+        
+        attr_accessor :config, :subscriptions, :destinations, :connected, :received_messages, :unreceived_messages
+        
+        def initialize cfg
+          @config = cfg
+          @subscriptions = []
+          @destinations = []
+          @received_messages = []
+          @unreceived_messages = []
+          @connected = true
+        end
+        
+        def disconnect
+          @subscriptions = []
+          @destinations = []
+          @received_messages = []
+          @unreceived_messages = []
+          @connected = false
+        end
+        
+        def subscribe destination_name, subscribe_headers={}
+          open_destination destination_name
+          unless @subscriptions.find {|s| s.name == destination_name} 
+            @subscriptions << Subscription.new(destination_name, subscribe_headers)
+          end
+          @subscriptions.last
+        end
+        
+        def unsubscribe destination_name, unsubscribe_headers={}
+          @subscriptions.delete_if {|s| s.name == destination_name}
+        end
+        
+        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)
+        end
+        
+        def receive
+          destination = @destinations.find do |q|
+            find_subscription(q.name) && !q.empty?
+          end
+          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
+
+        def unreceive message, headers={}
+          @unreceived_messages << message
+        end
+        
+        #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.body =~ body
+            else
+              m.body == body.to_s
+            end
+          end
+        end
+        
+        def open_destination destination_name
+          unless find_destination destination_name
+            @destinations << Destination.new(destination_name)
+          end
+        end
+        
+        def find_destination destination_name
+          @destinations.find{|q| q.name == destination_name }
+        end
+        
+        def find_subscription destination_name
+          @subscriptions.find{|s| s.name == destination_name}
+        end
+        
+        def all_messages
+          @destinations.map {|q| q.messages }.flatten
+        end
+      end
+      
+      class Destination
+        
+        attr_accessor :name, :messages
+        
+        def initialize name
+          @name = name
+          @messages = []
+        end
+        
+        def receive
+          @messages.shift
+        end
+
+        def send message
+          @messages << message
+        end
+        
+        def empty?
+          @messages.empty?
+        end
+        
+        def to_s
+          "<Test::Destination name='#{name}' messages='#{@messages.inspect}'>"
+        end
+      end
+      
+      class Subscription
+        attr_accessor :name, :headers
+        
+        def initialize name, headers
+          @name = name
+          @headers = headers
+        end
+        
+        def to_s
+          "<Test::Subscription destination='#{name}' headers='#{headers.inspect}' >"
+        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
+      end
+    end
+  end
+end

data/lib/activemessaging/adapters/wmq.rb

@@ -0,0 +1,202 @@
+################################################################################
+#  Copyright 2007 S. Perez. RBC Dexia Investor Servies Bank
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+################################################################################
+
+#
+# WebSphere MQ adapter for activemessaging
+#
+require 'wmq/wmq'
+
+module ActiveMessaging
+  module Adapters
+    module Adapter
+
+      # Connection class needed by a13g
+      class Connection
+        include ActiveMessaging::Adapter
+        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
+          cfg[:poll_interval] ||= 0.1
+
+          # Initialize instance members
+          # Trick for the connection_options is to allow settings WMQ constants directly in broker.yml :))
+          @connection_options = cfg.each_pair {|key, value| cfg[key] = instance_eval(value) if (value.instance_of?(String) && value.match("WMQ::")) }
+          @queue_names = []
+          @current_queue = 0
+          @queues = {}
+        end
+
+        # Disconnect method needed by a13g
+        # No need to disconnect from the queue manager since connection and disconnection occurs inside the send and receive methods
+        # headers is never used
+        def disconnect(headers = {})
+        end
+
+        # Receive method needed by a13g
+        def receive
+          raise "No subscription to receive messages from" if (@queue_names.nil? || @queue_names.empty?)
+          start = @current_queue
+          while true
+            @current_queue = ((@current_queue < @queue_names.length-1) ? @current_queue + 1 : 0)
+            sleep(@connection_options[:poll_interval]) if (@current_queue == start)
+            q = @queues[@queue_names[@current_queue]]
+            unless q.nil?
+              message = retrieve_message(q)
+              return message unless message.nil?
+            end
+          end
+        end
+
+        # Send method needed by a13g
+        # headers may contains 2 different hashes to gives more control over the sending process
+        #   :descriptor => {...} to populate the descriptor of the message
+        #   :put_options => {...} to specify the put options for that message
+        def send(q_name, message_data, headers={})
+          WMQ::QueueManager.connect(@connection_options) do |qmgr|
+            qmgr.open_queue(:q_name => q_name, :mode => :output) do |queue|
+
+              message_descriptor = headers[:descriptor] || {:format => WMQ::MQFMT_STRING}
+              put_options = headers[:put_options].nil? ? {} : headers[:put_options].dup
+
+              wmq_message = WMQ::Message.new(:data => message_data, :descriptor => message_descriptor)
+              queue.put(put_options.merge(:message => wmq_message, :data => nil))
+              return Message.new(wmq_message, q_name)
+            end
+          end
+        end
+
+        # Subscribe method needed by a13g
+        # headers may contains a hash to give more control over the get operation on the queue
+        #   :get_options => {...} to specify the get options when receiving messages
+        #   Warning : get options are set only on the first queue subscription and are common to all the queue's subscriptions
+        #             Any other get options passed with subsequent subscribe on an existing queue will be discarded
+        # subId is never used
+        def subscribe(q_name, headers={}, subId=NIL)
+          if @queues[q_name].nil?
+            get_options = headers[:get_options] || {}
+            q = Queue.new(q_name, get_options)
+            @queues[q_name] = q
+            @queue_names << q.name
+          end
+
+          q.add_subscription
+        end
+
+        # Unsubscribe method needed by a13g
+        # Stop listening the queue only after the last unsubscription
+        # headers is never used
+        # subId is never used
+        def unsubscribe(q_name, headers={}, subId=NIL)
+          q = @queues[q_name]
+          unless q.nil?
+            q.remove_subscription
+            unless q.has_subscription?
+              @queues.delete(q_name)
+              @queue_names.delete(q_name)
+            end
+          end
+        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
+
+        private
+
+        # Retrieve the first available message from the specicied queue
+        # Return nil if queue is empty
+        def retrieve_message(q)
+          WMQ::QueueManager.connect(@connection_options) do |qmgr|
+            qmgr.open_queue(:q_name => q.name, :mode => :input) do |queue|
+
+              get_options = q.get_options.dup
+              wmq_message = WMQ::Message.new
+              
+              if queue.get(get_options.merge(:message => wmq_message))
+                return Message.new(wmq_message, q.name)
+              else 
+                return nil
+              end
+            end
+          end
+        end
+      end
+
+      # 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
+        
+        def initialize(wmq_message, 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
+
+      # Queue class is used to keep track of the subscriptions
+      # It contains :
+      #   - name of the queue
+      #   - options to use when getting from the queue
+      #   - number of subscriptions
+      class Queue
+        attr_accessor :name, :get_options, :nb_subscriptions
+
+        def initialize(name, get_options)
+          @name, @get_options  = name, get_options
+          @nb_subscriptions = 0
+        end
+
+        def add_subscription
+          @nb_subscriptions += 1
+        end
+        
+        def remove_subscription
+          @nb_subscriptions -= 1 unless @nb_subscriptions > 0
+        end
+
+        def has_subscription?
+          @nb_subscriptions > 0
+        end
+
+        def to_s
+          "<Adapter::Queue name='#{@name}' get_options=#{@get_options} nb_subscriptions=#{@nb_subscriptions}>"
+        end
+      end
+      
+    end
+  end
+end