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

data/lib/torquebox/messaging/helpers.rb

@@ -0,0 +1,34 @@
+# 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.
+
+
+module TorqueBox
+  module Messaging
+    # @api private
+    module Helpers
+      WB = org.projectodd.wunderboss.WunderBoss
+      WBDestination = org.projectodd.wunderboss.messaging.Destination
+      WBMessaging = org.projectodd.wunderboss.messaging.Messaging
+      WBQueue = org.projectodd.wunderboss.messaging.Queue
+      WBTopic = org.projectodd.wunderboss.messaging.Topic
+      WBContext = org.projectodd.wunderboss.messaging.Context
+
+      protected
+
+      def default_broker
+        WB.find_or_create_component(WBMessaging.java_class, 'default', nil)
+      end
+    end
+  end
+end

data/lib/torquebox/messaging/hornetq.rb

@@ -0,0 +1,70 @@
+# 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/hornetq/address_settings'
+
+module TorqueBox
+  module Messaging
+    module HornetQ
+      extend TorqueBox::Messaging::Helpers
+
+      # Returns the destination controller for the given destination.
+      #
+      # The returned controller depends on the type of the given
+      # destination and, for queues, the requested type:
+      #
+      # ```
+      # destination  type          controller
+      # -------------------------------------------------------------------------
+      # Queue        :jms          org.hornetq.api.jms.management.JMSQueueControl
+      # Queue        :core         org.hornetq.api.core.management.QueueControl
+      # Topic        <ignored>     org.hornetq.api.jms.management.TopicControl
+      # ```
+      #
+      # Refer to the javadocs for those control classes for details on the
+      # available operations.
+      # @param destination [Destination] Should be a {Queue} or
+      #   {Topic}.
+      # @param type [:core, :jms]
+      def self.destination_controller(destination, type = :jms)
+        if destination.instance_of?(Queue) && type == :core
+          prefix = "core.queue."
+        else
+          prefix = ""
+        end
+        server_manager
+          .getHornetQServer
+          .getManagementService
+          .getResource("#{prefix}#{jms_name(destination)}")
+      end
+
+      protected
+
+      def self.jms_name(dest)
+        if dest.respond_to?(:internal_destination)
+          dest.internal_destination.jms_name
+        else
+          dest
+        end
+      end
+
+      def self.server_manager
+        unless default_broker.respond_to?(:jms_server_manager)
+          fail RuntimeError.new("The current broker isn't a HornetQ broker")
+        end
+        default_broker.jms_server_manager
+      end
+    end
+  end
+end

data/lib/torquebox/messaging/hornetq/address_settings.rb

