jruby-hornetq 0.4.0 → 0.5.0.alpha

data/examples/advanced/bytes_producer.rb

@@ -12,14 +12,14 @@ require 'hornetq'
 HornetQ::Client::Connection.session('hornetq://localhost') do |session|
   # Create the non-durable TestQueue to receive messages sent to the TestAddress
   session.create_queue_ignore_exists('TestAddress', 'TestQueue', false)
-  
+
   # Create Producer so that we can send messages to the Address 'jms.queue.ExampleQueue'
   session.producer('TestAddress') do |producer|
-  
+
     # Create a non-durable bytes message to send
     message = session.create_message(HornetQ::Client::Message::BYTES_TYPE,false)
     message.body = "#{Time.now}: ### Hello, World ###"
-  
+
     producer.send(message)
   end
 end

data/examples/advanced/client.rb

@@ -2,8 +2,8 @@
 # HornetQ Requestor:
 #      Submit a request and wait for a reply
 #      Uses the Requestor Pattern
-#      
-#      The Server (server.rb) must be running first, otherwise this example 
+#
+#      The Server (server.rb) must be running first, otherwise this example
 #      program will eventually timeout
 #      Displays a '.' for every request completed
 #      Used for performance measurements
@@ -26,7 +26,7 @@ HornetQ::Client::Connection.start_session(config) do |session|
   # Create a non-durable ServerQueue to receive messages sent to the ServerAddress
   session.create_queue_ignore_exists('ServerAddress', 'ServerQueue', false)
   start_time = Time.now
-  
+
   # Use Requestor (Client) Pattern to do a "RPC like" call to a server
   # Under the covers the requestor creates a temporary dynamic reply to queue
   # for the server to send the reply message to
@@ -38,7 +38,7 @@ HornetQ::Client::Connection.start_session(config) do |session|
       message.body = "Some request data"
       # Set the user managed message id
       message.user_id = Java::org.hornetq.utils::UUIDGenerator.getInstance.generateUUID
-  
+
       if reply = requestor.request(message, timeout)
         puts "Received Response: #{reply.inspect}" if count < 10
         puts "  Message:[#{reply.body.inspect}]" if count < 10
@@ -47,7 +47,7 @@ HornetQ::Client::Connection.start_session(config) do |session|
         puts "Time out, No reply received after #{timeout/1000} seconds"
       end
       puts "#{i}" if i%1000 == 0
-  
+
     end
   end
 

data/examples/advanced/client_session_pooling.rb

@@ -1,10 +1,10 @@
 #
 # HornetQ Requestor using session_pooling:
-#      Multithreaded clients all doing requests. 
-#      
+#      Multithreaded clients all doing requests.
+#
 #      Shows how the same session can be used safely on different threads
 #      rather than each thread having to create its own session
-#      
+#
 #      Typical scenario is in a Rails app when we need to do a call to a
 #      remote server and block until a response is received
 #

data/examples/advanced/consume_on_message.rb

@@ -20,12 +20,12 @@ config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
 
 # Using Connect.start since a session must be started in order to consume messages
 HornetQ::Client::Connection.connection(config[:connection]) do |connection|
-  
+
   # Create a non-durable TestQueue to receive messages sent to the TestAddress
   connection.session(config[:session]) do |session|
     session.create_queue_ignore_exists('TestAddress', 'TestQueue', false)
   end
-  
+
   # Consume All messages from the queue and gather statistics
   # on_message will call the supplied block for every message received in another
   # thread. As a result, the on_message call returns immediately!
@@ -33,17 +33,17 @@ HornetQ::Client::Connection.connection(config[:connection]) do |connection|
   #
   # :session_count can be used to spawn multiple consumers simultaneously, each
   # receiving messages simultaneously on their own threads
