jruby-hornetq 0.3.1 → 0.3.2

data/README.md

@@ -116,7 +116,7 @@ Producer: Write messages to a queue:
     require 'rubygems'
     require 'hornetq'
     
-    HornetQ::Client::Factory.create_session(:connector=> {:uri => 'hornetq://localhost'}) do |session|
+    HornetQ::Client::Factory.create_session(:connection => {:uri => 'hornetq://localhost'}) do |session|
       # Create Producer so that we can send messages to the Address 'jms.queue.ExampleQueue'
       producer = session.create_producer('jms.queue.ExampleQueue')
       
@@ -133,7 +133,7 @@ Consumer: Read message from a queue:
     require 'rubygems'
     require 'hornetq'
     
-    HornetQ::Client::Factory.start(:connector=> {:uri => 'hornetq://localhost'}) do |session|
+    HornetQ::Client::Factory.start(:connection => {:uri => 'hornetq://localhost'}) do |session|
       consumer = session.create_consumer('jms.queue.ExampleQueue')
       
       # Receive a single message, return immediately if no message available
@@ -156,7 +156,7 @@ Server: Receive requests and send back a reply
     # Shutdown Server after 5 minutes of inactivity, set to 0 to wait forever
     timeout = 300000
     
-    HornetQ::Client::Factory.start(:connector=> {:uri => 'hornetq://localhost'}) do |session|
+    HornetQ::Client::Factory.start(:connection => {:uri => 'hornetq://localhost'}) do |session|
       server = session.create_server('jms.queue.ExampleQueue', timeout)
     
       puts "Waiting for Requests..."  
@@ -184,7 +184,7 @@ Client: Send a request and wait for a reply
     # Wait 5 seconds for a reply
     timeout = 5000
     
-    HornetQ::Client::Factory.start(:connector=> {:uri => 'hornetq://localhost'}) do |session|
+    HornetQ::Client::Factory.start(:connection => {:uri => 'hornetq://localhost'}) do |session|
       requestor = session.create_requestor('jms.queue.ExampleQueue')
     
       # Create non-durable message

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.1'
+    s.version = '0.3.2'
     s.authors = ['Reid Morrison', 'Brad Pardee']
     s.email = ['rubywmq@gmail.com', 'bpardee@gmail.com']
     s.homepage = 'https://github.com/ClarityServices/jruby-hornetq'

data/examples/advanced/batch_client.rb

@@ -10,6 +10,9 @@
 # This sample sends a total of 100 requests in batches of 10.
 # One thread sends requests and the other processes replies.
 # Once 80% of the replies are back, it will send the next batch
+#  
+# Before running this sample, start server.rb first
+#
 
 # Allow examples to be run in-place without requiring a gem install
 $LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
@@ -17,99 +20,53 @@ $LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
 require 'rubygems'
 require 'yaml'
 require 'hornetq'
-require 'sync'
+require 'batch_requestor_pattern'
 
-total_count = (ARGV[0] || 100).to_i
-batching_size = (ARGV[1] || 10).to_i
+batch_size = (ARGV[0] || 100).to_i
+window_size = (ARGV[1] || 10).to_i
 
-request_address = 'ServerAddress'
-config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
+server_address = 'ServerAddress'
 
-class BatchClientPattern
-  def initialize(connection, request_address)
-    @session = connection.create_session
-    @producer = @session.create_producer(request_address)
-    @reply_queue = "#{request_address}.#{Java::java.util::UUID.randomUUID.toString}"
-    @session.create_temporary_queue(@reply_queue, @reply_queue)
-    @counter_sync = Sync.new
-    @counter = 0
-    
-    # Start consuming replies
-    connection.on_message(:queue_name => @reply_queue) {|message| process_reply(message) }
-  end
-  
-  # Increment Message Counter
-  def inc_counter(total_count=1)
-    @counter_sync.synchronize(:EX) { @counter += total_count }
-  end
+config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
 
-  # Decrement Message counter
-  def dec_counter(total_count=1)
-    @counter_sync.synchronize(:EX) { @counter -= total_count }
-  end
-  
-  # Return the current message count
-  def counter
-    @counter_sync.synchronize(:SH) { @counter }
-  end
+# Create a HornetQ session
+HornetQ::Client::Connection.connection(config[:connection]) do |connection|
+  window_size = batch_size if window_size > batch_size
+  # * :batch_size Total size of batch
+  # * :window_size Size of the sliding window. This also indicates the maximimum
+  #                number of outstanding requests to have open at any time
+  #                Default: 0.8
+  #                (:max_outstanding_responses)
   
