jruby-hornetq 0.3.3 → 0.4.0

data/HISTORY.md

@@ -1,3 +1,8 @@
+## 0.4.0 (2011-04-01)
+
+* Upgrade to HornetQ 2.2.2
+* Migrate to new HornetQClient factory API's
+
 ## 0.3.0 (2011-02-16)
 
 * Rename HornetQ::Client::Factory to HornetQ::Client::Connection

data/README.md

@@ -3,17 +3,11 @@ jruby-hornetq
 
 * http://github.com/ClarityServices/jruby-hornetq
 
-### WARNING: Alpha code!!
-
-This code should only be used for prototyping at this time, since breaking
-changes are made between every release. Once the code goes to V1.0.0 we will
-make every effort to not break the existing interface in any way.
-
 Feedback is welcome and appreciated :)
 
 ### Introduction
 
-jruby-hornetq attempts to "rubify" the HornetQ Java libraries without 
+jruby-hornetq create a Ruby friendly API into the HornetQ Java libraries without 
 compromising performance. It does this by sprinkling "Ruby-goodness" into the
 existing HornetQ Java classes and interfaces, I.e. By adding Ruby methods to
 the existing classes and interfaces. Since jruby-hornetq exposes the HornetQ
@@ -36,15 +30,14 @@ several reasons for choosing the HornetQ Core API over its JMS API:
 * The HornetQ team recommend the Core API for performance
 * The HornetQ JMS API is just another wrapper on top of its Core API
 
-To use the JMS API, see the jruby-jms project. (Not yet released into the wild,
-let me know if you want it :) )
+To use the JMS API from JRuby see the jruby-jms project
 
 HornetQ
 -------
 
-For information on the HornetQ messaging and queuing system, see:
+For information on the HornetQ messaging and queuing system, see: http://www.jboss.org/hornetq
 
-For more documentation on any of the classes, see: http://hornetq.sourceforge.net/docs/hornetq-2.1.0.Final/api/index.html?org/hornetq/api/core/client/package-summary.html
+For more documentation on any of the classes, see: http://docs.jboss.org/hornetq/2.2.2.Final/api/index.html
 
 Concepts & Terminology
 ----------------------

data/Rakefile

@@ -9,7 +9,7 @@ desc "Build gem"
 task :gem  do |t|
   gemspec = Gem::Specification.new do |s|
     s.name = 'jruby-hornetq'
-    s.version = '0.3.3'
+    s.version = '0.4.0'
     s.authors = ['Reid Morrison', 'Brad Pardee']
     s.email = ['rubywmq@gmail.com', 'bpardee@gmail.com']
     s.homepage = 'https://github.com/ClarityServices/jruby-hornetq'

data/examples/producer-consumer/browse_all.rb

@@ -0,0 +1,25 @@
+#
+# HornetQ Consumer:
+#          Read a single message from the queue
+#
+
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+
+require 'rubygems'
+require 'hornetq'
+
+# Using Connect.start since a session must be started in order to consume messages
+HornetQ::Client::Connection.start_session('hornetq://localhost') do |session|
+
+  # Create a non-durable TestQueue to receive messages sent to the TestAddress
+  session.create_queue_ignore_exists('TestAddress', 'TestQueue', false)
+
+  # Consume All messages from the queue and gather statistics
+  stats = session.consume(:queue_name => 'TestQueue', :timeout=> 0, :statistics=>true, :browse_only=>true) do |message|
+    p message
+    puts "=================================="
+    message.acknowledge
+  end
+  puts "Browsed #{stats[:count]} messages in #{stats[:duration]} seconds at #{stats[:messages_per_second]} messages per second"
+end

data/examples/producer-consumer/consume_all.rb

@@ -21,5 +21,5 @@ HornetQ::Client::Connection.start_session('hornetq://localhost') do |session|
     puts "=================================="
     message.acknowledge
   end
