torquebox-messaging 1.1.1-java → 2.0.0.beta1-java

data/lib/torquebox/messaging/message.rb

@@ -0,0 +1,123 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+#
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+#
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+module TorqueBox
+  module Messaging
+    class Message
+
+      attr_reader :jms_message
+
+      # if no encoding specified in the message itself assume the legacy encoding
+      DEFAULT_DECODE_ENCODING = :marshal_base64
+      
+      # if no encoding specified when creating a message and no global
+      # defaut set use :marshal
+      DEFAULT_ENCODE_ENCODING = :marshal
+      
+      ENCODING_PROPERTY = "__ContentEncoding__"
+
+      def initialize(jms_session, payload)
+        @jms_message = self.class::JMS_TYPE == :text ? jms_session.create_text_message :
+          jms_session.create_bytes_message
+        set_encoding
+        encode( payload )
+      end
+
+      def initialize_from_message(jms_message)
+        @jms_message = jms_message
+      end
+
+      def set_encoding
+        @jms_message.set_string_property( ENCODING_PROPERTY, self.class::ENCODING.to_s )
+      end
+
+      def populate_message_headers(options)
+        return if options.nil?
+        options.each do |key, value|
+          case key.to_s
+          when 'correlation_id' then @jms_message.setJMSCorrelationID(value)
+          when 'reply_to'       then @jms_message.setJMSReplyTo(value)
+          when 'type'           then @jms_message.setJMSType(value)
+          end
+        end
+      end
+
+      def populate_message_properties(properties)
+        return if properties.nil?
+        properties.each do |key, value|
+          case value
+          when Integer
+            @jms_message.set_long_property(key.to_s, value)
+          when Float
+            @jms_message.set_double_property(key.to_s, value)
+          when TrueClass, FalseClass
+            @jms_message.set_boolean_property(key.to_s, value)
+          else
+            @jms_message.set_string_property(key.to_s, value.to_s)
+          end
+        end
+      end
+
+      def method_missing(*args)
+        @jms_message.send(*args)
+      end
+
+      class << self
+        alias :__new__ :new
+
+        def inherited(subclass)
+          class << subclass
+            alias :new :__new__
+          end
+        end
+
+        def new(jms_message_or_session, payload = nil, encoding = nil)
+          if jms_message_or_session.is_a?( javax.jms::Session )
+            encoding ||= ENV['DEFAULT_MESSAGE_ENCODING'] || DEFAULT_ENCODE_ENCODING
+            klass = class_for_encoding( encoding.to_sym )
+            klass.new( jms_message_or_session, payload )
+          else
+            encoding = extract_encoding_from_message( jms_message_or_session ) || DEFAULT_DECODE_ENCODING
+            klass = class_for_encoding( encoding )
+            msg = klass.allocate
+            msg.initialize_from_message( jms_message_or_session )
+            msg
+          end
+        end
+
+        def encoding_map
+          @encoding_map ||= { }
+        end
+
+        def register_encoding(klass)
+          encoding_map[klass::ENCODING] = klass
+        end
+
+        def class_for_encoding(encoding)
+          klass = encoding_map[encoding.to_sym]
+          raise ArgumentError.new( "No message class found for encoding '#{encoding}'" ) unless klass
+          klass
+        end
+
+        def extract_encoding_from_message(jms_message)
+          jms_message.get_string_property( ENCODING_PROPERTY )
+        end
+
+      end
+    end
+  end
+end

data/lib/torquebox/messaging/message_processor.rb

@@ -0,0 +1,47 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+# 
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+# 
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+module TorqueBox
+  module Messaging
+    class MessageProcessor
+
+      attr_accessor :message
+
+      def initialize
+        @message = nil 
+      end
+      
+      def on_message(body)
+        throw "Your subclass must implement on_message(body)"
+      end
+
+      def on_error(error)
+        raise error
+      end
+
+      def process!(message)
+        @message = message
+        begin
+          on_message( message.decode )
+        rescue Exception => e
+          on_error( e ) 
+        end 
+      end
+
+    end
+  end
+end

data/lib/torquebox/messaging/processor_wrapper.rb