-  connection.on_message(:queue_name    => 'TestQueue', 
+  connection.on_message(:queue_name    => 'TestQueue',
                         :session_count => session_count,
                         :statistics    => true) do |message|
     print '.'
     message.acknowledge
   end
-  
+
   puts "Started #{session_count} consumers, will wait for #{sleep_time/1000} seconds before shutting down"
   # Wait for sleep_time before shutting down the server
   sleep(sleep_time/1000)
-  
+
   connection.on_message_statistics.each do |stats|
     puts "Received #{stats[:count]} messages in #{stats[:duration]} seconds at #{stats[:messages_per_second]} messages per second"
   end

data/examples/advanced/consumer.rb

@@ -18,10 +18,10 @@ config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
 
 # Create a HornetQ session
 HornetQ::Client::Connection.start_session(config) do |session|
-  
+
   # Create the non-durable TestQueue to receive messages sent to the TestAddress
   session.create_queue_ignore_exists('TestAddress', 'TestQueue', false)
-  
+
   # Consume All messages from the queue
   stats = session.consume(:queue_name => 'TestQueue', :timeout=> 0, :statistics=>true) do |message|
     print '.'

data/examples/advanced/multi_client.rb

@@ -21,7 +21,7 @@ def worker_thread(id, connection, timeout, request_count)
   begin
     connection.start_session do |session|
       start_time = Time.now
-  
+
       # Use Requestor (Client) Pattern to do a "RPC like" call to a server
       # Under the covers the requestor creates a temporary dynamic reply to queue
       # for the server to send the reply message to
@@ -33,7 +33,7 @@ def worker_thread(id, connection, timeout, request_count)
           message.body = "Some request data"
           # Set the user managed message id
           message.user_id = Java::org.hornetq.utils::UUIDGenerator.getInstance.generateUUID
-  
+
           if reply = requestor.request(message, timeout)
             puts "Thread[#{id}]:Received Response: #{reply.inspect}" if request_count < 10
             puts "Thread[#{id}]:  Message:[#{reply.body.inspect}]" if request_count < 10
@@ -44,7 +44,7 @@ def worker_thread(id, connection, timeout, request_count)
           puts "Thread:#{id}=>#{i}" if i%1000 == 0
         end
       end
-      
+
       duration = Time.now - start_time
       puts "\nThread[#{id}]:Made #{request_count} calls in #{duration} seconds at #{request_count/duration} synchronous requests per second"
     end

data/examples/advanced/producer.rb

@@ -20,7 +20,7 @@ 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)
   start_time = Time.now
-  
+
   session.producer('TestAddress') do |producer|
     puts "Sending messages"
     (1..count).each do |i|
@@ -28,12 +28,12 @@ HornetQ::Client::Connection.session(config) do |session|
       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
     end
   end
-  
+
   duration = Time.now - start_time
   puts "Delivered #{count} messages in #{duration} seconds at #{count/duration} messages per second"
 end

data/examples/advanced/server.rb

@@ -21,24 +21,24 @@ HornetQ::Client::Connection.start_session(config) do |session|
 
   count = 0
   start_time = Time.now
-  
+
   session.server('ServerQueue', timeout) do |server|
     puts "Server started and waiting for requests ..."
     server.run do |request_message|
       count += 1
       print '.'
       puts "#{count}" if count%1000 == 0
-    
+
       # Create Reply Message
       reply_message = session.create_message(HornetQ::Client::Message::TEXT_TYPE, false)
       reply_message.body = "Echo [#{request_message.body}]"
-    
+
       # The result of this block is the message to be sent back to the requestor (client)
       # Or, nil if no response should be sent back
       reply_message
     end
   end
-  
+
   duration = Time.now - start_time - timeout/1000
   puts "\nReceived #{count} requests in #{duration} seconds at #{count/duration} messages per second"
 end

data/examples/client-server/client.rb

@@ -2,7 +2,7 @@
 # HornetQ Requestor (Client):
 #      Submit a request and wait for a reply
 #      Uses the Requestor Pattern
-#      The Server (server.rb) must be running first, otherwise this example 
+#      The Server (server.rb) must be running first, otherwise this example
 #      program will eventually timeout
 #
 
@@ -16,7 +16,7 @@ timeout = (ARGV[0] || 5000).to_i
 
 # 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 ServerQueue to receive messages sent to the ServerAddress
   session.create_queue_ignore_exists('ServerAddress', 'ServerQueue', false)
 
@@ -27,7 +27,7 @@ HornetQ::Client::Connection.start_session('hornetq://localhost') do |session|
     # Create non-durable message
     message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
     message.body = "Some request data"