-  puts "Received #{stats[:count]} messages in #{stats[:duration]} seconds at #{stats[:messages_per_second]} messages per second"
+  puts "Consumed #{stats[:count]} messages in #{stats[:duration]} seconds at #{stats[:messages_per_second]} messages per second"
 end

data/lib/hornetq.rb

@@ -25,6 +25,11 @@ module HornetQ
     return java.lang.Integer.new(port)
   end
 
+  # Convert string into a HornetQ SimpleString
+  def self.as_simple_string(str)
+   str.is_a?(Java::org.hornetq.api.core::SimpleString) ? str : Java::org.hornetq.api.core::SimpleString.new(str.to_s) 
+  end
+  
 end
 
 require 'hornetq/server'

data/lib/hornetq/client/connection.rb

@@ -34,7 +34,7 @@ module HornetQ
       #  block. Upon completion the session and connection are both closed
       # See Connection::initialize and Connection::create_session for the list
       #  of parameters
-      #  
+      #
       # Returns result of block
       def self.start_session(params={},&proc)
         session(params) do |session|
@@ -63,50 +63,8 @@ module HornetQ
 
       # Create a new Connection from which sessions can be created
       #
-      # Parameters:
-      # * a Hash consisting of one or more of the named parameters
-      # * Summary of parameters and their default values
-      #  HornetQ::Client::Connection.new(
-      #    :uri                            => 'hornetq://localhost',
-      #    :ack_batch_size                 => ,
-      #    :auto_group                     => ,
-      #    :block_on_acknowledge           => ,
-      #    :block_on_durable_send          => ,
-      #    :block_on_non_durable_send      => ,
-      #    :cache_large_messages_client    => ,
-      #    :call_timeout                   => ,
-      #    :client_failure_check_period    => ,
-      #    :confirmation_window_size       => ,
-      #    :connection_load_balancing_policy_class_name => ,
-      #    :connection_ttl                 => ,
-      #    :consumer_max_rate              => ,
-      #    :consumer_window_size           => ,
-      #    :discovery_address              => ,
-      #    :discovery_initial_wait_timeout => ,
-      #    :discovery_port                 => ,
-      #    :discovery_refresh_timeout      => ,
-      #    :failover_on_initial_connection => true,
-      #    :failover_on_server_shutdown    => true,
-      #    :group_id                       => ,
-      #    :initial_message_packet_size    => ,
-      #    :java_object                    => ,
-      #    :local_bind_address             => ,
-      #    :max_retry_interval             => ,
-      #    :min_large_message_size         => ,
-      #    :pre_acknowledge                => ,
-      #    :producer_max_rate              => ,
-      #    :producer_window_size           => ,
-      #    :reconnect_attempts             => 1,
-      #    :retry_interval                 => ,
-      #    :retry_interval_multiplier      => ,
-      #    :scheduled_thread_pool_max_size => ,
-      #    :static_connectors              => ,
-      #    :thread_pool_max_size           => ,
-      #    :use_global_pools               =>
-      #  )
-      #
       # Mandatory Parameters
-      # * :uri
+      # * :uri                             => 'hornetq://localhost',
       #   * The hornetq uri as to which server to connect with and which
       #     transport protocol to use. Format:
       #       hornetq://server:port,backupserver:port/?protocol=[netty|discover]
@@ -118,44 +76,204 @@ module HornetQ
       #       hornetq://server:port/?protocol=discovery
       #   * To use HornetQ within the current JVM
       #       hornetq://invm
-      #
       # Optional Parameters
