torquebox-messaging 2.3.2-java → 3.0.0.beta1-java

data/lib/torquebox/messaging/backgroundable.rb

@@ -28,10 +28,13 @@ module TorqueBox
     # Backgroundable provides mechanism for executing an object's
     # methods asynchronously.
     module Backgroundable
+      # @!parse extend BackgroundableClassMethods
+
+      # @api private
       MUTEX = Mutex.new
 
       def self.included(base)
-        base.extend(ClassMethods)
+        base.extend(BackgroundableClassMethods)
         base.extend(FutureStatus)
         base.send(:include, FutureStatus)
       end
@@ -42,7 +45,7 @@ module TorqueBox
       end
 
       # Allows you to background any method that has not been marked
-      # as a backgrounded method via {ClassMethods#always_background}.
+      # as a backgrounded method via {BackgroundableClassMethods#always_background}.
       # @param [Hash] options that are passed through to
       #   {TorqueBox::Messaging::Destination#publish}
       # @return [Future]
@@ -50,7 +53,7 @@ module TorqueBox
         BackgroundProxy.new(self, options)
       end
 
-      module ClassMethods
+      module BackgroundableClassMethods
 
         # Marks methods to always be backgrounded. Takes one or more
         # method symbols, and an optional options hash as the final
@@ -75,7 +78,7 @@ module TorqueBox
         end
 
         # Allows you to background any method that has not been marked
-        # as a backgrounded method via {ClassMethods#always_background}.
+        # as a backgrounded method via {BackgroundableClassMethods#always_background}.
         # @param [Hash] options that are passed through to
         #   {TorqueBox::Messaging::Destination#publish}
         # @return [Future]
@@ -83,16 +86,19 @@ module TorqueBox
           BackgroundProxy.new(self, options)
         end
 
+        # @api private
         def method_added(method)
           super
           __method_added(method)
         end
 
+        # @api private
         def singleton_method_added(method)
           super
           __method_added(method)
         end
 
+        # @api private
         def __enable_backgroundable_newrelic_tracing(method)
           method = method.to_s
           if Backgroundable.newrelic_available?
@@ -170,6 +176,7 @@ module TorqueBox
 
       end
 
+      # @api private
       class BackgroundProxy
         def initialize(receiver, options)
           @receiver = receiver
@@ -183,9 +190,9 @@ module TorqueBox
         end
       end
 
+      # @api private
       module Util
-        extend TorqueBox::Injectors
-        
+
         class << self
           def publish_message(receiver, method, args, options = { })
             queue_name = Task.queue_name( "torquebox_backgroundable" )
@@ -195,9 +202,10 @@ module TorqueBox
             queue.publish( {:receiver => receiver,
                              :future_id => future.correlation_id,
                              :future_queue => queue_name,
+                             :future_ttl => options[:future_ttl],
                              :method => method,
                              :args => args}, options )
-            
+
             future
           rescue javax.jms.InvalidDestinationException => ex
             raise RuntimeError.new("The Backgroundable queue is not available. Did you disable it by setting its concurrency to 0?")
@@ -230,7 +238,7 @@ module TorqueBox
           end
 
           def methods_include?(methods, method)
-            method = (RUBY_VERSION =~ /^1\.9\./ ? method.to_sym : method.to_s)
+            method = (RUBY_VERSION =~ /^1\.8\./ ? method.to_s : method.to_sym)
             methods.include?(method)
           end
         end

data/lib/torquebox/messaging/backgroundable_processor.rb

@@ -21,6 +21,7 @@ require 'torquebox/messaging/future_responder'
 
 module TorqueBox
   module Messaging
+    # @api private
     class BackgroundableProcessor < MessageProcessor
 
       def self.log_newrelic_notice(klass)
@@ -30,7 +31,7 @@ module TorqueBox
       end
 
       def on_message(hash)
-        FutureResponder.new( Queue.new( hash[:future_queue] ), hash[:future_id] ).respond do
+        FutureResponder.new( Queue.new( hash[:future_queue] ), hash[:future_id], hash[:future_ttl] ).respond do
           klass = hash[:receiver].class
           if klass.respond_to?( :__enable_backgroundable_newrelic_tracing )
             klass.__enable_backgroundable_newrelic_tracing( hash[:method] )

data/lib/torquebox/messaging/connection.rb

@@ -21,106 +21,53 @@ require 'torquebox/messaging/session'
 module TorqueBox
   module Messaging
     class Connection
-      include TorqueBox::Injectors
 
-      def initialize(jms_connection)
+      attr_accessor :jms_connection
+
+      def initialize(jms_connection, connection_factory)
         @jms_connection = jms_connection
-        @tm = fetch('transaction-manager')
+        @connection_factory = connection_factory
+        @tm = TorqueBox.fetch('transaction-manager')
       end
 
       def start
