torquebox-messaging 1.0.0.CR1-java

data/lib/gem_hook.rb

@@ -0,0 +1,22 @@
+# 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/client'
+require 'torquebox/messaging/task'
+require 'torquebox/messaging/destination'
+require 'torquebox/messaging/message_processor'
+require 'torquebox/messaging/backgroundable'

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

@@ -0,0 +1,20 @@
+# 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.
+
+# 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

@@ -0,0 +1,134 @@
+# 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'
+
+module TorqueBox
+  module Messaging
+    module Backgroundable
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def background(options = { })
+        BackgroundProxy.new(self, options)
+      end
+
+      module ClassMethods
+
+        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.instance_methods_include?(self, method) ||
+                  Util.private_instance_methods_include?(self, method)
+                __enable_backgrounding(method)
+              end
+            end
+          end
+        end
+
+        def method_added(method)
+          method = method.to_s
+          if @__backgroundable_methods &&
+              @__backgroundable_methods[method] &&
+              !@__backgroundable_methods[method][:backgrounding]
+            __enable_backgrounding(method)
+          else
+            super
+          end
+        end
+
+        private
+        def __enable_backgrounding(method)
+          privatize = Util.private_instance_methods_include?(self, method)
+          protect = Util.protected_instance_methods_include?(self, method) unless privatize
+          async_method = "__async_#{method}"
+          sync_method = "__sync_#{method}"
+
+          @__backgroundable_methods[method][:backgrounding] = true
+          options = @__backgroundable_methods[method][:options]
+          class_eval do
+
+            define_method async_method do |*args|
+              Util.publish_message(self, sync_method, args, options)
+            end
+
+            alias_method sync_method, method
+            alias_method method, async_method
+
+            if privatize || protect
+              send((privatize ? :private : :protected), method, sync_method, async_method)
+            end
+          end
+        ensure
+          @__backgroundable_methods[method][:backgrounding] = nil
+        end
+
+      end
+
+      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
+
+      module Util
+        QUEUE_NAME = "/queues/torquebox/#{ENV['TORQUEBOX_APP_NAME']}/backgroundable"
+
+        class << self
+          def publish_message(receiver, method, args, options = { })
+            Queue.new(QUEUE_NAME).publish({:receiver => receiver, :method => method, :args => args}, options)
+          rescue javax.naming.NameNotFoundException => ex
+            raise RuntimeError.new("The backgroundable queue is not available. Did you disable it by setting its concurrency to 0?")
+          end
+
+          def instance_methods_include?(klass, method)
+            methods_include?(klass.instance_methods, 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\.9\./ ? method.to_sym : method.to_s)
+            methods.include?(method)
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/torquebox/messaging/client.rb

@@ -0,0 +1,74 @@
+# 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.
+
+begin
+  require 'torquebox-messaging'
+rescue LoadError=>e
+  # ignore!
+end
+
+require 'torquebox/naming'
+require 'torquebox/messaging/ext/javax_jms_session'
+
+module TorqueBox
+  module Messaging
+
+    class Client
+
+      AUTO_ACK = javax.jms::Session::AUTO_ACKNOWLEDGE
+      CLIENT_ACK = javax.jms::Session::CLIENT_ACKNOWLEDGE
+      DUPS_OK_ACK = javax.jms::Session::DUPS_OK_ACKNOWLEDGE
+
+ 
+      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
+
+      def self.connect(options={}, &block)
+        transacted = options.fetch(:transacted, true)
+        ack_mode = options.fetch(:ack_mode, AUTO_ACK)
+        naming_host = options[:naming_host]
+        naming_port = options[:naming_port]
+        connection_factory = nil
+        TorqueBox::Naming.connect( naming_host, naming_port ) do |context|
+          connection_factory = context['/ConnectionFactory']
+          connection = connection_factory.createConnection
+          session = connection.createSession( transacted, canonical_ack_mode( ack_mode ) )
+          connection.start
+          session.naming_context = context
+          session.connection = connection
+          return session if ( block.nil? )
+          begin
+            block.call( session )
+          ensure 
+            connection.close()
+          end 
+        end
+      end
+    end
+
+  end
+end

data/lib/torquebox/messaging/destination.rb