-      # * :ack_batch_size
-      # * :auto_group
-      # * :block_on_acknowledge
-      # * :block_on_durable_send
-      # * :block_on_non_durable_send
-      # * :cache_large_messages_client
-      # * :call_timeout
-      # * :client_failure_check_period
-      # * :confirmation_window_size
-      # * :connection_load_balancing_policy_class_name
-      # * :connection_ttl
-      # * :consumer_max_rate
-      # * :consumer_window_size
-      # * :discovery_address
-      # * :discovery_initial_wait_timeout
-      # * :discovery_port
-      # * :discovery_refresh_timeout
-      # * :failover_on_initial_connection
-      # * :failover_on_server_shutdown
-      # * :group_id
-      # * :initial_message_packet_size
-      # * :java_object
-      # * :local_bind_address
-      # * :max_retry_interval
-      # * :min_large_message_size
-      # * :pre_acknowledge
-      # * :producer_max_rate
-      # * :producer_window_size
-      # * :reconnect_attempts
-      # * :retry_interval
-      # * :retry_interval_multiplier
-      # * :scheduled_thread_pool_max_size
-      # * :static_connectors
-      # * :thread_pool_max_size
-      # * :use_global_pools
-
+      # 
+      #   High Availability
+      # 
+      # *  :ha                             => true | false,
+      #      true:  Receives cluster topology updates from the cluster as
+      #             servers leave or join and new backups are appointed or removed.
+      #      false: Uses the suplied static list of hosts in :uri
+      #             and no HA backup information is propagated to the client
+      #      Default: false
+      #        
+      #   Flow Control
+      #   
+      #    :ack_batch_size                 => integer,
+      #      Sets the acknowledgements batch size. Must be > 0
+      #         
+      #    :pre_acknowledge                => true | false,
+      #      Sets whether messages will pre-acknowledged on the server before 
+      #      they are sent to the consumers or not
+      #        true : Pre-acknowledge consumed messages on the server before they are sent to consumers
+      #        false: Clients acknowledge the message they consume. 
+      #      Default: false
+      #    
+      #   Grouping:
+      #   
+      #    :auto_group                     => true | false,
+      #      Sets whether producers will automatically assign a group ID 
+      #      to sent messages
+      #        true: A random unique group ID is created and set on each message 
+      #              for the property Message.HDR_GROUP_ID
+      #      Default: false
+      #      
+      #    :group_id                       => string,
+      #      Sets the group ID that will be set on each message sent
+      #      Default: nil (no goup id will be set)
+      #    
+      #   Blocking calls:
+      #   
+      #    :block_on_acknowledge           => true | false,
+      #      Sets whether consumers created through this factory will block 
+      #      while sending message acknowledgements or do it asynchronously. 
+      #      Default: false
+      #      
+      #    :block_on_durable_send          => true | false,
+      #      Sets whether producers will block while sending durable messages 
+      #      or do it asynchronously.
+      #      If the session is configured to send durable message asynchronously, 
+      #      the client can set a SendAcknowledgementHandler on the ClientSession 
+      #      to be notified once the message has been handled by the server. 
+      #      Default: true
+      #    
+      #    :block_on_non_durable_send      => true | false,
+      #      Sets whether producers will block while sending non-durable messages 
+      #      or do it asynchronously.
+      #      If the session is configured to send non-durable message asynchronously, 
+      #      the client can set a SendAcknowledgementHandler on the ClientSession 
+      #      to be notified once the message has been handled by the server. 
+      #      Default: false
+      #      
+      #    :call_timeout                   => long,
+      #      Sets the blocking calls timeout in milliseconds. If client's blocking calls to the 
+      #      server take more than this timeout, the call will throw a 
+      #      HornetQException with the code HornetQException.CONNECTION_TIMEDOUT. 
+      #      Value is in milliseconds, default value is HornetQClient.DEFAULT_CALL_TIMEOUT. 
+      #      Must be >= 0
+      #      
+      #   Client Reconnection Parameters:
+      #   
+      #    :connection_ttl                 => long,
+      #      Set the connection time-to-live 
+      #      -1  : Disable
+      #      >=0 : milliseconds the server will keep a connection alive in the 
+      #            absence of any data arriving from the client. 
+      #      Default: 60,000
+      #    
+      #    :client_failure_check_period    => long,
+      #      Sets the period in milliseconds used to check if a client has 
+      #      failed to receive pings from the server. 
+      #      Value must be -1 (to disable) or greater than 0
+      #      Default: 30,000
+      #      
+      #    :initial_connect_attempts       => int,
+      #      ?
+      #      
+      #    :failover_on_initial_connection => true | false,
+      #      Sets whether the client will automatically attempt to connect to 
+      #      the backup server if the initial connection to the live server fails
+      #        true : If live server is not reachable try to connect to backup server
+      #        false: Fail to start if live server is not reachable
+      #      Default: false
+      #      
+      #    :max_retry_interval             => long,
+      #      Sets the maximum retry interval in milliseconds.
+      #      Only appicable if the retry interval multiplier has been specified
+      #      Default: 2000 (2 seconds)
+      #      
+      #    :reconnect_attempts             => 1,
+      #    :retry_interval                 => long,
+      #      Returns the time to retry the connection after failure. 
+      #      Value is in milliseconds.
+      #      Default: 2000 (2 seconds)
+      #    
+      #    :retry_interval_multiplier      => double,
+      #      Sets the multiplier to apply to successive retry intervals. 
+      #      Value must be positive. 
+      #      Default: 1
+      #      
+      #   Large Message parameters:
+      #   
+      #    :cache_large_messages_client    => true | false,
+      #      Sets whether large messages received by consumers will be  
+      #      cached in temporary files or not. 
+      #      When true, consumers will create temporary files to cache large messages. 
+      #      There is 1 temporary file created for each large message. 
+      #      Default: false
+      #    
+      #    :min_large_message_size         => int,
+      #      Sets the large message size threshold in bytes. Value must be > 0
+      #      Messages whose size is if greater than this value will be handled as large messages
+      #      Default: 102400 bytes  (100 KBytes)
+      #      
+      #    :compress_large_message         => true | false,
+      #      
+      #   Message Rate Management:
+      #   
+      #    :consumer_max_rate              => int,
+      #      Sets the maximum rate of message consumption for consumers.
+      #      Controls the rate at which a consumer can consume messages.
+      #      A consumer will never consume messages at a rate faster than the
+      #      rate specified. 
+      #        -1 : Disable
+      #       >=0 : Maximum desired message consumption rate specified 
+      #             in units of messages per second. 
+      #      Default: -1
+      #      
+      #    :producer_max_rate              => int,
+      #      Sets the maximum rate of message production for producers. 
+      #      Controls the rate at which a producer can produce messages.
+      #      A producer will never produce messages at a rate faster than the rate specified.
+      #        -1 : Disabled
+      #        >0 : Maximum desired message production rate specified in units of messages per second.
+      #      Default: -1 (Disabled)
+      #      
+      #   Thread Pools:
+      #   
+      #    :scheduled_thread_pool_max_size => int,
+      #      Sets the maximum size of the scheduled thread pool. 
+      #      This setting is relevant only if this factory does not use global pools. 
+      #      Value must be greater than 0. 
+      #      Default: 5
+      #      
+      #    :thread_pool_max_size           => int,
+      #      Sets the maximum size of the thread pool. 
+      #      This setting is relevant only if this factory does not use 
+      #      global pools. 
+      #        -1 : Unlimited thread pool
+      #        >0 : Number of threads in pool
+      #      Default: -1 (Unlimited)
+      #    
+      #    :use_global_pools               => true | false,
+      #      Sets whether this factory will use global thread pools 
+      #      (shared among all the factories in the same JVM) or its own pools.
+      #        true: Uses global JVM thread pools across all HornetQ connections
+      #        false: Use a thread pool just for this connection
+      #      Default: true
+      #  
+      #   Window Sizes:
+      #   
+      #    :confirmation_window_size       => int,
+      #      Set the size in bytes for the confirmation window of this connection. 
+      #        -1 : Disable the window
+      #        >0 : Size in bytes
+      #      Default: -1 (Disabled)
+      #      
+      #    :consumer_window_size           => int,
+      #      Sets the window size for flow control for consumers.
+      #       -1 : Disable flow control
+      #        0 : Do Not buffer any messages
+      #       >0 : Set the maximum size of the buffer
+      #      Default: 1048576 (1 MB)
+      #      
+      #    :producer_window_size           => int,
+      #      Sets the window size for flow control of the producers. 
+      #      -1 : Disable flow control
+      #      >0 : The maximum amount of bytes at any give time (to prevent overloading the connection). 
+      #      Default: 65536 (64 KBytes)
+      #      
+      #  Other:
+      #  
+      #    :connection_load_balancing_policy_class_name => string,
+      #      Set the class name of the connection load balancing policy
+      #      Value must be the name of a class implementing org.hornetq.api.core.client.loadbalance.ConnectionLoadBalancingPolicy
+      #      Default: "org.hornetq.api.core.client.loadbalance.RoundRobinConnectionLoadBalancingPolicy"
+      #      
+      #    :initial_message_packet_size    => int,
+      #      Sets the initial size of messages in bytes
+      #      Value must be greater than 0
+      #      
       def initialize(params={})
         params =params.clone
         uri = nil