@@ -0,0 +1,228 @@
+# 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 'forwardable'
+
+module TorqueBox
+  module Messaging
+    module HornetQ
+      # Sets the HornetQ-specific address options for the given match.
+      #
+      # This provides programatic access to options that are normally set
+      # in the xml configuration.
+      class AddressSettings
+        include TorqueBox::Messaging::Helpers
+        extend Forwardable
+
+        # Creates and registers address settings.
+        #
+        # Creating a new AddressOptions for a match that you have set
+        # options for already will replace those prior options.
+        #
+        # @param match_or_dest must be either a {Destination} or a fully
+        #   qualified jms destination name (prefixed with 'jms.queue.'
+        #   or 'jms.topic.'). It may contain HornetQ wildcard matchers
+        #   (see
+        #   http://docs.jboss.org/hornetq/2.3.0.Final/docs/user-manual/html/wildcard-syntax.html)
+        def initialize(match_or_dest)
+          server_manager = HornetQ.server_manager
+          import_hornetq
+
+          @address_settings = org.hornetq.core.settings.impl.AddressSettings.new
+          server_manager.add_address_settings(normalize_destination_match(match_or_dest), @address_settings)
+        end
+
+        # Specifies what should happen when an address reaches
+        # max_size_bytes in undelivered messages.
+        #
+        # See
+        # http://docs.jboss.org/hornetq/2.3.0.Final/docs/user-manual/html/paging.html
+        #
+        # The policy can be one of:
+        #
+        # * :block - publish calls will block until the current size
+        #    drops below max_size_bytes
+        # * :drop - new messages are silently dropped
+        # * :fail - new messages are dropped and an exception is thrown on publish
+        # * :page - new messages will be paged to disk
+        #
+        # @param policy [Symbol] (:page) The policy to use.
+        def address_full_message_policy=(policy)
+          policy_const = case policy.to_s
+                         when "block"
+                           AddressFullMessagePolicy::BLOCK
+                         when "drop"
+                           AddressFullMessagePolicy::DROP
+                         when "fail"
+                           AddressFullMessagePolicy::FAIL
+                         when "page"
+                           AddressFullMessagePolicy::PAGE
+                         else
+                           fail ArgumentError.new("#{policy} isn't a valid full message policy")
+                         end
+          @address_settings.address_full_message_policy = policy_const
+        end
+
+        # If set, any messages that fail to deliver to their original
+        # destination will be delivered here. See
+        # http://docs.jboss.org/hornetq/2.3.0.Final/docs/user-manual/html/undelivered-messages.html#undelivered-messages.configuring
+        #
+        # @param address ('jms.queue.DLQ') The address to use. It can
+        #   either be a {Destination} object or a fully-qualified
+        #   destination name.
+        def dead_letter_address=(address)
+          @address_settings.dead_letter_address = SimpleString.new(HornetQ.jms_name(address))
+        end
+
+        # If set, any messages with a :ttl that expires before
+        # delivery will be delivered here. See
+        # http://docs.jboss.org/hornetq/2.3.0.Final/docs/user-manual/html/message-expiry.html#message-expiry.configuring
+        #
+        # @param address ('jms.queue.ExpiryQueue') The address to use. It can
+        #   either be a {Destination} object or a fully-qualified
+        #   destination name.
+        def expiry_address=(address)
+          @address_settings.expiry_address = SimpleString.new(HornetQ.jms_name(address))
+        end
+
+        # If true, only the most recent message
+        # for a last-value property will be retained.
+        #
+        # Setting this option will also cause
+        # {#address_full_message_policy=} to be set to :drop, as HornetQ
+        # has a bug related to paging last value queues. See
+        # http://docs.jboss.org/hornetq/2.3.0.Final/docs/user-manual/html/last-value-queues.html
+        #
+        # @param val [true,false] (false)
+        def last_value_queue=(val)
+          @address_settings.last_value_queue = val
+          self.address_full_message_policy = :drop
+        end
+
+        # @!method send_to_dla_on_no_route=(val)
+        #
+        # If true, any message that can't be routed to its destination
+        # will be sent to the {#dead_letter_address=}.
+        #
+        # @param val [true,false] (false)
+        def_delegator(:@address_settings, :setSendToDLAOnNoRoute, :send_to_dla_on_no_route=)
+
+        # @!method expiry_delay=(delay)
+        #
+        # If > -1, this value (in millis) is used as the
+        # default :ttl for messages that don't have a :ttl > 0 set.
+        #
+        # @param delay [Number] (-1) The delay.
+        def_delegators(:@address_settings, :expiry_delay=)
+
+        # @!method max_delivery_attempts=(attempts)
+        #
+        # The number of times delivery will be attempted for a message
+        # before giving up.
+
+        # If {#dead_letter_address=} is set, the message will be
+        # delivered there, or removed otherwise. See
+        # http://docs.jboss.org/hornetq/2.3.0.Final/docs/user-manual/html/undelivered-messages.html#undelivered-messages.configuring
+        #
+        # @param attempts [Number] (10)
+        def_delegators(:@address_settings, :max_delivery_attempts=)
+
+        # @!method max_redelivery_delay=(delay)
+        #
+        # Specifies the maximum redelivery delay (in millis) when a
+        # {#redelivery_multiplier=} is used.
+        #
+        # @param delay [Number] (same as {#redelivery_delay=})
+        def_delegators(:@address_settings, :max_redelivery_delay=)
+
+        # @!method max_size_bytes=(bytes)
+        #
+        # The maximum size (in bytes) of retained messages
+        # on an address before {#address_full_message_policy=} is applied. See
+        # http://docs.jboss.org/hornetq/2.3.0.Final/docs/user-manual/html/paging.html
+        #
+        # @param bytes [Number] (20_971_520 (20MB))
+        def_delegators(:@address_settings, :max_size_bytes=)
+
+        # @!method page_cache_max_size=(size)
+        #
+        # HornetQ will keep up to this many page files in memory to
+        # optimize IO. See
+        # http://docs.jboss.org/hornetq/2.3.0.Final/docs/user-manual/html/paging.html
+        #
+        # @param size [Number] (5)
+        def_delegators(:@address_settings, :page_cache_max_size=)
+
+        # @!method page_size_bytes=(bytes)
+        #
+        # The size (in bytes) of the page files created when
+        # paging. See
+        # http://docs.jboss.org/hornetq/2.3.0.Final/docs/user-manual/html/paging.html
+        #
+        # @param bytes [Number] (10_485_760 (10MB))
+        def_delegators(:@address_settings, :page_size_bytes=)
+
+        # @!method redelivery_delay=(delay)
+        #
+        # Specifies the delay (in millis) between redelivery
+        # attempts. See
+        # http://docs.jboss.org/hornetq/2.3.0.Final/docs/user-manual/html/undelivered-messages.html#undelivered-messages.delay
+        #
+        # @param delay [Number] (0)
+        def_delegators(:@address_settings, :redelivery_delay=)
+
+        # @!method redelivery_multiplier=(multiplier)
+        #
+        # Controls the backoff for redeliveries. The
+        # delay between redelivery attempts is calculated as
+        # {#redelivery_delay=} * ({#redelivery_multiplier=} ^ attempt_count). This won't have
+        # any effect if you don't also set {#redelivery_delay=} and {#max_redelivery_delay=}.
+        #
+        # @param multiplier [Float] (1.0)
+        def_delegators(:@address_settings, :redelivery_multiplier=)
+
+        # @!method redistribution_delay=(delay)
+        #
+        # Specifies the delay (in millis) to wait before
+        # redistributing messages from a node in a cluster to other
+        # nodes when the queue no longer has consumers on the current
+        # node. See
+        # http://docs.jboss.org/hornetq/2.3.0.Final/docs/user-manual/html/clusters.html
+        #
+        # @param delay [Number] (1_000)
+        def_delegators(:@address_settings, :redistribution_delay=)
+
+        protected
+
+        def normalize_destination_match(match_or_dest)
+          if (match = HornetQ.jms_name(match_or_dest)) != match_or_dest
+            match
+          elsif match_or_dest == "#" ||
+              /^jms\.(queue|topic)\./ =~ match_or_dest
+            match_or_dest
+          else
+            error_message = "#{match_or_dest} isn't a valid match. See the "\
+                            "docs for TorqueBox::Messaging::HornetQ::AddressOptions"
+            fail ArgumentError.new(error_message)
+          end
+        end
+
+        def import_hornetq
+          java_import org.hornetq.core.settings.impl.AddressFullMessagePolicy
+          java_import org.hornetq.api.core.SimpleString
+        end
+      end
+    end
+  end
+end