@@ -0,0 +1,173 @@
+# 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/kernel'
+require 'torquebox/messaging/client'
+
+require 'torquebox/messaging/ext/javax_jms_queue_browser'
+
+module TorqueBox
+  module Messaging
+
+    module Destination
+      include Enumerable
+      
+      attr_reader :name
+
+      PRIORITY_MAP = {
+          :low => 1,
+          :normal => 4,
+          :high => 7,
+          :critical => 9
+      }
+
+      def initialize(name, connect_options=nil, enumerable_options=nil)
+        @name = name
+        @connect_options = connect_options || {}
+        @enumerable_options = enumerable_options || {}
+      end
+
+      def publish(message, options = {})
+        wait_for_destination(options[:startup_timeout]) {
+          Client.connect(@connect_options) do |session|
+            session.publish name, message, normalize_options(options)
+            session.commit if session.transacted?
+          end
+        }
+      end
+
+      def receive(options={})
+        result = nil
+        wait_for_destination(options[:startup_timeout]) {
+          Client.connect(@connect_options) do |session|
+            result = session.receive( name, options )
+            session.commit if session.transacted?
+          end
+        }
+        result
+      end
+
+      def start
+        TorqueBox::Kernel.lookup("JMSServerManager") do |server|
+          destination.name = name
+          destination.server = server
+          destination.create
+        end
+      end
+      alias_method :create, :start
+
+      def destroy
+        TorqueBox::Kernel.lookup("JMSServerManager") do |server|
+          destination.name = name
+          destination.server = server
+          destination.destroy
+        end
+      end
+
+      def each(&block)
+        wait_for_destination do
+          Client.connect(@connect_options) do |session|
+            destination = session.lookup_destination( name )
+            browser = session.create_browser( destination, @enumerable_options[:selector] )
+            begin
+              browser.each(&block)
+            ensure
+              browser.close
+            end
+          end
+        end
+      end
+      
+      def to_s
+        name
+      end
+
+      protected
+
+      def normalize_options(options)
+        if options.has_key?(:persistent)
+          options[:delivery_mode] =
+            options.delete(:persistent) ? javax.jms::DeliveryMode.PERSISTENT : javax.jms::DeliveryMode.NON_PERSISTENT
+        end
+
+        if options.has_key?(:priority)
+          if PRIORITY_MAP[options[:priority]]
+            options[:priority] = PRIORITY_MAP[options[:priority]]
+          elsif (0..9) === options[:priority].to_i
+            options[:priority] = options[:priority].to_i
+          else
+            raise ArgumentError.new(":priority must in the range 0..9, or one of #{PRIORITY_MAP.keys.collect {|k| ":#{k}"}.join(',')}")
+          end
+        end
+
+        options
+      end
+
+      def wait_for_destination(timeout=nil, &block)
+        timeout ||= 30000 # 30s default
+        start = Time.now
+        begin
+          block.call
+        rescue javax.naming.NameNotFoundException => ex
+          elapsed = (Time.now - start) * 1000
+          if elapsed > timeout
+            raise ex
+          else
+            sleep(0.1)
+            retry
+          end
+        end
+      end
+    end
+
+    class Queue
+      include Destination
+      def destination
+        @destination ||= Java::org.torquebox.messaging.core::ManagedQueue.new
+      end
+
+      def publish_and_receive(message, options={})
+        result = nil
+        wait_for_destination(options[:startup_timeout]) {
+          Client.connect(@connect_options) do |session|
+            result = session.publish_and_receive(name, message,
+                                                 normalize_options(options))
+            session.commit if session.transacted?
+          end
+        }
+        result
+      end
+
+      def receive_and_publish(options={}, &block)
+        wait_for_destination(options[:startup_timeout]) {
+          Client.connect(@connect_options) do |session|
+            session.receive_and_publish(name, normalize_options(options), &block)
+            session.commit if session.transacted?
+          end
+        }
+      end
+    end
+
+    class Topic
+      include Destination
+      def destination
+        @destination ||= Java::org.torquebox.messaging.core::ManagedTopic.new
+      end
+    end
+
+  end
+end

data/lib/torquebox/messaging/ext/javax_jms_queue_browser.rb

@@ -0,0 +1,27 @@
+# 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 javax.jms::QueueBrowser
+  include Enumerable
+  
+  def each(&block)
+    enumeration.each(&block)
+  end
+end
+

data/lib/torquebox/messaging/ext/javax_jms_session.rb

@@ -0,0 +1,142 @@
+# 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/javax_jms_text_message'
+
+module javax.jms::Session
+
+  attr_accessor :connection
+  attr_accessor :naming_context
+
+  def publish(destination, message, options = {})
+    destination = lookup_destination( destination ) unless destination.is_a?( Java::javax.jms.Destination )
+    producer = createProducer( destination )
+    jms_message = create_text_message
+    populate_message_headers(jms_message, options)
+    populate_message_properties(jms_message, options[:properties])
+    jms_message.encode message
+    producer.send( jms_message,
+                   options.fetch(:delivery_mode, producer.delivery_mode),
+                   options.fetch(:priority, producer.priority),
+                   options.fetch(:ttl, producer.time_to_live) )
+    jms_message
+  ensure
+    producer.close unless producer.nil?
+  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_name, options={})
+    decode = options.fetch(:decode, true)
+    timeout = options.fetch(:timeout, 0)
+    selector = options.fetch(:selector, nil)
+    destination = lookup_destination( destination_name )
+    consumer = createConsumer( destination, selector )
+    jms_message = consumer.receive( timeout )
+    if jms_message
+      decode ? jms_message.decode : jms_message
+    end
+  ensure
+    consumer.close unless consumer.nil?
+  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 }
+    jms_message = publish(destination, wrapped_message, options)
+    commit if transacted?
+
+    options[:selector] = "JMSCorrelationID='#{jms_message.jms_message_id}'"
+    response = receive(destination, options)
+    commit if transacted?
+
+    if response
+      decode ? 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 = {})
+    receive_options = options.merge(:decode => false,
+                                    :selector => "synchronous = 'true'")
+    request = receive(destination, receive_options)
+    unless request.nil?
+      decoded_request = 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
+    commit if transacted?
+  end
+
+  def lookup_destination(destination_name)
+    @naming_context[ destination_name ]
+  end
+
+  def populate_message_headers(jms_message, 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(jms_message, 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
+
+end
+