@@ -170,50 +288,55 @@ module HornetQ
           params = uri.params.merge(params)
         end
 
-        @connection = nil
-        @sessions = []
-        @consumers = []
         # In-VM Transport has no fail-over or additional parameters
         @is_invm = uri.host == 'invm'
+        transport_list = []
         if @is_invm
-          transport = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::INVM_CONNECTOR_CLASS_NAME)
-          @connection = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport)
-        elsif params[:protocol]
-          # Auto-Discovery just has a host name and port
-          if params[:protocol] == 'discovery'
-            @connection = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(uri.host, uri.port)
-          elsif params[:protocol] != 'netty'
-            raise "Unknown HornetQ protocol:#{params[:protocol]}"
-          end
-        end
-
-        # Unless already created, then the connection will use the netty protocol
-        unless @connection
-          # Primary Transport
-          transport = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::NETTY_CONNECTOR_CLASS_NAME, {'host' => uri.host, 'port' => uri.port })
+          transport_list << Java::org.hornetq.api.core::TransportConfiguration.new(HornetQ::INVM_CONNECTOR_CLASS_NAME)
+        else
+          case params[:protocol]
+          when 'discovery'
+            #TODO: Also support: DiscoveryGroupConfiguration(String name, String localBindAddress, String groupAddress, int groupPort, long refreshTimeout, long discoveryInitialWaitTimeout)
+            transport_list << Java::org.hornetq.api.core::DiscoveryGroupConfiguration.new(uri.host, uri.port)
+          when 'netty', nil
+            transport_list << Java::org.hornetq.api.core::TransportConfiguration.new(HornetQ::NETTY_CONNECTOR_CLASS_NAME, {'host' => uri.host, 'port' => uri.port })
 
