torquebox-messaging 3.2.0-java → 4.0.0.alpha1-java

data/lib/org.torquebox.messaging-client.rb

@@ -1,20 +0,0 @@
-# Copyright 2008-2013 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.
-
-# Backwards-compatibility
-$stderr.puts "Usage of 'org.torquebox.messaging-client' is deprecated.  Please use 'torquebox-messaging'."
-require 'torquebox-messaging'

data/lib/torquebox/messaging/backgroundable.rb

@@ -1,250 +0,0 @@
-# Copyright 2008-2013 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/queue'
-require 'torquebox/messaging/future'
-require 'torquebox/messaging/task'
-require 'torquebox/messaging/future_status'
-require 'torquebox/injectors'
-require 'torquebox/logger'
-
-module TorqueBox
-  module Messaging
-
-    # 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(BackgroundableClassMethods)
-        base.extend(FutureStatus)
-        base.send(:include, FutureStatus)
-      end
-
-      # Signals if the newrelic gem is loaded.
-      def self.newrelic_available?
-        defined?(NewRelic::Agent)
-      end
-
-      # Allows you to background any method that has not been marked
-      # as a backgrounded method via {BackgroundableClassMethods#always_background}.
-      # @param [Hash] options that are passed through to
-      #   {TorqueBox::Messaging::Destination#publish}
-      # @return [Future]
-      def background(options = { })
-        BackgroundProxy.new(self, options)
-      end
-
-      module BackgroundableClassMethods
-
-        # Marks methods to always be backgrounded. Takes one or more
-        # method symbols, and an optional options hash as the final
-        # argument. The options allow you to set publish options for
-        # each call.
-        # see TorqueBox::Messaging::Destination#publish
-        def always_background(*methods)
-          options = methods.last.is_a?(Hash) ? methods.pop : {}
-          @__backgroundable_methods ||= {}
-
-          methods.each do |method|
-            method = method.to_s
-            if !@__backgroundable_methods[method]
-              @__backgroundable_methods[method] ||= { }
-              @__backgroundable_methods[method][:options] = options
-              if Util.singleton_methods_include?(self, method) ||
-                  Util.instance_methods_include?(self, method)
-                __enable_backgrounding(method)
-              end
-            end
-          end
-        end
-
-        # Allows you to background any method that has not been marked
-        # as a backgrounded method via {BackgroundableClassMethods#always_background}.
-        # @param [Hash] options that are passed through to
-        #   {TorqueBox::Messaging::Destination#publish}
-        # @return [Future]
-        def background(options = { })
-          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?
-            TorqueBox::Messaging::Backgroundable::MUTEX.synchronize do
-              @__enabled_bg_tracing_methods ||= {}
-              if !@__enabled_bg_tracing_methods[method]
-                include(NewRelic::Agent::Instrumentation::ControllerInstrumentation) unless
-                  include?(NewRelic::Agent::Instrumentation::ControllerInstrumentation)
-                begin
-                  add_transaction_tracer(method, :name => method.sub("__sync_", ""), :category => :task)
-                rescue Exception => e
-                  TorqueBox::Logger.new( Backgroundable ).error "Error loading New Relic for backgrounded method #{method.sub("__sync_", "")}: #{e}"
-                end
-                @__enabled_bg_tracing_methods[method] = true
-              end
-            end
-          end
-        end
-
-        private
-        
-        def __method_added(method)
-          method = method.to_s
-          if @__backgroundable_methods &&
-              @__backgroundable_methods[method] &&
-              !@__backgroundable_methods[method][:backgrounding]
-            __enable_backgrounding(method)
-          end
-        end
-
-        def __enable_backgrounding(method)
-          singleton_method = Util.singleton_methods_include?(self, method)
-          singleton = (class << self; self; end)
-
-          if singleton_method
-
-            TorqueBox::Logger.new( self ).
-              warn("always_background called for :#{method}, but :#{method} " +
-                   "exists as both a class and instance method. Only the " +
-                   "class method will be backgrounded.") if Util.instance_methods_include?(self, method)
-
-            privatize = Util.private_singleton_methods_include?(self, method)
-            protect = Util.protected_singleton_methods_include?(self, method) unless privatize
-          else
-            privatize = Util.private_instance_methods_include?(self, method)
-            protect = Util.protected_instance_methods_include?(self, method) unless privatize
-          end
-
-          async_method = "__async_#{method}"
-          sync_method = "__sync_#{method}"
-
-          @__backgroundable_methods[method][:backgrounding] = true
-          options = @__backgroundable_methods[method][:options]
-
-          (singleton_method ? singleton : self).class_eval do
-            define_method async_method do |*args|
-              Util.publish_message(self, sync_method, args, options)
-            end
-          end
-          
-          code = singleton_method ? "class << self" : ""
-          code << %Q{
-            alias_method :#{sync_method}, :#{method}
-            alias_method :#{method}, :#{async_method}
-          }
-          code << %Q{
-            #{privatize ? "private" : "protected"} :#{method}, :#{sync_method}, :#{async_method}
-          } if privatize || protect
-          code << "end" if singleton_method
-
-          class_eval code          
-        ensure
-          @__backgroundable_methods[method][:backgrounding] = nil
-        end
-
-      end
-
-      # @api private
-      class BackgroundProxy
-        def initialize(receiver, options)
-          @receiver = receiver
-          @options = options
-        end
-
-        def method_missing(method, *args, &block)
-          @receiver.method_missing(method, *args, &block) unless @receiver.respond_to?(method)
-          raise ArgumentError.new("Backgrounding a method with a block argument is not supported. If you need this feature, please file a feature request at http://issues.jboss.org/browse/TORQUE") if block_given?
-          Util.publish_message(@receiver, method, args, @options)
-        end
-      end
-
-      # @api private
-      module Util
-
-        class << self
-          def publish_message(receiver, method, args, options = { })
-            queue_name = Task.queue_name( "torquebox_backgroundable" )
-            queue = Queue.new( queue_name )
-            future = Future.new( queue )
-            options[:encoding] = :marshal
-            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?")
-          end
-
-          def singleton_methods_include?(klass, method)
-            methods_include?(klass.singleton_methods, method) ||
-              private_singleton_methods_include?(klass, method)
-          end
-
-          def private_singleton_methods_include?(klass, method)
-            methods_include?(klass.private_methods, method)
-          end
-
-          def protected_singleton_methods_include?(klass, method)
-            methods_include?(klass.protected_methods, method)
-          end
-
-          def instance_methods_include?(klass, method)
-            methods_include?(klass.instance_methods, method) ||
-              private_instance_methods_include?(klass, method)
-          end
-
-          def private_instance_methods_include?(klass, method)
-            methods_include?(klass.private_instance_methods, method)
-          end
-
-          def protected_instance_methods_include?(klass, method)
-            methods_include?(klass.protected_instance_methods, method)
-          end
-
-          def methods_include?(methods, method)
-            method = (RUBY_VERSION =~ /^1\.8\./ ? method.to_s : method.to_sym)
-            methods.include?(method)
-          end
-        end
-      end
-    end
-  end
-end
-
-

