gz_activemessaging 0.13.1

data/lib/activemessaging/adapters/stomp.rb

@@ -0,0 +1,212 @@
+require 'stomp'
+
+require 'activemessaging/adapters/base'
+
+module ActiveMessaging
+  module Adapters
+    module Stomp
+      
+      class Connection < ActiveMessaging::Adapters::BaseConnection
+        register :stomp
+
+        attr_accessor :stomp_connection, :retryMax, :deadLetterQueue, :configuration, :deadLetterQueuePrefix
+
+        def initialize(cfg)
+          @retryMax = cfg[:retryMax] || 0
+          @deadLetterQueue = cfg[:deadLetterQueue] || nil
+          @deadLetterQueuePrefix = cfg[:deadLetterQueuePrefix] || nil
+        
+          cfg[:login] ||= ""
+          cfg[:passcode] ||= ""
+          cfg[:host] ||= "localhost"
+          cfg[:port] ||= "61613"
+          cfg[:reliable]  = cfg[:reliable].nil? ? TRUE : cfg[:reliable]
+          cfg[:reconnectDelay] ||= 5
+          cfg[:clientId] ||= nil
+
+          # hold on to the config
+          @configuration = cfg
+
+          # create a new stomp connection
+          connect_headers = cfg[: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
+        
+        # Checks if the connection supports dead letter queues
+        def supports_dlq?
+          !@deadLetterQueue.nil? || !@deadLetterQueuePrefix.nil?
+        end
+
+        # add the dead letter queue prefix to the destination
+        def add_dlq_prefix(destination)
+            if (ri = destination.rindex("/"))
+                destination.clone.insert(ri + 1, @deadLetterQueuePrefix)
+            else
+                @deadLetterQueuePrefix + destination
+            end
+
+        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(options={})
+          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 or client-individual, send an ack
+          if (headers[:ack] === 'client' || headers[:ack] === 'client-individual')
+            ack_headers = message.headers.has_key?(:transaction) ? { :transaction=>message.headers[:transaction]} : {}
+            # All 3 protocol levels have unique ACK requirements.
+            case @stomp_connection.protocol
+              when ::Stomp::SPL_10
+                @stomp_connection.ack(message.headers['message-id'], ack_headers)
+              when ::Stomp::SPL_11
+                ack_headers['subscription'] = message.headers['subscription']
+                @stomp_connection.ack(message.headers['message-id'], ack_headers)
+              else # avoid ::Stomp::SPL_12 constant when using older Stomp gems
+                @stomp_connection.ack(message.headers['ack'], ack_headers)
+            end
+          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
+
+        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
+          @stomp_connection.begin(transaction_id)
+          begin
+
+            if @retryMax > 0
+              retry_headers = message.headers.stringify_keys
+              retry_headers['transaction']= transaction_id
+              content_type_header = retry_headers.delete('content-type')
+              content_length_header = retry_headers.delete('content-length')
+              # If the content-length header in the original message is nil 
+              # then we need to set the :suppress_content_length option so 
+              # that the stomp client does not set the content-length of the 
+              # retried message. This option will allow ActiveMQ to interpret the 
+              # message as a TextMessage.
+              # This is somewhat of a hack because the setting of the :suppress_content_length 
+              # header is usually done in the messaging.rb and is removed by the time 
+              # the unreceive message is called. So I am making some assumptions here
+              # on whether or not to set the option
+              if content_type_header and content_type_header.include?('text/plain') && content_length_header.nil?
+                  retry_headers[:suppress_content_length] = true
+              end
+                           
+              retry_destination = retry_headers.delete('destination')
+              retry_destination = headers[:destination] if headers[: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
+                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
+                logger.warn "retrying message on #{retry_destination}"
+                self.stomp_publish(retry_destination, message.body, retry_headers)
+
+              elsif retry_count >= @retryMax && supports_dlq?
+                # send the 'poison pill' message to the dead letter queue - make it persistent by default
+                retry_headers['a13g-original-destination'] = retry_destination #retry_headers.delete('destination')
+                retry_headers['persistent'] = true
+                retry_headers.delete('message-id')
+                
+                # If the prefix option is set then put the prefix after the /queue/ or /topic/
+                if (@deadLetterQueuePrefix)
+                    dlq = add_dlq_prefix(retry_destination)
+                else
+                    dlq = @deadLetterQueue
+                end
+                logger.warn "putting message on DLQ: #{dlq}"
+                self.stomp_publish(dlq, 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
+              @stomp_connection.ack(message.headers['message-id'], message.headers.stringify_keys.merge('transaction'=>transaction_id))
+            end
+
+            # now commit the transaction
+            @stomp_connection.commit transaction_id
+          rescue Exception=>exc
+            # if there is an error, try to abort the transaction, then raise the error
+            @stomp_connection.abort transaction_id
+            raise exc
+          end
+
+        end
+
+      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/synch.rb

@@ -0,0 +1,95 @@
+require 'activemessaging/adapters/base'
+# 
+# This is meant to avoid the need to use a broker in development, and generally make development mode easier
+# 
+module ActiveMessaging
+  module Adapters
+    module Synch
+    
+      class Connection  < ActiveMessaging::Adapters::BaseConnection
+        register :synch
+
+        #configurable params
+        attr_accessor :configuration, :max_process, :processing_pids, :use_fork
+
+        #generic init method needed by a13g
+        def initialize cfg
+          ActiveMessaging.logger.debug "ActiveMessaging::Adapters::Synch::Connection.initialize: #{cfg.inspect}"
+          @configuration = cfg
+          
+          @use_fork = !!@configuration[:use_fork]
+
+          # max at once
+          @max_process = 10
+          # keep track of the processes running
+          @processing_pids = {}
+
+          if use_fork
+            Thread.new {
+              watch_processes
+            }
+          end
+        end
+        
+        def watch_processes
+          while true
+            begin
+              pid = Process.wait(0, Process::WNOHANG)
+              if m = processing_pids.delete(pid)
+                ActiveMessaging.logger.debug "ActiveMessaging:synch - processing complete for pid (#{pid}):\n\t#{m}"
+              end
+              sleep(0.5)
+            rescue
+            end
+          end
+        end
+
+        def send destination_name, message_body, message_headers={}
+          message = Message.new(message_body, 'id', message_headers, destination_name, 'MESSAGE')
+          
+          if use_fork
+
+            if processing_pids.size > max_process
+              ActiveMessaging.logger.debug "ActiveMessaging:synch too many processes: #{processing_pids.size} > #{max_process}"
+              sleep(0.5)
+            end
+
+            pid = fork {
+              ActiveMessaging.logger.debug "\n-------------------- ActiveMessaging:synch start fork dispath (#{Process.pid}) --------------------"
+              ActiveMessaging::Gateway.prepare_application
+              ActiveMessaging::Gateway._dispatch(message)
+              ActiveMessaging::Gateway.reset_application
+              ActiveMessaging.logger.debug "-------------------- ActiveMessaging:synch end fork dispath (#{Process.pid})--------------------\n"
+            }
+
+            Process.detach(pid)
+            processing_pids[pid] = "Destination: #{destination_name}, Message: #{message_body}"
+
+          else
+
+            ActiveMessaging.logger.debug "\n-------------------- ActiveMessaging:synch before dispath --------------------"
+            ActiveMessaging::Gateway.prepare_application
+            ActiveMessaging::Gateway._dispatch(message)
+            ActiveMessaging::Gateway.reset_application
+            ActiveMessaging.logger.debug "-------------------- ActiveMessaging:synch after dispath --------------------\n"
+
+          end
+          
+        end
+
+      end
+
+      class Message < ActiveMessaging::BaseMessage
+        attr_accessor :command
+
+        def initialize body, id, headers, destination, command='MESSAGE'
+          # ActiveMessaging.logger.debug "Message headers:#{headers.inspect}, id:#{id}, body:#{body}, destination:#{destination}, command:#{command}"
+          @headers, @body, @destination, @command =  headers, body, destination, command
+          headers['destination'] = destination
+        end
+
+      end
+    
+    end
+  end
+end

data/lib/activemessaging/adapters/test.rb

@@ -0,0 +1,137 @@
+require 'activemessaging/adapters/base'
+
+module ActiveMessaging
+  module Adapters
+    module Test
+    
+      class Connection < ActiveMessaging::Adapters::BaseConnection
+        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_body, nil, message_headers, destination_name)
+        end
+        
+        def receive(options={})
+          destination = @destinations.find do |q|
+            find_subscription(q.name) && !q.empty?
+          end
+          destination.receive unless destination.nil?
+        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.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 < ActiveMessaging::BaseMessage
+      end
+      
+    end
+  end
+end

data/lib/activemessaging/adapters/wmq.rb

@@ -0,0 +1,193 @@
+################################################################################
+#  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'
+
+require 'activemessaging/adapters/base'
+
+module ActiveMessaging
+  module Adapters
+    module Adapter
+
+      # Connection class needed by a13g
+      class Connection < ActiveMessaging::Adapters::BaseConnection
+        register :wmq
+
+        # 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(options={})
+          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 < 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
+        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