-          # Check for backup server connection information
-          if uri.backup_host
-            backup_transport = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::NETTY_CONNECTOR_CLASS_NAME, {'host' => uri.backup_host, 'port' => uri.backup_port })
-            @connection = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport, backup_transport)
+            if uri.backup_host
+              transport_list << Java::org.hornetq.api.core::TransportConfiguration.new(HornetQ::NETTY_CONNECTOR_CLASS_NAME, {'host' => uri.backup_host, 'port' => uri.backup_port })
+            end
           else
-            @connection = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport)
+            raise "Unknown HornetQ protocol:'#{params[:protocol]}'"
           end
         end
 
-        # If any other options were supplied, apply them to the created Connection instance
+        #TODO: Support: server_locator.addInterceptor
+          
+        # Create server locator with or without HA. Without HA being the default
+        @server_locator = if params[:ha]
+          Java::org.hornetq.api.core.client::HornetQClient.createServerLocatorWithHA(*transport_list)
+          #TODO: Support: server_locator.addClusterTopologyListener
+        else
+          Java::org.hornetq.api.core.client::HornetQClient.createServerLocatorWithoutHA(*transport_list)
+        end
+
+        # If any other options were supplied, apply them to the server locator
         params.each_pair do |key, val|
           method = key.to_s+'='