-  # Send x messages
-  def send(total_count)
-    #print "Sending #{total_count} messages"
-    start_time = Time.now
-    total_count.times do |i|
-      message = @session.create_message(HornetQ::Client::Message::TEXT_TYPE,true)
-      message.reply_to_queue_name = @reply_queue
-      message.body = "Request Current Time. #{i}"
-      @producer.send(message)
-      print "."
-      #puts "Sent:#{message}"
-    end
-    duration = Time.now - start_time
-    #printf "\nSend %5d msg, %5.2f s, %10.2f msg/s\n", total_count, duration, total_count/duration
-  end
+  pattern_config = {
+    :connection     => connection,
+    :server_address => server_address,
+    :completion_ratio => 0.8
+  }
   
-  # Receive Reply messages
-  def process_reply(message)
+  requestor = BatchRequestorPattern.new(connection, server_address) do |message|
+    # Display an @ symbol for every reply received
     print '@'
-    inc_counter(1)
-    message.acknowledge
   end
   
-  def close
-    @producer.close
-    @session.close
-  end
-end
-
-# Create a HornetQ session
-HornetQ::Client::Connection.connection(config[:connection]) do |connection|
-  batching_size = total_count if batching_size > total_count
-  
-  client = BatchClientPattern.new(connection, request_address)
-  
-  times = (total_count/batching_size).to_i
+  times = (batch_size/window_size).to_i
   puts "Performing #{times} loops"
-  count = 0
+  
   times.times do |i|
-    client.send(batching_size)
-    count += batching_size
-    # Wait for at least 80% of responses
-    loop do
-      #puts "Waiting for receive"
-      sleep 0.1
-      received_count = client.counter
-      #puts "\nReceived #{received_count} messages"
-      if received_count >= 0.8 * count
-        puts ""
-        break 
-      end
+    
+    window_size.times do |i|
+      message = @session.create_message(true)
+      message.type = :text
+      message.body = "Request Current Time. #{i}"
+      requestor.send(message)
+      print "."
     end
+    
+    # Wait for at least 80% of responses before sending more requests
+    requestor.wait_for_outstanding_replies
+    
   end
-  
-  while client.counter < total_count
-    sleep 0.1
-    print "*"
-  end
-  client.close
+  puts "Done sending requests, waiting for remaining replies"
+  requestor.wait_for_all_outstanding_replies
+  requestor.close
 end

data/examples/advanced/batch_requestor_pattern.rb

