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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a88f0c3624c3fc1d526b1db306ab3412dda0d25
-  data.tar.gz: e6481e02bfb7293207f3ee0edb92bddbeab7cca5
+  metadata.gz: 0e0d4bba6bdf81556ac4029954113a4ca1261182
+  data.tar.gz: b60488fcd243cb03eb35dd93206a0a81a2979200
 SHA512:
-  metadata.gz: 04b06b767aa8e96226d13458912dbd5a6e589c77d30a537097ccbf05eb35cea634629495dd64310a22547044186b2b2c34c06439dd5ac65997394f1c7c8fe780
-  data.tar.gz: b549fba3e2e7d78af367d22df660e07fe8988cf2e7de0cc54b2f9a24870d167c75798fec2c04b2542b05d1f7ced40ea3cc98dcd8d7e2f5a8017f3a0f15494acb
+  metadata.gz: 379e6fdca557bb4ee68d126334324537ac1abd1793b213b85d566605adf3d6af613668d76cb006efee9d0e44557d63a21a6d27a034d181eec6484ccc25c9379a
+  data.tar.gz: 7f9b80963a6097523f642ac06c0190e007fb8b3d052f1b7476d8a90222e001c835bfbdd486950d2043fdef0a2d26e31c31b2e25d92f2b9f83c3f26d83770b3f7

data/lib/torquebox-messaging.rb

@@ -1,22 +1,21 @@
-module TorqueboxMessaging
-  VERSION = '3.2.0'
-  MAVEN_VERSION = '3.2.0'
-end
-begin
-  require 'java'
-  require File.dirname(__FILE__) + '/torquebox-messaging.jar'
-  require File.dirname(__FILE__) + '/jboss-jms-api_1.1_spec-1.0.1.Final.jar'
-  require File.dirname(__FILE__) + '/jboss-transaction-api_1.1_spec-1.0.1.Final.jar'
-  require File.dirname(__FILE__) + '/hornetq-core-client-2.3.1.Final.jar'
-  require File.dirname(__FILE__) + '/hornetq-commons-2.3.1.Final.jar'
-  require File.dirname(__FILE__) + '/jboss-logging-3.1.2.GA.jar'
-  require File.dirname(__FILE__) + '/netty-3.6.2.Final.jar'
-  require File.dirname(__FILE__) + '/hornetq-journal-2.3.1.Final.jar'
-  require File.dirname(__FILE__) + '/jboss-logmanager-1.4.0.Final.jar'
-  require File.dirname(__FILE__) + '/hornetq-jms-client-2.3.1.Final.jar'
-rescue LoadError
-  puts 'JAR-based gems require JRuby to load. Please visit www.jruby.org.'
-  raise
+# Copyright 2014 Red Hat, Inc, and individual contributors.
+#
+# 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.
+
+require 'torquebox-core'
+
+Dir.glob("#{File.dirname(__FILE__)}/wunderboss-jars/*.jar") do |jar|
+  TorqueBox::Jars.register_and_require(jar)
 end
 
-load File.dirname(__FILE__) + '/gem_hook.rb' if File.exists?( File.dirname(__FILE__) + '/gem_hook.rb')
+require 'torquebox/messaging'

data/lib/torquebox/messaging.rb

@@ -1,22 +1,82 @@
-# 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.
+# Copyright 2014 Red Hat, Inc, and individual contributors.
+#
+# 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.
 