-          if @connection.respond_to? method
-            @connection.send method, val
-            #puts "Debug: #{key} = #{@connection.send key}" if @connection.respond_to? key.to_sym
+          if @server_locator.respond_to? method
+            @server_locator.send method, val
+            HornetQ.logger.trace { "HornetQ ServerLocator setting: #{key} = #{@connection.send key}" } if @server_locator.respond_to? key.to_sym
           else
-            HornetQ.logger.warn "Warning: Option:#{key}, with value:#{val} is invalid and being ignored"
+            HornetQ.logger.warn "Warning: Option:#{key}, with value:#{val} is invalid and will be ignored"
           end
         end
+
+        @connection = @server_locator.createSessionFactory
+        # For handling managed sessions and consumers
+        @sessions = []
+        @consumers = []
       end
 
-      # Return true if this connection was configured in INVM transport protocol
+      # Return true if this connection was configured to use INVM transport protocol
       def invm?
         @is_invm
       end
@@ -370,9 +493,9 @@ module HornetQ
         end
       end
 
-      # Create a session, start the session, call the supplied block 
+      # Create a session, start the session, call the supplied block
       # and once the block completes close the session.
-      # 
+      #
       # See: #session_create for the Parameters
       #
       # Returns the result of the block
@@ -417,7 +540,9 @@ module HornetQ
       def close
         @sessions.each { |session| session.close }
         @connection.close if @connection
+        @server_locator.close if @server_locator
         @connection = nil
+        @server_locator = nil
       end
 
       # Receive messages in a separate thread when they arrive
@@ -490,12 +615,12 @@ module HornetQ
       def on_message_statistics
         @consumers.collect{|consumer| consumer.on_message_statistics}
       end
-      
+
       # Start all sessions managed by this connection
-      # 
+      #
       # Sessions created via #create_session are not managed unless
       # :managed => true was specified when the session was created
-      # 
+      #
       # Session are Only managed when created through the following methods:
       #   Connection#on_message
       #   Connection#create_session And :managed => true
@@ -513,5 +638,5 @@ module HornetQ
         @sessions.each {|session| session.stop}
       end
     end
-  end  
+  end
 end

data/lib/hornetq/client/org_hornetq_api_core_client_client_session.rb

@@ -284,17 +284,16 @@ module Java::org.hornetq.api.core.client::ClientSession
   end
     
   # To be consistent create Requestor from Session
-  def create_requestor(request_address)
-    #Java::org.hornetq.api.core.client::ClientRequestor.new(self, request_address);
-    HornetQ::Client::RequestorPattern.new(self, request_address)
+  def create_requestor(request_address, reply_address=nil, reply_queue=nil)
+    HornetQ::Client::RequestorPattern.new(self, request_address, reply_address, reply_queue)
   end
   
   # Creates a RequestorPattern to send a request and to synchronously wait for
   # the reply, call the supplied block, then close the requestor
   # Returns the result from the block
-  def requestor(request_address,&block)
+  def requestor(request_address, reply_address=nil, reply_queue=nil, &block)
     begin
-      requestor = self.create_requestor(request_address)
+      requestor = self.create_requestor(request_address, reply_address, reply_queue)
       block.call(requestor)
     ensure
       requestor.close if requestor

data/lib/hornetq/client/org_hornetq_core_client_impl_client_message_impl.rb

@@ -53,6 +53,12 @@
 #          
 # long 	message_id()
 #          Returns the messageID
+#          This is an internal message id used by HornetQ itself, it cannot be
+#          set by the user.
+#          The message is only visible when consuming messages, when producing
+#          messages the message_id is Not returned to the caller
+#          Use user_id to carry user supplied message id's for correlating 
+#          responses to requests
 #          
 # byte 	priority()
 #          Returns the message priority. 