@@ -0,0 +1,163 @@
+#
+# HornetQ Batch Requestor Pattern:
+#      Submit a batch of requests and wait for replies
+#
+# This is an advanced use case where the client submits requests in a controlled
+# fashion. The alternative would be just to submit all requests at the same time,
+# however then it becomes extremely difficult to pull back submitted requests
+# if say 80% of the first say 100 requests fail.
+#
+# This sample sends a total of 100 requests in batches of 10.
+# One thread sends requests and the other processes replies.
+# Once 80% of the replies are back, it will send the next batch
+#
+# Maybe one day this pattern can make it out of examples and into the product :)
+#
+require 'sync'
+
+class BatchRequestorPattern
+  
+  attr_accessor :batch_size, :window_size, :completion_ratio
+  attr_reader :reply_address, :reply_count, :send_count
+  
+  # 
+  # Returns a new BatchRequestorPattern
+  # 
+  # Parameters:
+  # * connection: The HornetQ connection. Used for creating sessions for the
+  #               pattern to run
+  # * server_address: The address to send requests to
+  # * An optional block can be passed in that will be called with every reply
+  #   It can be used to perform specialized handling such as:
+  # ** Aborting a batch process
+  # ** Moving the response to another queue for re-queuing later
+  # 
+  # Implementation:
+  # 
+  # Creates a temporary reply to queue for receiving responses from the server
+  #   Consists of the server_address following by a '.' and a UUID
+  #   
+  # Uses Connection#on_message to process replies in a separate thread
+  # 
+  # If the connection is started, it will start consuming replies immediately,
+  # otherwise it will only start processing replies once the connection has
+  # been started.
+  # 
+  # Sending of messages should be done by only one thread at a time since
+  # this pattern shares the same session and producer for sending messages
+  #
+  # Parameters
+  # * :connection Connection to create session and response queue with
+  # * :server_address Address to send requests to
+  # * :completion_ratio Percentage of responses to wait for before sending
+  #                     further requests
+  #                     Must be a number between 0 and 1 inclusive
+  #                     Default: 0.8
+  #
+  def initialize(params, &reply_block)
+    params            = params.dup
+    connection        = params.delete(:connection)
+    server_address    = params.delete(:server_address)
+    @completion_ratio = params.delete(:completion_ratio).to_f
+    
+    raise "Invalid :completion_ratio of #{@completion_ratio}. Must be between 0 and 1 inclusive" unless @completion_ratio.between?(0,1)
+    
+    @session = connection.create_session
+    @producer = @session.create_producer(server_address)
+    @reply_address = "#{server_address}.#{Java::java.util::UUID.randomUUID.toString}"
+    @session.create_temporary_queue(@reply_address, @reply_address)
+    @reply_count_sync = Sync.new
+    @reply_count = 0
+    @send_count = 0
+    @reply_block = reply_block
+    
+    # Start consuming replies. The Address and Queue names are the same
+    connection.on_message(:queue_name => @reply_address) {|message| process_reply(message) }
+  end
+  
+  # Return the current message count
+  def reply_count
+    @reply_count_sync.synchronize(:SH) { @reply_count }
+  end
+  
+  # Send a message to the server, setting the reply to address to the temporary
+  # address created by this pattern
+  # 
+  # Sending of messages should be done by only one thread at a time since
+  # this pattern shares the same session and producer for sending messages
+  #
+  # Returns the total number of messages sent so far in this batch
+  def send(message)
+    message.reply_to_address = @reply_address
+    @producer.send(message)
+    @send_count += 1
+  end
+  
+  # Retry Sending a message to the server, setting the reply to address to the 
+  # temporary address created by this pattern
+  # 
+  # Only call this method when a reply is received and we want to resend a
+  # previous request
+  # 
+  # Note: This method will decrement the number of messages received by 1 
+  #       and will Not increment the number of messages sent, since it is 
+  #       considered to have already been sent
+  # 
+  # ReSending and Sending of messages should be done by only one thread at a time since
+  # this pattern shares the same session and producer for sending messages
+  # #TODO Should we rather just add a Sync around the producer?
+  #       What if a resend is being done in the reply handler?
+  #
+  # Returns the total number of messages sent so far in this batch
+  def resend(message)
+    message.reply_to_address = @reply_address
+    
+    # Decrement Reply Message counter
+    @reply_count_sync.synchronize(:EX) { @reply_count -= 1 }  
+    @producer.send(message)
+  end
+  
+  # Receive Reply messages, calling the supplied reply handler block to support
+  # custom error handling
+  # 
+  # Returns result of reply block supplied to constructor
+  def process_reply(message)
+    # Increment reply message counter
+    @reply_count_sync.synchronize(:EX) { @reply_count += 1 }
+    
+    result = @reply_block.call(message) if @reply_block
+    message.acknowledge
+    result
+  end
+  
+  # Release resources used by this pattern
+  def close
+    @producer.close
+    @session.close
+  end
+  
+  # Wait for replies from server until the required number of responses has been
+  # received based on the completion ratio
+  # 
+  # For example a completion ration of 0.8 will wait for at least 80% of replies
+  # to be received. So if 10 requests were sent this method would only return
+  # once 8 or more replies have been received
+  # 
+  # #TODO Need a Timeout here
+  def wait_for_outstanding_replies
+    while self.reply_count >= self.completion_ratio * self.send_count
+      sleep 0.1
+    end
+  end
+  
+  # Wait for replies from server until the required number of responses has been
+  # received based on the completion ratio
+  # 
+  # #TODO Need a Timeout here
+  def wait_for_all_outstanding_replies
+    while self.reply_count >= self.send_count
+      sleep 0.1
+    end
+  end
+  
+end

data/examples/advanced/producer.rb

@@ -18,14 +18,15 @@ config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
 # Create a HornetQ session
 HornetQ::Client::Connection.session(config) do |session|
   # Create a non-durable TestQueue to receive messages sent to the TestAddress
-  session.create_queue_ignore_exists('TestAddress', 'TestQueue', false)
+  session.create_queue_ignore_exists('jms.queue.SampleQueue', 'jms.queue.SampleQueue', false)
   start_time = Time.now
   
-  session.producer('TestAddress') do |producer|
+  session.producer('jms.queue.SampleQueue') do |producer|
     puts "Sending messages"
     (1..count).each do |i|
       message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
-      message.body = "#{Time.now}: ### Hello, World ###"
+      message.body = "#{Time.now}: #{i} : ### Hello, World ###"
+      message.user_id = Java::org.hornetq.utils::UUIDGenerator.getInstance.generateUUID
       
       producer.send(message)
       puts "#{i}\n" if i%1000 == 0

data/examples/producer-consumer/consume_all.rb