-        @jms_connection.start
+        jms_connection.start
       end
 
       def close
-        @jms_connection.close
+        jms_connection.close
       end
 
       def client_id
-        @jms_connection.client_id
+        jms_connection.client_id
       end
 
       def client_id=(client_id)
-        @jms_connection.client_id = client_id
+        jms_connection.client_id = client_id
       end
-      
-      def with_session(enlist_tx = true)
-        if !enlist_tx || (current.nil? && !transaction)
-          begin
-            yield activate( create_session )
-          ensure
-            deactivate
-          end
-        elsif transaction && (!current.respond_to?(:transaction) || current.transaction != transaction)
-          yield activate( create_xa_session )
-        else
-          yield( current )
+
+      def with_session(&block)
+        begin
+          session = create_session
+          result = block.call( session )
+        ensure
+          session.close
         end
+        result
       end
 
-      def sessions
-        Thread.current[:session] ||= []
-      end
-      def current
-        sessions.last
-      end
-      def activate(session)
-        sessions.push(session) && current
-      end
-      def deactivate
-        sessions.pop.close
+      def create_session
+        Session.new( jms_connection.create_session( false, Session::AUTO_ACK ) )
       end
 
       def transaction
         @tm && @tm.transaction
       end
 
-      def create_xa_session
-        jms_session = @jms_connection.create_xa_session()
-        transaction.enlist_resource( jms_session.xa_resource )
-        session = TransactedSession.new( jms_session, transaction, self )
-        transaction.registerSynchronization( session )
-        session
-      end
-
-      def create_session
-        Session.new( @jms_connection.create_session( false, Session::AUTO_ACK ) )
-      end
-
-    end
-    
-    class TransactedSession < Session
-      include javax.transaction.Synchronization
-      attr_reader :transaction
-
-      def initialize( jms_session, transaction, connection )
-        super( jms_session )
-        @transaction = transaction
-        @connection = connection.extend(TransactedConnection)
-      end
-
-      def close
-        # eat the close, until tx completes
-      end
-
-      def beforeCompletion
-        # required interface
-      end
-
-      def afterCompletion(status)
-        @connection.deactivate
-        @connection.complete!
+      def deactivate
+        @connection_factory.deactivate
       end
-    end
 
-    module TransactedConnection
-      def close
-        super if @complete
-      end
-      def complete!
-        @complete = true
-        close
-      end
     end
 
   end

data/lib/torquebox/messaging/connection_factory.rb

@@ -23,7 +23,7 @@ module TorqueBox
     class ConnectionFactory
 
       attr_reader :internal_connection_factory
-      
+
       def self.new(internal_connection_factory = nil)
         return internal_connection_factory if internal_connection_factory.is_a?( ConnectionFactory )
         super
@@ -31,31 +31,70 @@ module TorqueBox
 
       def initialize(internal_connection_factory = nil)
         @internal_connection_factory = internal_connection_factory
+        @tm = TorqueBox.fetch('transaction-manager')
       end
 
-      def with_new_connection(options, &block)
+      def with_new_connection(options, enlist_tx = true, &block)
         client_id = options[:client_id]
-        connection = create_connection( options )
+        create_internal_connection_factory( options )
+        if !enlist_tx || (current.nil? && !transaction)
+          connection = create_connection( options )
+          connection.client_id = client_id if client_id
+          begin
+            connection.start
+            result = block.call( connection )
+          ensure
+            connection.close
+          end
+        elsif transaction && (!current.respond_to?(:session_transaction) || current.session_transaction != transaction)
+          result = block.call( activate( create_xa_connection( options ), client_id ) )
+          # XaSession's afterCompletion callback deactivates XA connections
+        else
+          result = block.call( current )
+        end
+        result
+      end
+
+      def connections
+        Thread.current[:torquebox_connection] ||= []
+      end
+
+      def current
+        connections.last
+      end
+
+      def activate(connection, client_id)
         connection.client_id = client_id if client_id
         connection.start
-        begin
-          result = block.call( connection )
-        ensure
-          connection.close
-        end
-        return result
+        connections.push(connection) && current
+      end
+
+      def deactivate
+        connections.pop.close
       end
 
-      def create_connection(options)
+      def transaction
+        @tm && @tm.transaction
+      end
+
+      def create_internal_connection_factory(options)
         host     = options[:host] || "localhost"
         port     = options[:port] || 5445
-        username = options[:username]
-        password = options[:password]
         if !@internal_connection_factory
           @internal_connection_factory = create_connection_factory( host, port )
         end
+      end
 