@@ -136,14 +142,22 @@ class Java::OrgHornetqCoreClientImpl::ClientMessageImpl
   #     requestor = session.create_requestor('Request Queue')
   #
   def reply_to_address=(name)
-    val = nil
-    if name.is_a? Java::org.hornetq.api.core::SimpleString
-      val = name
-    else
-      val = Java::org.hornetq.api.core::SimpleString.new(name.to_s)
-    end
-
-    put_string_property(Java::OrgHornetqCoreClientImpl::ClientMessageImpl::REPLYTO_HEADER_NAME, val)
+    put_string_property(Java::OrgHornetqCoreClientImpl::ClientMessageImpl::REPLYTO_HEADER_NAME, HornetQ::as_simple_string(name))
+  end
+  
+  # Generate a new user_id
+  #
+  # Sets the user_id to a newly generated id, using a UUID algorithm
+  # 
+  # The user_id is similar to the message_id in other JMS based messaging systems
+  # in fact the HornetQ JMS API uses the user_id as the JMS Message ID.
+  # 
+  # The internal message_id is set by the HornetQ Server and is Not returned
+  # when sending messages
+  # 
+  # Returns generated user_id
+  def generate_user_id
+    self.user_id = Java::org.hornetq.utils::UUIDGenerator.instance.generateUUID
   end
   
   # Returns the message type as one of the following symbols
@@ -349,7 +363,7 @@ class Java::OrgHornetqCoreClientImpl::ClientMessageImpl
       :priority => priority,      
       :timestamp => timestamp,
       :type_sym => type_sym,
-      :user_id => user_id,
+      :user_id => user_id.nil? ? nil : user_id.to_s,
     }
   end
 
@@ -357,5 +371,5 @@ class Java::OrgHornetqCoreClientImpl::ClientMessageImpl
   def inspect
     "#{self.class.name}:\nBody: #{body.inspect}\nAttributes: #{attributes.inspect}\nProperties: #{properties.inspect}"
   end
-
+  
 end

data/lib/hornetq/client/requestor_pattern.rb

@@ -1,30 +1,111 @@
 module HornetQ::Client
 
   # Implements the Requestor Pattern 
-  #   Send a request to a server and wait for a reply  
+  #   Send a request to a server and wait for a reply
+  # Parameters
+  # * session
+  #   The session to use processing this request
+  #   Note: Sessions cannot be shared concurrently by multiple threads
+  # * request_address
+  #   Address to send requests to.
+  #   It is expected that process listening to requests at this address has
+  #   implemented the ServerPattern
+  # * reply_address 
+  #   If supplied the reply_address must already exist and will be used for 
+  #   receiving responses
+  #   If not supplied a temporary queue will be created and used by this instance
+  #   of the RequestorPattern
+  #   This optional parameter is normally not used 
+  # * reply_queue
+  #   If a reply_address is supplied, the reply_queue name can be supplied if it
+  #   differs from reply_address
   class RequestorPattern
-    def initialize(session, request_address)
+    def initialize(session, request_address, reply_address=nil, reply_queue=nil)
       @session = session
       @producer = session.create_producer(request_address)
-      reply_queue = "#{request_address}.#{Java::java.util::UUID.randomUUID.toString}"
-      begin
-        session.create_temporary_queue(reply_queue, reply_queue)
-      rescue NativeException => exc
-        p exc
+      if reply_address
+        @reply_address = reply_address
+        @reply_queue = reply_queue || reply_address
+        @destroy_temp_queue = false
+      else
+        @reply_queue = @reply_address = "#{request_address}.#{Java::java.util::UUID.randomUUID.toString}"
+        begin
+          session.create_temporary_queue(@reply_address, @reply_queue)
+          @destroy_temp_queue = true
+        rescue NativeException => exc
+          p exc
+        end
       end
-      @consumer = session.create_consumer(reply_queue)
     end