data/lib/torquebox/messaging/queue.rb

@@ -1,311 +1,149 @@
-# 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/destination'
-require 'torquebox/service_registry'
+# 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.
+
+java_import java.util.concurrent.TimeUnit
+java_import org.projectodd.wunderboss.messaging.ConcreteReply
 
 module TorqueBox
   module Messaging
+    # Represents a messaging queue.
+    #
+    # Obtain a queue object by calling {TorqueBox::Messaging.queue}.
     class Queue < Destination
 
-      class << self
-
-        # Creates the queue, starts and return a Queue object.
-        #
-        # @param name The name of the queue
-        # @param options Optional parameters (a Hash), including:
-        # @option options [String] :selector The selector for the queue
-        # @option options [Boolean] :durable If the queue should be durable
-        # @option options [Boolean] :exported If the queue should be visible in remote JNDI lookups
-        # @return [Queue] if the service is created and started
-        # @return [nil] if the service is not created in the specified time (30 s)
-        def start(name, options={})
-          selector = options.fetch(:selector, "")
-          durable = options.fetch(:durable, true)
-          exported = options.fetch(:exported, false)
-
-          with_destinationizer do |destinationizer|
-            destinationizer.create_queue(name, durable, selector, exported)
-          end
-
-          new(name, options)
-        end
-      end
-
-      # Publishes a message and waits for the reply
-      #
-      # @param message The message to publish
-      # @param options Optional parameters (a Hash)
-      # @return Replied message
-      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
-
-      # Waits for a message and replies
-      #
-      # @param options Optional parameters (a Hash)
-      # @param block The block to handle the received message. The return value of the block will be send back to the queue.
-      # @return [void]
-      def receive_and_publish(options={}, &block)
-        with_session do |session|
-          session.receive_and_publish(self, normalize_options(options), &block)
-        end
-      end
-
-      # Returns true if queue is paused, false
-      # otherwise.
-      def paused?
-        with_queue_control do |control|
-          control.is_paused
-        end
-      end
-
-      # Pauses a queue.
-      #
-      # Messages put into a queue will not be delivered even
-      # if there are connected consumers.
-      #
-      # When executed on a paused queue, nothing happens.
-      #
-      # @return [void]
-      def pause
-        with_queue_control do |control|
-          control.pause
-        end
-      end
-
-      # Resumes a queue after it was paused.
-      # When executed on a active queue, nothing happens.
-      #
-      # @return [void]
-      def resume
-        with_queue_control do |control|
-          control.resume
-        end
-      end
-
-      # Removes messages from the queue.
-      #
-      # @param filter [String] Expression in a SQL92-like syntax based on properties set on the messages. If not set all messages will be removed.
-      #
-      # @example Remove messages with type property set
-      #
-      #   @queue.remove_messages("type = 'tomatoe' OR type = 'garlic'")
-      #
-      # @return [Integer] Number of removed messages
-      def remove_messages(filter = nil)
-        with_queue_control do |control|
-          control.remove_messages(filter)
-        end
-      end
-
-      # Removes message from the queue by its id.
-      #
-      # @param id [String] ID of the message
-      # @return [Boolean] true if the message was removed, false otherwise.
-      def remove_message(id)
-        with_queue_control do |control|
-          control.remove_message(id)
-        end
-      end
-
-      # Counts messages in the queue.
-      #
-      # @param filter [String] Expression in a SQL92-like syntax based on properties set on the messages. If not set all messages will be counted.
-      #
-      # @example Count messages with :type property set to 'tomatoe' or 'garlic'
-      #
-      #   @queue.count_messages("type = 'tomatoe' OR type = 'garlic'")
-      #
-      # @return [Fixnum] The number of counted messages
-      def count_messages(filter = nil)
-        with_queue_control do |control|
-          control.count_messages(filter)
-        end
-      end
-
-      # Expires messages from the queue.
-      #
-      # @param filter [String] Expression in a SQL92-like syntax based on properties set on the messages. If not set all messages will be expired.
-      #
-      # @return [Fixnum] The number of expired messages
-      def expire_messages(filter = nil)
-        with_queue_control do |control|
-          control.expire_messages(filter)
-        end
-      end
-
-      # Expires message from the queue by its id.
-      #
-      # @return [Boolean] Returns true if the message was expired, false otherwise.
-      def expire_message(id)
-        with_queue_control do |control|
-          control.expire_message(id)
-        end
-      end
-
-      # Sends message to dead letter address.
-      #
-      # @return [Boolean] Returns true if the message was sent, false otherwise.
-      def send_message_to_dead_letter_address(id)
-        with_queue_control do |control|
-          control.send_message_to_dead_letter_address(id)
-        end
-      end
-
-      # Sends messages to dead letter address.
-      #
-      # @param filter [String] Expression in a SQL92-like syntax based on properties set on the messages. If not set all messages will be send.
-      #
-      # @return [Fixnum] The number of sent messages
-      def send_messages_to_dead_letter_address(filter = nil)
-        with_queue_control do |control|
-          control.send_messages_to_dead_letter_address(filter)
-        end
-      end
-
-      # Returns the consumer count connected to the queue.
-      #
-      # @return [Fixnum] The number of consumers
-      def consumer_count
-        with_queue_control do |control|
-          control.consumer_count
-        end
-      end
-
-      # Returns the scheduled messages count for this queue.
-      #
-      # @return [Fixnum] The number of scheduled messages
-      def scheduled_messages_count
-        with_queue_control do |control|
-          control.scheduled_count
-        end
-      end
-
-      # Moves messages from the queue to another queue specified in the
-      # +queue_name+ parameter. Optional +reject_duplicates+ parameter
-      # specifies if the duplicates should be rejected.
-      #
-      # @param queue_name [String] The name of the queue to move the messages to
-      # @param filter [String] Parameter to limit messages to move. If provided nil or empty string, *all messages* will be moved.
-      # @param reject_duplicates [Boolean] Specifies if the duplicates should be rejected
-      # @return [Fixnum] The number of moved messages
-      def move_messages(queue_name, filter = nil, reject_duplicates = false)
-        with_queue_control do |control|
-          control.move_messages(filter, queue_name, reject_duplicates)
-        end
-      end
-
-      # Moves message for specific id from the queue to another queue
-      # specified in the queue_name parameter.
-      #
-      # @param queue_name [String] The name of the queue to move the messages to
-      # @param id [String] Message ID
-      # @param reject_duplicates [Boolean] Specifies if the duplicates should be rejected
-      # @return [Boolean] true if the message was moved,false otherwise
-      def move_message(queue_name, id, reject_duplicates = false)
-        with_queue_control do |control|
-          control.move_message(id, queue_name, reject_duplicates)
-        end
-      end
-
-      # Returns current expiry address.
-      #
-      # @return [String] Current expiry address. Please note that the destination contains 'jms.queue' or 'jms.topic' prefixes.
-      def expiry_address
-        with_queue_control do |control|
-          control.expiry_address
-        end
-      end
-
-      # Sets the expiry address.
-      #
-      # Please note that you need to provide the
-      # *full address* containing the destination name and
-      # jms.queue or jms.topic prefixes, for example:
-      #
-      # @example Set the destination to /queues/customexpire
-      #
-      #   @queue.expiry_address = "jms.queue./queues./customexpire"
-      #
-      # @example Set the destination to /topics/customexpire
-      #
-      #   @queue.expiry_address = "jms.topic./topics./customexpire"
-      #
-      # @return [String] Current expiry address
-      def expiry_address=(address)
-        with_queue_control do |control|
-          control.set_expiry_address(address)
-        end
-
-        expiry_address
-      end
-
-      # Returns current dead letter address.
-      #
-      # @return [String] Current dead letter address. Please note that the destination contains 'jms.queue' or 'jms.topic' prefixes,
-      def dead_letter_address
-        with_queue_control do |control|
-          control.dead_letter_address
-        end
-      end
-
-      # Sets the dead letter address.
-      #
-      # Please note that you need to provide the
-      # *full address* containing the destination name and
-      # +jms.queue+ or +jms.topic+ prefixes, for example:
-      #
-      # @example Set the destination to /queues/customdead
-      #
-      #   @queue.dead_letter_address = "jms.queue./queues./customdead"
-      #
-      # @example Set the destination to /topics/customdead
-      #
-      #   @queue.dead_letter_address = "jms.topic./topics./customdead"
-      #
-      # @return [String] Current dead letter address
-      def dead_letter_address=(address)
-        with_queue_control do |control|
-          control.set_dead_letter_address(address)
-        end
-
-        dead_letter_address
-      end
-
-
-      def to_s
-        "[Queue: #{super}]"
+      # Valid options for Queue creation.
+      QUEUE_OPTIONS = optset(WBMessaging::CreateQueueOption, :default_options)
+
+      # Valid options for {#request}.
+      REQUEST_OPTIONS = optset(PUBLISH_OPTIONS, :timeout, :timeout_val)
+
+      # Sends a message this queue and waits for a response.
+      #
+      # Implements the request-response pattern, and is used in
+      # conjunction with {#respond}.
+      #
+      # Can optionally be given block that will be called with
+      # the message.
+      #
+      # 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, :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
+      # @option options :timeout [Number] (0) Time in millis,
+      #   after which the :timeout_val is returned. 0
+      #   means wait forever.
+      # @option options :timeout_val [Object] The value to
+      #   return when a timeout occurs.
+      # @return The message, or the return value of the block if a
+      #   block is given.
+      def request(message, options = {}, &block)
+        validate_options(options, REQUEST_OPTIONS)
+        options = apply_default_options(options)
+        options = coerce_context(options)
+        options = normalize_publish_options(options)
+        encoding = options[:encoding] || Messaging.default_encoding
+        future = @internal_destination.request(message,
+                                               Codecs[encoding],
+                                               Codecs.java_codecs,
+                                               extract_options(options, WBQueue::RequestOption))
+        timeout = options[:timeout] || 0
+        result = if timeout == 0
+                   future.get
+                 else
+                   begin
+                     future.get(timeout, TimeUnit::MILLISECONDS)
+                   rescue java.util.concurrent.TimeoutException
+                     nil
+                   end
+                 end
+        msg = if result
+                result.body
+              else
+                options[:timeout_val]
+              end
+        if block
+          block.call(msg)
+        else
+          msg
+        end
+      end
+
+      # Valid options for {#respond}
+      RESPOND_OPTIONS = optset(WBQueue::RespondOption, :decode)
+
+      # Registers a block to receive each request message sent to this
+      # destination, and returns the result of the block call to the
+      # requestor.
+      #
+      # 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 when the responder is 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 :ttl [Number] (60000) The time for the
+      #   response message to live, in millis.
+      # @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 respond(options = {}, &block)
+        validate_options(options, RESPOND_OPTIONS)
+        options = apply_default_options(options)
+        options = coerce_context(options)
+        handler = MessageHandler.new do |message|
+          ConcreteReply.new(block.call(options.fetch(:decode, true) ? message.body : message),
+                            nil)
+        end
+        @internal_destination.respond(handler,
+                                      Codecs.java_codecs,
+                                      extract_options(options, WBQueue::RespondOption))
+      end
+
+      protected
+
+      def initialize(name, options = {})
+        validate_options(options, QUEUE_OPTIONS)
+        coerced_opts = coerce_context(options)
+        create_options = extract_options(coerced_opts, WBMessaging::CreateQueueOption)
+        super(default_broker.find_or_create_queue(name, create_options),
+              options)
       end
 
-      # @api private
-      #
-      # Retrieves the JMSQueueControl implementation for current
-      # queue.
-      def with_queue_control
-        TorqueBox::ServiceRegistry.lookup("jboss.messaging.default") do |server|
-          yield server.management_service.get_resource("jms.queue.#{@name}")
-        end
-      end
     end
   end
 end