-begin
-  require 'torquebox-messaging'
-rescue LoadError=>e
-  # ignore!
+require 'torquebox/messaging/context'
+require 'torquebox/messaging/destination'
+require 'torquebox/messaging/queue'
+require 'torquebox/messaging/topic'
+require 'torquebox/messaging/hornetq'
+
+module TorqueBox
+  module Messaging
+    def self.default_encoding
+      @default_encoding ||= :marshal
+    end
+
+    def self.default_encoding=(enc)
+      @default_encoding = enc
+    end
+
+    # Creates a new queue reference.
+    #
+    # This may be a reference to a remote or local (in-vm) queue.
+    # Obtaining a reference to an in-vm queue will cause the queue
+    # to be created within the broker if it does not already exist.
+    # For remote queues, the queue must already exist in the remote
+    # broker.
+    #
+    # If a context is provided, it must be remote, and will be
+    # remembered and used by any method that takes a `:context`
+    # option.
+    #
+    # @param name [String] The name of the queue.
+    # @param options [Hash] Options for queue creation.
+    # @option options :context [Context] A context to a
+    #   *remote* broker to use; caller expected to close.
+    # @option options :durable [true, false] (true) Whether messages
+    #   persist across restarts.
+    # @option options :selector [String] A JMS (SQL 92) expression
+    #   to filter published messages.
+    # @option options :default_options [Hash] A set of default
+    #   options to apply to any operations on this queue.
+    # @return [Queue] The queue reference.
+    def self.queue(name, options = {})
+      Queue.new(name, options)
+    end
+
+    # Creates a new topic reference.
+    #
+    # This may be a reference to a remote or local (in-vm) topic.
+    # Obtaining a reference to an in-vm topic will cause the topic
+    # to be created within the broker if it does not already exist.
+    # For remote topics, the topic must already exist in the remote
+    # broker.
+    #
+    # If a context is provided, it must be remote, and will be
+    # remembered and used by any method that takes a `:context`
+    # option.
+    #
+    # @param name [String] The name of the topic.
+    # @param options [Hash] Options for topic creation.
+    # @option options :context [Context] A context to a
+    #   *remote* broker to use; caller expected to close.
+    # @option options :default_options [Hash] A set of default
+    #   options to apply to any operations on this topic.
+    # @return [Topic] The topic reference.
+    def self.topic(name, options = {})
+      Topic.new(name, options)
+    end
+
+  end
 end

data/lib/torquebox/messaging/context.rb

@@ -0,0 +1,174 @@
+# Copyright 2014 Red Hat, Inc, and individual contributors.
+#
+# 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.
+
+require 'torquebox/messaging/helpers'
+
+module TorqueBox
+  module Messaging
+    # Represents a context to the message broker.
+    #
+    # You should only need to create a Context directly if you are
+    # connecting to a remote broker, you need transactional semantics,
+    # or you need better perfomance when doing lots of
+    # {Destination#publish} or {Destination#receive} calls in rapid
+    # succession, since each call will
+    # create and close a context if one is not provided.
+    class Context
+      include TorqueBox::OptionUtils
+      include TorqueBox::Messaging::Helpers
+      extend TorqueBox::OptionUtils
+
+      attr_reader :internal_context
+
+      # Valid options for Context creation.
+      CONTEXT_OPTIONS = optset(WBMessaging::CreateContextOption)
+
+      # Creates a new context.
+      #
+      # You are responsible for closing any contexts you create.
+      #
+      # If given a block, the Context instance will be passed to
+      # the block and the Context will be closed once the block
+      # returns.
+      #
+      # @param options [Hash]
+      # @option options :mode [Symbol] (:auto_ack) One of: :auto_ack,
+      #   :client_ack, :transacted
+      # @option options :client_id [String] Identifies the client id
+      #   for use with a durable topic subscriber.
+      # @option options :host [String] The host of a remote broker.
+      # @option options :port [Number] (nil, 5445 if :host provided)
+      #   The port of a remote broker.
+      # @option options :username [String] The username for the remote
+      #   broker.
+      # @option options :password [String] The password for the remote
+      #   broker.
+      # @option options :remote_type [Symbol] (:hornetq_standalone)
+      #   When connecting to a HornetQ instance running inside
+      #   WildFly, this needs to be set to :hornetq_wildfly.
+      # @option options :reconnect_attempts [Number] (0) Total number
+      #   of reconnect attempts to make before giving up (-1 for unlimited).
+      # @option options :reconnect_retry_interval [Number] (2000) The
+      #   period in milliseconds between subsequent recontext attempts.
+      # @option options :reconnect_max_retry_interval [Number] (2000)
+      #   The max retry interval that will be used.
+      # @option options :reconnect_retry_interval_multiplier [Number]
+      #   (1.0) A multiplier to apply to the time since the last retry
+      #   to compute the time to the next retry.
+      # @return [Context]
+      def initialize(options = {}, &block)
+        validate_options(options, CONTEXT_OPTIONS)
+        options[:mode] = coerce_mode(options[:mode])
+        create_options = extract_options(options, WBMessaging::CreateContextOption)
+        @internal_context = default_broker.create_context(create_options)
+        if block
+          begin
+            block.call(self)
+          ensure
+            close
+          end
+        end
+      end
+
+      # Creates a Queue from this context.
+      #
+      # The Queue instance will use this context for
+      # any of its methods that take a `:context` option.
+      #
+      # @param (see Queue#initialize)
+      # @return (see Queue#initialize)
+      def queue(name, options = {})
+        TorqueBox::Messaging.queue(name, options.merge(:context => self))
+      end
+
+      # Creates a Topic from this context.
+      #
+      # The Topic instance will use this context for
+      # any of its methods that take a `:context` option.
+      #
+      # @param (see Topic#initialize)
+      # @return (see Topic#initialize)
+      def topic(name, options = {})
+        TorqueBox::Messaging.topic(name, options.merge(:context => self))
+      end
+
+      # Closes this context.
+      #
+      # Once closed, any operations on this context will raise
+      # errors.
+      # @return [void]
+      def close
+        @internal_context.close
+      end
+
+
+      # Rolls back the context.
+      #
+      # This only has affect for :transacted contexts.
+      #
+      # @return [void]
+      def rollback
+        @internal_context.rollback
+      end
+
+      # Commits the context.
+      #
+      # This only has affect for :transacted contexts.
+      #
+      # @return [void]
+      def commit
+        @internal_context.commit
+      end
+
+      # Acknowledge any un-acknowledged messages in this context.
+      #
+      # This only has affect for :client_ack contexts.
+      #
+      # @return [void]
+      def acknowledge
+        @internal_context.acknowledge
+      end
+
+      # @return [Symbol] The mode of this context.
+      def mode
+        case @internal_context.mode
+        when WBContext::Mode::AUTO_ACK
+          :auto_ack
+        when WBContext::Mode::CLIENT_ACK
+          :client_ack
+        when WBContext::Mode::TRANSACTED
+          :transacted
+        end
+      end
+
+      protected
+
+      def coerce_mode(mode)
+        case mode
+        when nil
+          nil
+        when :auto_ack
+          WBContext::Mode::AUTO_ACK
+        when :client_ack
+          WBContext::Mode::CLIENT_ACK
+        when :transacted
+          WBContext::Mode::TRANSACTED
+        else
+          fail ArgumentError.new("#{mode} is not a valid context mode.")
+        end
+      end
+
+    end
+  end
+end