@@ -0,0 +1,38 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+# 
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+# 
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+require 'torquebox/transactions'
+
+module TorqueBox
+  module Messaging
+    class ProcessorWrapper
+      
+      def initialize(target, session, message)
+        @target = target
+        @session = session
+        @message = message
+      end
+
+      def process!
+        TorqueBox.transaction( @session ) do
+          @target.process!( @message )
+        end
+      end
+      
+    end
+  end
+end

data/lib/torquebox/messaging/queue.rb

@@ -0,0 +1,61 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+# 
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+# 
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+require 'torquebox/messaging/destination'
+require 'torquebox/service_registry'
+
+module TorqueBox
+  module Messaging
+    class Queue < Destination
+
+      def self.start( name, options={} )
+        selector = options.fetch( :selector, "" )
+        durable  = options.fetch( :durable,  true )
+        jndi     = options.fetch( :jndi,     [].to_java(:string) )
+        TorqueBox::ServiceRegistry.lookup("jboss.messaging.default.jms.manager") do |server|
+          server.createQueue( false, name, selector, durable, jndi )
+        end
+        new( name )
+      end
+
+      def stop
+        TorqueBox::ServiceRegistry.lookup("jboss.messaging.default.jms.manager") do |server|
+          server.destroyQueue( name )
+        end
+      end
+
+      def publish_and_receive(message, options={})
+        result = nil
+        with_session do |session|
+          result = session.publish_and_receive(self, message,
+                                               normalize_options(options))
+        end
+        result
+      end
+
+      def receive_and_publish(options={}, &block)
+        with_session do |session|
+          session.receive_and_publish(self, normalize_options(options), &block)
+        end
+      end
+
+      def to_s
+        "[Queue: #{super}]"
+      end
+    end
+  end
+end

data/lib/torquebox/messaging/session.rb