data/lib/torquebox/messaging/backgroundable_processor.rb

@@ -1,52 +0,0 @@
-# Copyright 2008-2013 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/message_processor'
-require 'torquebox/messaging/const_missing'
-require 'torquebox/messaging/future_responder'
-
-module TorqueBox
-  module Messaging
-    # @api private
-    class BackgroundableProcessor < MessageProcessor
-
-      def self.log_newrelic_notice(klass)
-        @newrelic_notice_logged ||=
-          log.warn( "The New Relic agent is loaded, but an issue with the inheritance hierachy of " <<
-                    klass.name << " prevents us from reporting on its Backgroundable calls." ) || true
-      end
-
-      def on_message(hash)
-        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] )
-          elsif Backgroundable.newrelic_available? 
-            self.class.log_newrelic_notice( klass )
-          end
-          
-          hash[:receiver].send(hash[:method], *hash[:args])
-        end
-      end
-
-      private
-      def self.log
-        @logger ||= TorqueBox::Logger.new( self )
-      end
-    end
-  end
-end

data/lib/torquebox/messaging/connection.rb

@@ -1,74 +0,0 @@
-# Copyright 2008-2013 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/injectors'
-require 'torquebox/messaging/session'
-
-module TorqueBox
-  module Messaging
-    class Connection
-
-      attr_accessor :jms_connection
-
-      def initialize(jms_connection, connection_factory)
-        @jms_connection = jms_connection
-        @connection_factory = connection_factory
-        @tm = TorqueBox.fetch('transaction-manager')
-      end
-
-      def start
-        jms_connection.start
-      end
-
-      def close
-        jms_connection.close
-      end
-
-      def client_id
-        jms_connection.client_id
-      end
-
-      def client_id=(client_id)
-        jms_connection.client_id = client_id
-      end
-
-      def with_session(&block)
-        begin
-          session = create_session
-          result = block.call( session )
-        ensure
-          session.close
-        end
-        result
-      end
-
-      def create_session
-        Session.new( jms_connection.create_session( false, Session::AUTO_ACK ) )
-      end
-
-      def transaction
-        @tm && @tm.transaction
-      end
-
-      def deactivate
-        @connection_factory.deactivate
-      end
-
-    end
-
-  end
-end

data/lib/torquebox/messaging/connection_factory.rb

@@ -1,115 +0,0 @@
-# Copyright 2008-2013 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 'java'
-require 'torquebox/messaging/connection'
-
-module TorqueBox
-  module Messaging
-    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
-      end
-
-      def initialize(internal_connection_factory = nil)
-        @internal_connection_factory = internal_connection_factory
-        @tm = TorqueBox.fetch('transaction-manager')
-      end
-
-      def with_new_connection(options, enlist_tx = true, &block)
-        client_id = options[:client_id]
-        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
-        connections.push(connection) && current
-      end
-
-      def deactivate
-        connections.pop.close
-      end
-
-      def transaction
-        @tm && @tm.transaction
-      end
-
-      def create_internal_connection_factory(options)
-        host     = options[:host] || "localhost"
-        port     = options[:port] || 5445
-        if !@internal_connection_factory
-          @internal_connection_factory = create_connection_factory( host, port )
-        end
-      end
-
-      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)
-        connect_opts = { "host" => host, "port" => port }
-        transport_config =
-          org.hornetq.api.core.TransportConfiguration.new("org.hornetq.core.remoting.impl.netty.NettyConnectorFactory",
-                                                          connect_opts)
-        org.hornetq.api.jms.HornetQJMSClient.createConnectionFactoryWithoutHA( org.hornetq.api.jms::JMSFactoryType::CF, transport_config )
-      end
-
-
-      def to_s
-        "[ConnectionFactory: internal_connection_factory=#{internal_connection_factory}]"
-      end
-
-    end
-  end
-end