-  
+    
+    # Synchronous Request and wait for reply
+    #  
+    # Returns the message received, or nil if no message was received in the
+    # specified timeout.
+    # 
+    # The supplied request_message is updated as follows
+    # * The property JMSReplyTo is set to the name of the reply to address
+    # * Creates and sets the message user_id if not already set
+    # * #TODO: The expiry is set to the message timeout if not already set
+    # 
+    # Note: 
+    # * The request will only look for a reply message with the same
+    #   user_id (message id) as the message that was sent. This is critical
+    #   since a previous receive may have timed out and we do not want
+    #   to pickup the reponse to an earlier request 
+    # 
+    # To receive a message after a timeout, call wait_for_reply with a nil message
+    # id to receive any message on the queue
+    # 
+    # Use: submit_request & then wait_for_reply to break it into
+    #      two separate calls
     def request(request_message, timeout)
-      request_message.putStringProperty(Java::OrgHornetqCoreClientImpl::ClientMessageImpl::REPLYTO_HEADER_NAME, @consumer.queue_name);
+      #TODO set message expiry to timeout if not already set
+      message_id = submit_request(request_message)
+      wait_for_reply(message_id, timeout)
+    end
+    
+    # Asynchronous Request
+    #  Use: submit_request & then wait_for_reply to break the request into
+    #       two separate calls.
+    #       
+    # For example, submit the request now, do some work, then later on
+    # in the same thread wait for the reply.
+    # 
+    # The supplied request_message is updated as follows
+    # * The property JMSReplyTo is set to the name of the reply to address
+    # * Creates and sets the message user_id if not already set
+    # * #TODO: The expiry is set to the message timeout if not already set
+    # 
+    # Returns Message id of the message that was sent
+    def submit_request(request_message)
+      request_message.reply_to_address = @reply_address
+      request_message.generate_user_id unless request_message.user_id
       @producer.send(request_message)
-      @consumer.receive(timeout)
+      request_message.user_id
+    end
+    
+    # Asynchronous wait for reply
+    # 
+    # Parameters:
+    #   user_id: the user defined id to correlate a response for 
+    # 
+    # Supply a nil user_id to receive any message from the queue
+    #  
+    # Returns the message received
+    # 
+    # Note: Call submit_request before calling this method
+    def wait_for_reply(user_id, timeout)
+      # We only want the reply to the supplied message_id, so set filter on message id
+      filter = "#{Java::org.hornetq.api.core::FilterConstants::HORNETQ_USERID} = 'ID:#{user_id}'" if user_id
+      @session.consumer(:queue_name => @reply_queue, :filter=>filter) do |consumer|
+        consumer.receive(timeout)
+      end
     end
     
     def close
+      @session.delete_queue(@reply_queue) if @destroy_temp_queue
       @producer.close if @producer
-      @consumer.close if @consumer
-      @session.delete_queue(@consumer.queue_name)
     end
   end
   

data/lib/hornetq/client/server_pattern.rb

@@ -35,6 +35,7 @@ module HornetQ::Client
         reply_message.durable = request_message.durable?
         # Send request message id back in reply message for correlation purposes
         reply_message.user_id = request_message.user_id
+        #TODO: Also need to include other attributes such as Expiry
         # Send to Reply to address supplied by the caller
         @producer.send(request_message.reply_to_address, reply_message)
         #puts "Sent reply to #{reply_to.to_s}: #{reply_message.inspect}"

metadata

@@ -2,7 +2,7 @@
 name: jruby-hornetq
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors: 
   - Reid Morrison
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-24 00:00:00 -04:00
+date: 2011-04-01 00:00:00 -04:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -59,6 +59,7 @@ files:
   - examples/advanced/server.rb
   - examples/client-server/client.rb
   - examples/client-server/server.rb
+  - examples/producer-consumer/browse_all.rb
   - examples/producer-consumer/consume_all.rb
   - examples/producer-consumer/consume_on_message.rb
   - examples/producer-consumer/consumer.rb