-  
+
     # Send message to the address
     puts "Send request message and wait for Reply"
     if reply = requestor.request(message, timeout)
@@ -35,6 +35,6 @@ HornetQ::Client::Connection.start_session('hornetq://localhost') do |session|
     else
       puts "Time out, No reply received after #{timeout/1000} seconds"
     end
-  
+
   end
 end

data/examples/client-server/server.rb

@@ -20,18 +20,18 @@ HornetQ::Client::Connection.start_session(:connection=> {:uri => 'hornetq://loca
   session.create_queue_ignore_exists('ServerAddress', 'ServerQueue', false)
 
   session.server('ServerQueue', timeout) do |server|
-    puts "Waiting for Requests..."  
+    puts "Waiting for Requests..."
     server.run do |request_message|
       puts "Received:[#{request_message.inspect}]"
-    
+
       # Create Reply Message
       reply_message = session.create_message(HornetQ::Client::Message::TEXT_TYPE, false)
       reply_message.body = "Echo [#{request_message.body}]"
-    
+
       # The result of this block is the message to be sent back to the requestor (client)
       # Or, nil if no response should be sent back
       reply_message
     end
   end
-  
+
 end

data/examples/producer-consumer/consume_all.rb

@@ -11,10 +11,10 @@ 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) do |message|
     p message

data/examples/producer-consumer/consume_on_message.rb

@@ -15,12 +15,12 @@ session_count = (ARGV[1] || 1).to_i
 
 # Using Connect.start since a session must be started in order to consume messages
 HornetQ::Client::Connection.connection('hornetq://localhost') do |connection|
-  
+
   # Create a non-durable TestQueue to receive messages sent to the TestAddress
   connection.session do |session|
     session.create_queue_ignore_exists('TestAddress', 'TestQueue', false)
   end
-  
+
   # Consume All messages from the queue and gather statistics
   # on_message will call the supplied block for every message received in another
   # thread. As a result, the on_message call returns immediately!
@@ -28,18 +28,18 @@ HornetQ::Client::Connection.connection('hornetq://localhost') do |connection|
   #
   # :session_count can be used to spawn multiple consumers simultaneously, each
   # receiving messages simultaneously on their own threads
-  connection.on_message(:queue_name    => 'TestQueue', 
+  connection.on_message(:queue_name    => 'TestQueue',
                         :session_count => session_count,
                         :statistics    => true) do |message|
     p message
     puts "=================================="
     message.acknowledge
   end
-  
+
   puts "Started #{session_count} consumers, will wait for #{sleep_time/1000} seconds before shutting down"
   # Wait for sleep_time before shutting down the server
   sleep(sleep_time/1000)
-  
+
   connection.on_message_statistics.each do |stats|
     puts "Received #{stats[:count]} messages in #{stats[:duration]} seconds at #{stats[:messages_per_second]} messages per second"
   end

data/examples/producer-consumer/consumer.rb

@@ -11,10 +11,10 @@ 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 the non-durable TestQueue to receive messages sent to the TestAddress
   session.create_queue_ignore_exists('TestAddress', 'TestQueue', false)
-  
+
   session.consumer('TestQueue') do |consumer|
     # Receive a single message, return immediately if no message available
     if message = consumer.receive_immediate

data/examples/producer-consumer/producer.rb

@@ -14,7 +14,7 @@ require 'hornetq'
 HornetQ::Client::Connection.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)
-  
+
   # Using the Producer pattern send messages to the Address 'TestAddress'
   session.producer('TestAddress') do |producer|
     # Create a non-durable message
@@ -24,9 +24,9 @@ HornetQ::Client::Connection.session('hornetq://localhost') do |session|
     # Always set the message type prior to setting the body so that the message
     # is correctly created for you
     message.body = "#{Time.now}: ### Hello, World ###"
-  
+
     producer.send(message)
-    
+
     puts "Sent Message: #{message.inspect}"
   end
 end

data/examples/resque/hornetq_job.rb

@@ -13,12 +13,12 @@ require 'sync'
 # batch files. Rather than just flood the queue with every record from a file
 # the Batch Client Pattern can be used to only send out a batch of requests at
 # a time and when sufficient responses have been received, send another batch.
-# 
+#
 # The following additional features can be implemented in this pattern
 # * Stop the batch if say 80% of records fail in the first batch, etc.
 # * Support pause and resume of batch processing
 # * Support restart and recoverability
-# 
+#
 # See the Resque example for implementations of some of the above capabilities
 #
 class BatchClientPattern
@@ -33,11 +33,11 @@ class BatchClientPattern
     @consumer = session.create_consumer(reply_queue)
     @session = session
     session.start
-    
+
     @counter_sync = Sync.new
     @processed = 0
   end
-  
+
   # Before re-using a batch pattern, reset all internal counters
   def reset
     @counter_sync.synchronize(:EX) do
@@ -45,12 +45,12 @@ class BatchClientPattern
       @sucessful = 0
     end
   end
-  
+
   # Return the current message count
   def processed
     @counter_sync.synchronize(:SH) { @sucessful + @processed }
   end
-  
+
   # Increment Successful response counter by supplied count
   def inc_sucessful(count=1)
     @counter_sync.synchronize(:EX) { @sucessful += count }
@@ -60,7 +60,7 @@ class BatchClientPattern
   def sucessful
     @counter_sync.synchronize(:SH) { @sucessful }
   end
-  
+
   # Increment Successful response counter by supplied count
   def inc_failed(count=1)
     @counter_sync.synchronize(:EX) { @failed += count }
@@ -70,7 +70,7 @@ class BatchClientPattern
   def failed
     @counter_sync.synchronize(:SH) { @failed }
   end
-  
+
   # Send x messages
   def send(total_count)
     #print "Sending #{total_count} messages"
@@ -86,7 +86,7 @@ class BatchClientPattern
     duration = Time.now - start_time
     #printf "\nSend %5d msg, %5.2f s, %10.2f msg/s\n", total_count, duration, total_count/duration
   end
-  
+
   # Receive Reply messages calling the supplied block for each message
   # passing in the message received from the server.
   # After the block returns, the message is automatically acknowledged
@@ -102,7 +102,7 @@ class BatchClientPattern
       p exc
     end
   end
-  
+
   def close
     @producer.close
     @consumer.close
@@ -116,7 +116,7 @@ end
 # Create a Resque Job with the ability to report status
 #
 class HornetQJob < Resque::JobWithStatus
-  
+
   # Set the name of the queue to use for this Job Worker
   @queue = "hornetq_job"
 
@@ -126,14 +126,14 @@ class HornetQJob < Resque::JobWithStatus
     batching_size  = (options['batching_size'] || 80).to_i
     address        = options['address'] || 'processor'
     receive_thread = nil
-    
+
     # Create a HornetQ session
     count = 0
     HornetQ::Client::Connection.session('hornetq://localhost') do |session|
       batching_size = total_count if batching_size > total_count
-  
+
       client = BatchClient.new(session, address)
-  
+
       # Start receive thread
       receive_thread = Thread.new do
         client.receive do |message|
@@ -141,7 +141,7 @@ class HornetQJob < Resque::JobWithStatus
           client.inc_sucessful
         end
       end
-  
+
       times = (total_count/batching_size).to_i
       puts "Performing #{times} loops"
       times.times do |i|
@@ -156,11 +156,11 @@ class HornetQJob < Resque::JobWithStatus
           #puts "\nReceived #{received_count} messages"
           if received_count >= 0.8 * count
             puts ""
-            break 
+            break
           end
         end
       end
-  
+
       while client.counter < total_count
         sleep 0.1
         print "*"
@@ -177,7 +177,7 @@ end
 if __FILE__ == $0
   # Make sure you have a worker running
   # jruby resque_worker.rb
-  
+
   options = {
     'total_count' => (ARGV[0] || 4000).to_i,
     'batching_size' => (ARGV[1] || 40).to_i,
@@ -187,7 +187,7 @@ if __FILE__ == $0
   puts "Creating the HornetQJob"
   job_id = HornetQJob.create(options)
   puts "Got back #{job_id}"
-  
+
   # check the status until its complete
   while status = Resque::Status.get(job_id) and !status.completed? && !status.failed? &&!status.killed?
     sleep 1