data/lib/torquebox/messaging/destination.rb

@@ -1,37 +1,34 @@
-# 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/msc'
-require 'torquebox/messaging/session'
-require 'torquebox/messaging/connection_factory'
-require 'torquebox/messaging/ext/javax_jms_queue_browser'
+# Copyright 2014 Red Hat, Inc, and individual contributors.
+#
+# 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.
+
+require 'torquebox/codecs'
+require 'torquebox/messaging/helpers'
 
 module TorqueBox
   module Messaging
+    # Represents a messaging destination.
+    #
+    # You'll never instantiate a Destination directly, but use {Queue}
+    # or {Topic} instead.
     class Destination
-      include Enumerable
+      include TorqueBox::OptionUtils
+      include TorqueBox::Messaging::Helpers
+      extend TorqueBox::OptionUtils
 
-      attr_reader :connection_factory
-      attr_reader :name
-      attr_reader :java_destination
-      attr_accessor :enumerable_options
-      attr_accessor :connect_options
+      attr_accessor :internal_destination
 
+      # Maps priority mnemonics to priority values.
       PRIORITY_MAP = {
         :low => 1,
         :normal => 4,
@@ -39,228 +36,180 @@ module TorqueBox
         :critical => 9
       }
 
-      def _dump(level)
-        name
-      end
+      # Valid options for {#publish}.
+      PUBLISH_OPTIONS = optset(WBDestination::PublishOption, :encoding)
 