-        Connection.new( @internal_connection_factory.create_connection( username, password ) )
+      def create_connection(options={})
+        username = options[:username]
+        password = options[:password]
+        Connection.new( @internal_connection_factory.create_connection( username, password ), self )
+      end
+
+      def create_xa_connection(options={})
+        username = options[:username]
+        password = options[:password]
+        XaConnection.new( @internal_connection_factory.create_xa_connection( username, password ), self )
       end
 
       def create_connection_factory(host, port)

data/lib/torquebox/messaging/datamapper_marshaling.rb

@@ -21,6 +21,7 @@
 # class name of the resource, and use Resource.get to _load it.
 module TorqueBox
   module Messaging
+    # @api private
     module DataMapper
 
       def self.included(base)

data/lib/torquebox/messaging/destination.rb

@@ -24,11 +24,11 @@ require 'torquebox/messaging/ext/javax_jms_queue_browser'
 module TorqueBox
   module Messaging
     class Destination
-      include TorqueBox::Injectors
       include Enumerable
 
       attr_reader :connection_factory
       attr_reader :name
+      attr_reader :java_destination
       attr_accessor :enumerable_options
       attr_accessor :connect_options
 
@@ -39,9 +39,8 @@ module TorqueBox
         :critical => 9
       }
 
-      def _dump(depth)
-        return self.name.queue_name if self.name.respond_to?( :queue_name )
-        self.name.to_s
+      def _dump(level)
+        name
       end
 
       def self._load(str)
@@ -52,7 +51,7 @@ module TorqueBox
         raise ArgumentError, "destination cannot be nil" unless destination
         if connection_factory_or_options.nil? || connection_factory_or_options.is_a?( Hash )
           options = connection_factory_or_options
-          connection_factory = fetch( 'connection-factory' )
+          connection_factory = TorqueBox.fetch( 'connection-factory' )
           unless options.nil?
             # Don't use our internal connection factory if the user
             # has specified a host or port to connect to
@@ -64,10 +63,50 @@ module TorqueBox
           @connection_factory  = ConnectionFactory.new( connection_factory_or_options )
           @connect_options = {}
         end
-        @name                = destination
+
+
+        if destination.is_a?(javax.jms.Destination )
+          if destination.is_a?(javax.jms.Queue)
+            @name = destination.queue_name
+          else
+            @name = destination.topic_name
+          end
+
+          @java_destination = destination
+        else
+          @name = destination
+        end
+
+
         @enumerable_options  = {}
       end
 
+      # Stops the destination.
+      #
+      # @note This is an asynchronous method.
+      # @return [java.util.concurrent.CountDownLatch] The latch to wait for the task completion
+      # @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CountDownLatch.html
+      def stop
+        TorqueBox::Messaging::Destination.with_destinationizer do |destinationizer|
+          destinationizer.remove_destination(name)
+        end
+      end
+
+      # Stops the destination.
+      #
+      # @note This is a synchronous method.
+      # @return [Boolean] true if the destination was successfully stopped, false otherwise
+      # @see TorqueBox::Messaging::Destination.stop
+      def stop_sync
+        latch = stop
+        TorqueBox::Messaging::Destination.wait_for_latch(latch)
+      end
+
+      # Publishes a message to the destination
+      #
+      # @param message The message to publish
+      # @param options Optional parameters (a Hash)
+      # @return [void]
       def publish(message, options = {})
         wait_for_destination(options[:startup_timeout]) do
           with_session(options) do |session|
@@ -107,8 +146,15 @@ module TorqueBox
 
       def with_session(opts = {})
         transactional = opts.fetch(:tx, true)
-        connection_factory.with_new_connection( connect_options ) do |connection|
-          connection.with_session(transactional) do |session|
+
+        # https://issues.jboss.org/browse/TORQUE-1033
+        # If there is no encoding for the message, set the default one
+        # for the destination. If the encoding for destination isn't set
+        # it won't hurt
+        opts[:encoding] = @connect_options[:encoding] if opts[:encoding].nil?
+
+        connection_factory.with_new_connection(connect_options, transactional) do |connection|
+          connection.with_session do |session|
             yield session
           end
         end
@@ -194,6 +240,29 @@ module TorqueBox
         def lookup(name)
           list.find { |destination| destination.name == name }
         end
+
+        # @api private
+        def with_destinationizer
+          service_name = TorqueBox::MSC.deployment_unit.service_name.append('torquebox').append('messaging').append('destinationizer')
+
+          TorqueBox::ServiceRegistry.lookup(service_name) do |destinationizer|
+            yield destinationizer
+          end
+        end
+
+        # @api private
+        def wait_for_latch(latch)
+          if latch
+            begin
+              # Wait for the services to come up for up to 30 seconds
+              latch.await(45, java.util.concurrent.TimeUnit::SECONDS)
+            rescue
+              return false
+            end
+          end
+          
+          true
+        end
       end
 
     end