@@ -10,13 +10,16 @@ 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|
+HornetQ::Client::Connection.start_session(
+  :connection => {:uri => 'hornetq://stage1'} ,
+  :session => { :username => 'clarity', :password => 'clarityrul3s'}) do |session|
   
   # Create a non-durable TestQueue to receive messages sent to the TestAddress
-  session.create_queue_ignore_exists('TestAddress', 'TestQueue', false)
+  session.create_queue_ignore_exists('jms.queue.SampleQueue', 'jms.queue.SampleQueue', false)
   
   # Consume All messages from the queue and gather statistics
-  stats = session.consume(:queue_name => 'TestQueue', :timeout=> 0, :statistics=>true) do |message|
+  stats = session.consume(:queue_name => 'jms.queue.SampleQueue', :timeout=> 0, :statistics=>true) do |message|
+    puts "Body Size:#{message.body_size}"
     p message
     puts "=================================="
     message.acknowledge

data/examples/resque/hornetq_job.rb

@@ -77,7 +77,7 @@ class BatchClientPattern
     start_time = Time.now
     total_count.times do |i|
       message = @session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
-      message.reply_to_queue_name = @consumer.queue_name
+      message.reply_to_address = @consumer.queue_name
       message.body = "Request Current Time. #{i}"
       @producer.send(message)
       print "."

data/examples/worker/hornetq.yml

@@ -10,7 +10,7 @@ client:
   :session:
     :username:          guest
     :password:          guest
-    :auto_close:        true
+    :managed:           true
   :session_pool:
     :pool_size:         3
     :pool_warn_timeout: 0.25

data/lib/hornetq/client/connection.rb

@@ -174,7 +174,8 @@ module HornetQ
         @sessions = []
         @consumers = []
         # In-VM Transport has no fail-over or additional parameters
-        if uri.host == 'invm'
+        @is_invm = uri.host == 'invm'
+        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]
@@ -212,6 +213,11 @@ module HornetQ
         end
       end
 
+      # Return true if this connection was configured in INVM transport protocol
+      def invm?
+        @is_invm
+      end
+
       # Create a new HornetQ session
       #
       # Note: Remember to close the session once it is no longer used.
@@ -316,6 +322,7 @@ module HornetQ
       #
       def create_session(params={})
         raise "HornetQ::Client::Connection Already Closed" unless @connection