-      def self._load(str)
-        self.new( str )
+      # Send a message to this destination.
+      #
+      # The message can be any data that can be encoded using the
+      # given :encoding.
+      #
+      # If no context is provided, a new context will be created, then
+      # closed.
+      #
+      # @param message [Object] The message to send.
+      # @param options [Hash] Options for message publication.
+      # @option options :encoding [Symbol] (:marshal) one of: :edn, :json,
+      #   :marshal, :marshal_base64, :text
+      # @option options :priority [Symbol, Number] (:normal) 0-9, or
+      #   one of: :low, :normal, :high, :critical
+      # @option options :ttl [Number] (0) time to live, in millis, 0
+      #   == forever
+      # @option options :persistent [true, false] (true) whether
+      #   undelivered messages survive restarts
+      # @option options :properties [Hash] a hash to which selectors
+      #   may be applied
+      # @option options :context [Context] a context to use;
+      #   caller expected to close
+      # @return [void]
+      def publish(message, options = {})
+        validate_options(options, PUBLISH_OPTIONS)
+        options = apply_default_options(options)
+        options = normalize_publish_options(options)
+        options = coerce_context(options)
+        encoding = options[:encoding] || Messaging.default_encoding
+        @internal_destination.publish(message,
+                                      Codecs[encoding],
+                                      extract_options(options, WBDestination::PublishOption))
       end
 
-      def initialize(destination, connection_factory_or_options = nil)
-        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 = 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
-            connection_factory = nil if options[:host] or options[:port]
-          end
-          @connection_factory = ConnectionFactory.new( connection_factory )
-          @connect_options = options || {}
-        else
-          @connection_factory  = ConnectionFactory.new( connection_factory_or_options )
-          @connect_options = {}
-        end
+      # Valid options for {#receive}.
+      RECEIVE_OPTIONS = optset(WBDestination::ReceiveOption, :decode, :timeout_val)
 
-
-        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  = {}
+      # Receive a message from this destination.
+      #
+      # Can optionally be given a block that will be called with
+      # the message.
+      #
+      # If a :selector is provided, then only messages having
+      # properties matching that expression may be received.
+      #
+      # If no context is provided, a new context will be created, then
+      # closed.
+      #
+      # @param options [Hash] Options for message receipt.
+      # @option options :timeout [Number] (10000) Time in millis,
+      #   after which the :timeout_val is returned. 0
+      #   means wait forever, -1 means don't wait at all
+      # @option options :timeout_val [Object] The value to
+      #   return when a timeout occurs. Also returned when
+      #   a :timeout of -1 is specified, and no message is available
+      # @option options :selector [String] A JMS (SQL 92) expression
+      #   matching message properties
+      # @option options :decode [true, false] (true) If true, the
+      #   decoded message body is returned. Otherwise, the
+      #   base message object is returned.
+      # @option options :context [Context] a context to use;
+      #   caller expected to close
+      # @return The message, or the return value of the block if a
+      #   block is given.
+      def receive(options = {}, &block)
+        validate_options(options, RECEIVE_OPTIONS)
+        options = apply_default_options(options)
+        options = coerce_context(options)
+        result = @internal_destination.receive(Codecs.java_codecs,
+                                               extract_options(options, WBDestination::ReceiveOption))
+        msg = if result
+                options.fetch(:decode, true) ? result.body : result
+              else
+                options[:timeout_val]
+              end
+        block ? block.call(msg) : msg
       end
 
-      # Stops the destination.
+      # Valid options for {#listen}
+      LISTEN_OPTIONS = optset(WBDestination::ListenOption, :encoding, :decode)
+
+      # Registers a block to receive each message sent to this 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)
+      # If a :selector is provided, then only messages having
+      # properties matching that expression will be received.
+      #
+      # If given a context, the context must be remote, and the mode
+      # of that context is ignored, since it is used solely to
+      # generate sub-contexts for each listener thread. Closing the
+      # given context will also close the listener.
+      #
+      # If no context is provided, a new context will be created, then
+      # closed.
+      #
+      # @param options [Hash] Options for the listener.
+      # @option options :concurrency [Number] (1) The number of
+      #   threads handling messages.
+      # @option options :selector [String] A JMS (SQL 92) expression
+      #   matching message properties
+      # @option options :decode [true, false] If true, the decoded
+      #   message body is passed to the block. Otherwise, the
+      #   base message object is passed.
+      # @option options :context [Context] a *remote* context to
+      #   use; caller expected to close.
+      # @return A listener object that can be stopped by
+      #   calling .close on it.
+      def listen(options = {}, &block)
+        validate_options(options, LISTEN_OPTIONS)
+        options = apply_default_options(options)
+        options = coerce_context(options)
+        handler = MessageHandler.new do |message|
+          block.call(options.fetch(:decode, true) ? message.body : message)
         end
