jruby-hornetq 0.2.5.alpha → 0.3.0.alpha

data/examples/advanced/multi_client.rb

@@ -0,0 +1,71 @@
+#
+# HornetQ Requestor:
+#      Multithreaded clients all doing requests
+#
+
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+
+require 'rubygems'
+require 'yaml'
+require 'hornetq'
+
+timeout = (ARGV[0] || 30000).to_i
+thread_count = (ARGV[1] || 2).to_i
+request_count = (ARGV[2] || 5).to_i
+
+config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
+
+# Sample thread that does some work and then does a request-response call
+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
+      session.requestor('ServerAddress') do |requestor|
+        # Create non-durable message
+        puts "Sending #{request_count} requests"
+        (1..request_count).each do |i|
+          message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
+          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
+            print ".#{id}" if request_count >= 10
+          else
+            puts "Thread[#{id}]:Time out, No reply received after #{timeout/1000} seconds"
+          end
+          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
+
+  rescue Exception => exc
+    puts "Thread[#{id}]: Terminating due to Exception:#{exc.inspect}"
+    puts exc.backtrace
+  end
+  puts "Thread[#{id}]: Complete"
+end
+
+# Create a HornetQ Connection
+HornetQ::Client::Connection.connection(config[:connection]) do |connection|
+  threads = []
+
+  # Start threads passing in an id and the connection so that the thread
+  # can create its own session
+  thread_count.times do |i|
+    threads << Thread.new { worker_thread(i, connection, timeout, request_count) }
+  end
+  # Since each thread will terminate once it has completed its required number
+  # of requests, we can just wait for all the threads to terminate
+  threads.each {|t| t.join}
+end

data/examples/advanced/producer.rb

@@ -0,0 +1,37 @@
+#
+# HornetQ Producer:
+#          Write messages to the queue
+#          This example will display the message count after every 1000
+#          messages written to the address
+#
+
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+
+require 'rubygems'
+require 'yaml'
+require 'hornetq'
+
+count = (ARGV[0] || 1).to_i
+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)
+  start_time = Time.now
+  
+  session.producer('TestAddress') 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 ###"
+      
+      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

@@ -0,0 +1,44 @@
+#
+# HornetQ Consumer:
+#      Reply to a request
+#
+
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../../lib'
+
+require 'rubygems'
+require 'yaml'
+require 'hornetq'
+
+timeout = (ARGV[0] || 60000).to_i
+
+config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
+
+# Create a HornetQ session
+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)
+
+  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

@@ -0,0 +1,40 @@
+#
+# 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 
+#      program will eventually timeout
+#
+
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+
+require 'rubygems'
+require 'hornetq'
+
+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)
+
+  # 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
+  session.requestor('ServerAddress') do |requestor|
+    # 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)
+      puts "Received Response: #{reply.inspect}"
+    else
+      puts "Time out, No reply received after #{timeout/1000} seconds"
+    end
+  
+  end
+end

data/examples/client-server/server.rb

@@ -0,0 +1,37 @@
+#
+# HornetQ Consumer:
+#      Reply to a request
+#      Implements the Server Pattern
+#      The reply message is sent back to the reply to address supplied by the
+#      requestor
+#
+
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+
+require 'rubygems'
+require 'hornetq'
+
+# By default the server will shutdown after 60 seconds, set to 0 to never shutdown
+timeout = (ARGV[0] || 60000).to_i
+
+HornetQ::Client::Connection.start_session(:connection=> {:uri => 'hornetq://localhost'}) do |session|
+  # Create a non-durable ServerQueue to receive messages sent to the ServerAddress
+  session.create_queue_ignore_exists('ServerAddress', 'ServerQueue', false)
+
+  session.server('ServerQueue', timeout) do |server|
+    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

@@ -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) do |message|
+    p message
+    puts "=================================="
+    message.acknowledge
+  end
+  puts "Received #{stats[:count]} messages in #{stats[:duration]} seconds at #{stats[:messages_per_second]} messages per second"
+end

data/examples/producer-consumer/consume_on_message.rb

@@ -0,0 +1,46 @@
+#
+# HornetQ Consumer:
+#          Use Connection::on_message to consume all messages in separate
+#          threads so as not to block the main thread
+#
+
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+
+require 'rubygems'
+require 'hornetq'
+
+sleep_time = (ARGV[0] || 60000).to_i
+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!
+  # Other work can be performed on this thread, or just a sleep as in this example
+  #
+  # :session_count can be used to spawn multiple consumers simultaneously, each
+  # receiving messages simultaneously on their own threads
+  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
+end

data/examples/producer-consumer/consumer.rb

@@ -0,0 +1,27 @@
+#
+# 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 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
+      puts "Received:[#{message.body}]"
+      message.acknowledge
+    else
+      puts "No message found"
+    end
+  end
+end

data/examples/producer-consumer/producer.rb

@@ -0,0 +1,32 @@
+#
+# HornetQ Producer:
+#          Write messages to 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.session since a session does not have to be started in order
+# to produce messages
+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
+    message = session.create_message(false)
+    # Mark message as text
+    message.type_sym = :text
+    # 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/{client/resque → resque}/hornetq_job.rb

@@ -1,5 +1,5 @@
 # Allow examples to be run in-place without requiring a gem install
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../../lib'
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
 
 require 'rubygems'
 require 'resque/job_with_status' # in rails you would probably do this in an initializer
@@ -129,7 +129,7 @@ class HornetQJob < Resque::JobWithStatus
     
     # Create a HornetQ session
     count = 0
-    HornetQ::Client::Factory.session('hornetq://localhost') do |session|
+    HornetQ::Client::Connection.session('hornetq://localhost') do |session|
       batching_size = total_count if batching_size > total_count
   
       client = BatchClient.new(session, address)

data/examples/{client/resque → resque}/processor.rb

@@ -14,7 +14,7 @@ timeout = (ARGV[0] || 300000).to_i
 
 q_name = 'processor'
 
-HornetQ::Client::Factory.start('hornetq://localhost') do |session|
+HornetQ::Client::Connection.start_session('hornetq://localhost') do |session|
   begin
     # Create durable queue with matching address
     session.create_queue(q_name, q_name, true)

data/examples/{client → simple}/invm.rb

@@ -10,23 +10,22 @@ require 'rubygems'
 require 'hornetq'
 
 # Create and start an InVM HornetQ server instance
-HornetQ::Server::Factory.start('hornetq://invm') do |server|
+HornetQ::Server.start('hornetq://invm') do |server|
   # Allow a CTRL-C to stop this process
   server.enable_shutdown_on_signal
 
-  HornetQ::Client::Factory.start('hornetq://invm') do |session|
+  HornetQ::Client::Connection.start_session('hornetq://invm') do |session|
     session.create_queue("MyAddress","MyQueue", nil, false)
-  
+
     producer = session.create_producer('MyAddress')
     consumer = session.create_consumer('MyQueue')
-  
+
     # Create a non-durable message to send
     message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
     message.body = "#{Time.now}: ### Hello, World ###"
-  
+
     producer.send(message)
-  
-  
+
     # Receive a single message, return immediately if no message available
     if message = consumer.receive_immediate
       puts "Received:[#{message.body}]"