+        params ||= {}
         session = @connection.create_session(
           params[:username],
           params[:password],
@@ -487,11 +494,11 @@ module HornetQ
       # Start all sessions managed by this connection
       # 
       # Sessions created via #create_session are not managed unless
-      # :auto_close => true was specified when the session was created
+      # :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 :auto_close => true
+      #   Connection#create_session And :managed => true
       #
       # This call does not do anything to sessions in a session pool
       def start_managed_sessions

data/lib/hornetq/client/org_hornetq_core_client_impl_client_message_impl.rb

@@ -123,18 +123,19 @@ class Java::OrgHornetqCoreClientImpl::ClientMessageImpl
     contains_property(Java::OrgHornetqCoreClientImpl::ClientMessageImpl::REPLYTO_HEADER_NAME)
   end
   
-  # Return the Reply To Queue Name as a string
-  def reply_to_queue_name
+  # Return the Reply To Address as a string
+  def reply_to_address
     get_string_property(Java::OrgHornetqCoreClientImpl::ClientMessageImpl::REPLYTO_HEADER_NAME)
   end
 
-  # Set the Reply To Queue Name
+  # Set the Reply To Address
   #  When supplied, the consumer of the message is expected to send a response to the
-  #  specified queue. However, this is by convention, so no response is guaranteed
+  #  specified address. However, this is by convention, so no response is guaranteed
+  #  
   # Note: Rather than set this directly, consider creating a Client::Requestor:
   #     requestor = session.create_requestor('Request Queue')
   #
-  def reply_to_queue_name=(name)
+  def reply_to_address=(name)
     val = nil
     if name.is_a? Java::org.hornetq.api.core::SimpleString
       val = name

data/lib/hornetq/client/org_hornetq_core_client_impl_client_producer_impl.rb

@@ -1,5 +1,30 @@
 # TODO Support send(String)
 # TODO Support send(:data => string, :durable=>true, :address=>'MyAddress')
 #
+# See: http://hornetq.sourceforge.net/docs/hornetq-2.1.2.Final/api/index.html?org/hornetq/api/core/client/ClientProducer.html
+# 
+# Other methods still directly accessible through this class:
+#
+# void 	send(Message message)
+#          Sends a message to an address
+# void 	send(String address, Message message)
+#          Sends a message to the specified address instead of the ClientProducer's address
+#          
+#	close()
+#          Closes the ClientProducer
+# boolean 	closed?
+#          Returns whether the producer is closed or not
+#          
+# SimpleString 	address()
+#          Returns the address where messages will be sent
+#          
+# int 	max_rate()
+#          Returns the maximum rate at which a ClientProducer can send messages per second
+#          
+# boolean 	block_on_durable_send?
+#          Returns whether the producer will block when sending durable messages
+# boolean 	block_on_non_durable_send?
+#          Returns whether the producer will block when sending non-durable messages
+#          
 class Java::org.hornetq.core.client.impl::ClientProducerImpl
 end

data/lib/hornetq/client/server_pattern.rb

@@ -25,14 +25,18 @@ module HornetQ::Client
     # Send a reply to the received request message
     #   request: is the message received
     #   reply:   is the message to send to the client
+    #
+    # Note: A reply is only sent if it is a request message. This means that
+    #       the message must have a property named Java::OrgHornetqCoreClientImpl::ClientMessageImpl::REPLYTO_HEADER_NAME
+    #       containing the name of the address to which the response should be sent
     def reply(request_message, reply_message)
       if request_message.request?
         # Reply should have same durability as request
         reply_message.durable = request_message.durable?
-        reply_to = request_message.getSimpleStringProperty(Java::OrgHornetqCoreClientImpl::ClientMessageImpl::REPLYTO_HEADER_NAME);
         # Send request message id back in reply message for correlation purposes
         reply_message.user_id = request_message.user_id
-        @producer.send(reply_to, reply_message)
+        # 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}"
       end
       request_message.acknowledge

data/lib/hornetq/client/session_pool.rb

@@ -104,7 +104,7 @@ module HornetQ::Client
             producer = s.create_producer(address)
             block.call(s, producer)
           ensure
-            producer.close
+            producer.close if producer
           end
         end
       end

data/lib/hornetq/server.rb

@@ -41,12 +41,24 @@ module HornetQ
       acceptor_conf_set.add(acceptor)
       config.acceptor_configurations = acceptor_conf_set
 
+      more_acceptors = params.delete(:acceptor)
+      if more_acceptors
+        more_acceptors = [more_acceptors] unless more_acceptors.kind_of?(Array)
+        more_acceptors.each do |uri_str|
+          uri = HornetQ::URI.new(uri_str)
+          p = uri.params.merge('host' => uri.host, 'port' => uri.port)
+          puts p.inspect
+          accept = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::NETTY_ACCEPTOR_CLASS_NAME, p)
+          acceptor_conf_set.add(accept)
+        end
+      end
+
       if Java::org.hornetq.core.journal.impl.AIOSequentialFileFactory.isSupported
         config.journal_type = Java::org.hornetq.core.server.JournalType::ASYNCIO
       else
         require 'rbconfig'
         if Config::CONFIG['target_os'] == 'linux'
-          HornetQ.logger.info("AIO wasn't located on this platform, it will fall back to using pure Java NIO. Install LibAIO to enable the AIO journal")
+          HornetQ.logger.info("AIO wasn't located on this platform, it will fall back to using pure Java NIO. Install libaio and libHornetQAIO to enable the AIO journal")
         end
         config.journal_type = Java::org.hornetq.core.server.JournalType::NIO
       end

data/lib/hornetq/uri.rb

@@ -47,7 +47,7 @@ module HornetQ
           value = false if value == 'false'
           value = value.to_i if value =~ /^\d+$/
           value = value.to_f if value =~ /^\d+\.\d*$/
-          @params[key.to_sym] = value
+          @params[key] = value
         end
       end
     end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
     - 0
     - 3
-    - 1
-  version: 0.3.1
+    - 2
+  version: 0.3.2
 platform: ruby
 authors: 
   - Reid Morrison
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-23 00:00:00 -05:00
+date: 2011-03-09 00:00:00 -05:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -48,8 +48,13 @@ files:
   - Rakefile
   - README.md
   - bin/hornetq_server
+  - bin/data/bindings/hornetq-bindings-1.bindings
+  - bin/data/bindings/hornetq-bindings-2.bindings
+  - bin/data/journal/hornetq-data-1.hq
+  - bin/data/journal/hornetq-data-2.hq
   - examples/README
   - examples/advanced/batch_client.rb
+  - examples/advanced/batch_requestor_pattern.rb
   - examples/advanced/bytes_producer.rb
   - examples/advanced/client.rb
   - examples/advanced/client_session_pooling.rb