+        @internal_destination.listen(handler,
+                                     Codecs.java_codecs,
+                                     extract_options(options, WBDestination::ListenOption))
       end
 
-      # Stops the destination.
+      # Stops this 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
-        TorqueBox::Messaging::Destination.wait_for_latch(stop)
-      end
-      
-      # Publishes a message to the destination
+      # Note that stopping a destination may remove it from the broker if
+      # called outside of the container.
       #
-      # @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|
-            session.publish self, message, normalize_options(options)
-          end
-        end
+      def stop
+        @internal_destination.stop
       end
 
-      def receive(options = {}, &block)
-        wait_for_destination(options[:startup_timeout]) do
-          func = lambda do
-            with_session(options) do |session|
-              session.receive self, options, &block
-            end
-          end
-          if block
-            TorqueBox.transaction &func
-          else
-            func.call
-          end
-        end
-      end
+      protected
 
-      def each(&block)
-        wait_for_destination do
-          with_session do |session|
-            destination = session.java_destination( self )
-            browser = session.create_browser( destination, enumerable_options[:selector] )
-            begin
-              browser.each(&block)
-            ensure
-              browser.close
-            end
-          end
-        end
+      def initialize(internal_destination, options)
+        @internal_destination = internal_destination
+        @default_options = options[:default_options] || {}
+        @default_options[:context] ||= options[:context]
       end
 
-      def with_session(opts = {})
-        transactional = opts.fetch(:tx, true)
-
-        # 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
+      def apply_default_options(options)
+        @default_options.merge(options || {})
       end
 
-      def wait_for_destination(timeout=nil, &block)
-        timeout ||= 30_000 # 30s default
-        start = Time.now
-        begin
-          block.call
-        rescue javax.naming.NameNotFoundException, javax.jms.JMSException
-          elapsed = (Time.now - start) * 1000
-          if elapsed > timeout
-            raise
-          else
-            sleep(0.1)
-            retry
-          end
-        end
+      def coerce_context(options)
+        options = options.dup
+        options[:context] = options[:context].internal_context if options[:context]
+        options
       end
 
-      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)
+      def normalize_publish_options(options)
+        options = options.dup
+        if options.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(',')}")
+            priorities = PRIORITY_MAP.keys.map { |k| ":#{k }" }.join(',')
+            fail ArgumentError.new(":priority must in the range 0..9, or one of #{priorities}")
           end
         end
-
         options
       end
 
-      def enumerable_options
-        @enumerable_options ||= { }
-        @enumerable_options
-      end
-
-      def to_s
-        name
-      end
-
-      class << self
-
-        # List all destinations of this application.
-        #
-        # @return Array of {TorqueBox::Messaging::Queue} or {TorqueBox::Messaging::Topic}
-        #  depending on the destination type.
-        def list
-          # Get the JMS Manager
-          TorqueBox::ServiceRegistry.lookup("jboss.messaging.default.jms.manager") do |manager|
-
-            # JMSServerControl will let us grab the deployed queue/topic list
-            server_control = Java::org.hornetq.jms.management.impl.JMSServerControlImpl.new(manager)
-
-            # Retrieve the destination list appropriate to the destination type
-            if self == TorqueBox::Messaging::Topic
-              names = server_control.topic_names
-            elsif self == TorqueBox::Messaging::Queue
-              names = server_control.queue_names
-            else
-              names = []
-            end
+      # @api private
+      class MessageHandler
+        include Java::OrgProjectoddWunderbossMessaging::MessageHandler
 
-            names.map { |name| self.new(name) }
-          end
-        end
-
-        # Lookup a destination of this application by name. A destination could be
-        # a queue or topic.
-        #
-        # @param [String] name of the destination
-        #
-        # @return [TorqueBox::Messaging::Queue] or [TorqueBox::Messaging::Topic]
-        #   The destination instance.
-        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
+        def initialize(&block)
+          @block = block
         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
+        def on_message(message, context)
+          @block.call(message, context)
         end
       end