@@ -0,0 +1,168 @@
+# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
+# 
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+# 
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+module TorqueBox
+  module Messaging
+
+    class Session
+
+      AUTO_ACK = javax.jms::Session::AUTO_ACKNOWLEDGE
+      CLIENT_ACK = javax.jms::Session::CLIENT_ACKNOWLEDGE
+      DUPS_OK_ACK = javax.jms::Session::DUPS_OK_ACKNOWLEDGE
+
+      attr_accessor :jms_session
+      
+      def initialize(jms_session)
+        @jms_session = jms_session
+      end
+
+      def close
+        @jms_session.close
+      end
+
+      def queue_for(name)
+        Queue.new( @jms_session.create_queue( name ) )
+      end
+
+      def publish(destination, payload, options={})
+        producer    = @jms_session.create_producer( java_destination( destination ) )
+        message     = Message.new( @jms_session, payload, options[:encoding] )
+
+        message.populate_message_headers(options)
+        message.populate_message_properties(options[:properties])
+
+        producer.send( message.jms_message,
+                       options.fetch(:delivery_mode, producer.delivery_mode),
+                       options.fetch(:priority, producer.priority),
+                       options.fetch(:ttl, producer.time_to_live) )
+        message
+      end
+
+      # Returns decoded message, by default.  Pass :decode=>false to
+      # return the original JMS TextMessage.  Pass :timeout to give up
+      # after a number of milliseconds
+      def receive(destination, options={})
+        decode = options.fetch(:decode, true)
+        timeout = options.fetch(:timeout, 0)
+        selector = options[:selector]
+        
+        java_destination = java_destination( destination )
+        if options[:durable] && java_destination.class.name =~ /Topic/
+          consumer = @jms_session.createDurableSubscriber( java_destination,
+                                                           options.fetch(:subscriber_name, Topic::DEFAULT_SUBSCRIBER_NAME),
+                                                           selector,
+                                                           false )
+        else
+          consumer = @jms_session.createConsumer( java_destination, selector )      
+        end
+        begin
+          jms_message = consumer.receive( timeout )
+          if jms_message
+            decode ? Message.new( jms_message ).decode : jms_message
+          end
+        ensure
+          consumer.close unless consumer.nil?
+        end
+      end
+
+      # Implement the request-response pattern. Sends a message to the
+      # request destination and waits for a reply on the response
+      # destination.
+      #
+      # Options:
+      #
+      # :timeout - specifies the time in miliseconds to wait for answer,
+      #            default: 10000 (10s)
+      # :decode  - pass false to return the original JMS TextMessage,
+      #            default: true
+      #
+      def publish_and_receive(destination, message, options = {})
+        options[:timeout] ||= 10000 # 10s
+        decode = options.fetch(:decode, false)
+        options[:properties] ||= {}
+        options[:properties]["synchronous"] = "true"
+        wrapped_message = { :timeout => options[:timeout], :message => message }
+        message = publish(destination, wrapped_message, options)
+    
+        options[:selector] = "JMSCorrelationID='#{message.jms_message.jms_message_id}'"
+        response = receive(destination, options)
+    
+        if response
+          decode ? Message.new( response ).decode : response
+        end
+      end
+
+      # Receiving end of the request-response pattern. The return value of
+      # the block passed to this method is the response sent back to the
+      # client. If no block is given then request is returned as the
+      # response.
+      def receive_and_publish(destination, options = {})
+        selector = "synchronous = 'true'"
+        selector = "#{selector} and (#{options[:selector]})" if options[:selector]
+        receive_options = options.merge(:decode => false,
+                                        :selector => selector)
+    
+        request = receive(destination, receive_options)
+        unless request.nil?
+          decoded_request = Message.new( request ).decode
+          request_message = decoded_request[:message]
+          # Base the response ttl off the original request timeout
+          request_timeout = decoded_request[:timeout]
+          options[:ttl] ||= request_timeout
+    
+          response = block_given? ? yield(request_message) : request_message
+    
+          options[:correlation_id] = request.jms_message_id
+          publish(destination, response, options)
+        end
+      end
+
+      def unsubscribe(subscriber_name = Topic::DEFAULT_SUBSCRIBER_NAME)
+        @jms_session.unsubscribe( subscriber_name )
+      end
+      
+      def create_browser(*args)
+        jms_session.create_browser( *args )
+      end
+      
+      def java_destination(destination)
+        java_destination = destination.name
+        
+        unless java_destination.is_a?( javax.jms.Destination )
+          meth = destination.is_a?( Queue ) ? :create_queue : :create_topic
+          java_destination = @jms_session.send( meth, java_destination )
+        end
+        
+        java_destination
+      end
+      
+      def self.canonical_ack_mode(ack_mode)
+        case ( ack_mode )
+          when Fixnum
+            return ack_mode
+          when :auto
+            return AUTO_ACK
+          when :client
+            return CLIENT_ACK
+          when :dups_ok
+            return DUPS_OK_ACK
+        end
+      end
+    end
+
+  end
+end

data/lib/torquebox/messaging/task.rb

@@ -15,24 +15,24 @@
 # Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 # 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 
-require 'torquebox/messaging/destination'
+require 'torquebox/messaging/queue'
 require 'torquebox/messaging/future_responder'
 require 'torquebox/messaging/future'
 require 'torquebox/messaging/future_status'
 
 module TorqueBox
   module Messaging
-
+    
     class Task
       include FutureStatus
       
-      def self.queue_name
-        suffix = org.torquebox.common.util.StringUtils.underscore(name[0...-4])
+      def self.queue_name( name = self.name[0...-4] )
+        suffix = org.torquebox.core.util.StringUtils.underscore(name)
         "/queues/torquebox/#{ENV['TORQUEBOX_APP_NAME']}/tasks/#{suffix}"
       end
 
       def self.async(method, payload = {}, options = {})
-        queue = Queue.new(queue_name)
+        queue = Queue.new( queue_name )
         future = Future.new( queue )
         message = {
           :method => method,
@@ -40,8 +40,9 @@ module TorqueBox
           :future_id => future.correlation_id,
           :future_queue => queue_name
         }
+        options[:encoding] = :marshal
         queue.publish( message, options )
-
+        
         future
       rescue javax.naming.NameNotFoundException => ex
         raise RuntimeError.new("The queue for #{self.name} is not available. Did you disable it by setting its concurrency to 0?")