jruby-hornetq 0.2.5.alpha → 0.3.0.alpha

data/HISTORY.md

@@ -1,3 +1,15 @@
+## 0.3.0 (2011-02-16)
+
+* Rename HornetQ::Client::Factory to HornetQ::Client::Connection
+* Add Client Tests
+* Fix logging to HornetQ default logger when no other logger supplied
+* Re-arrange Examples
+* Add Worker samples
+
+## 0.2.5 (2011-02-07)
+
+* Add Rails and Ruby Logging
+
 ## 0.2.1 (2011-01-26)
 
 * Support for InVM Server

data/Rakefile

@@ -1,6 +1,7 @@
 raise "jruby-hornetq must be built with JRuby: try again with `jruby -S rake'" unless defined?(JRUBY_VERSION)
 
 require 'rake/clean'
+require 'rake/testtask'
 require 'date'
 require 'java'
 
@@ -8,7 +9,7 @@ desc "Build gem"
 task :gem  do |t|
   gemspec = Gem::Specification.new do |s|
     s.name = 'jruby-hornetq'
-    s.version = '0.2.5.alpha'
+    s.version = '0.3.0.alpha'
     s.authors = ['Reid Morrison', 'Brad Pardee']
     s.email = ['rubywmq@gmail.com', 'bpardee@gmail.com']
     s.homepage = 'https://github.com/ClarityServices/jruby-hornetq'
@@ -17,7 +18,18 @@ task :gem  do |t|
     s.summary = 'JRuby interface into HornetQ'
     s.files = FileList["./**/*"].exclude('*.gem', './nbproject/*').map{|f| f.sub(/^\.\//, '')}
     s.has_rdoc = true
+    s.executables = %w(hornetq_server)
     s.add_dependency "gene_pool", "~> 1.1.1"
   end
   Gem::Builder.new(gemspec).build
 end
+
+desc "Run Test Suite"
+task :test do
+  Rake::TestTask.new(:functional) do |t|
+    t.test_files = FileList['test/*_test.rb']
+    t.verbose    = true
+  end
+
+  Rake::Task['functional'].invoke
+end

data/bin/hornetq_server

@@ -32,10 +32,10 @@ if ARGV[0] =~ /\.ya?ml$/
     config = config[ARGV[i]] || config[ARGV[i].to_sym]
   end
   puts "config=#{config.inspect}"
-  server = HornetQ::Server::Factory.create_server(config)
+  server = HornetQ::Server.create_server(config)
 else
   uri = ARGV[0]
-  server = HornetQ::Server::Factory.create_server(uri)
+  server = HornetQ::Server.create_server(uri)
 end
 server.enable_shutdown_on_signal
 server.start

data/examples/README

@@ -0,0 +1,6 @@
+Most of the examples will run in-place without requiring a gem install.  However,
+to start the hornetq_server you must set the following environment variables
+adjusting the value of jruby-hornetq-home as necessary.
+
+export RUBYLIB=<jruby-hornetq-home>/lib
+export PATH=<jruby-hornetq-home>/bin:$PATH

data/examples/{client/advanced → advanced}/batch_client.rb

@@ -12,7 +12,7 @@
 # Once 80% of the replies are back, it will send the next batch
 
 # 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 'yaml'
@@ -21,25 +21,21 @@ require 'sync'
 
 total_count = (ARGV[0] || 100).to_i
 batching_size = (ARGV[1] || 10).to_i
-request_address = 'jms.queue.ExampleQueue'
 
+request_address = 'ServerAddress'
 config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
 
 class BatchClientPattern
-  def initialize(session, request_address)
-    @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
-    end
-    @consumer = session.create_consumer(reply_queue)
-    @session = session
-    session.start
-    
+  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
@@ -63,7 +59,7 @@ class BatchClientPattern
     start_time = Time.now
     total_count.times do |i|
       message = @session.create_message(HornetQ::Client::Message::TEXT_TYPE,true)
-      message.reply_to_queue_name = @consumer.queue_name
+      message.reply_to_queue_name = @reply_queue
       message.body = "Request Current Time. #{i}"
       @producer.send(message)
       print "."
@@ -74,35 +70,23 @@ class BatchClientPattern
   end
   
   # Receive Reply messages
-  def receive
-    print "Receiving messages"
-    begin
-      while reply = @consumer.receive
-        print '@'
-        #        puts "Received:#{reply}, [#{reply.body}]"
-        inc_counter(1)
-        reply.acknowledge
-      end
-    rescue Exception => exc
-      p exc
-    end
+  def process_reply(message)
+    print '@'
+    inc_counter(1)
+    message.acknowledge
   end
   
   def close
     @producer.close
-    @consumer.close
-    @session.delete_queue(@consumer.queue_name)
+    @session.close
   end
 end
 
 # Create a HornetQ session
-HornetQ::Client::Factory.session(config) do |session|
+HornetQ::Client::Connection.connection(config[:connection]) do |connection|
   batching_size = total_count if batching_size > total_count
   
-  client = BatchClientPattern.new(session, request_address)
-  
-  # Start receive thread
-  receive_thread = Thread.new {client.receive}
+  client = BatchClientPattern.new(connection, request_address)
   
   times = (total_count/batching_size).to_i
   puts "Performing #{times} loops"

data/examples/advanced/bytes_producer.rb

@@ -0,0 +1,25 @@
+#
+# HornetQ Producer:
+#          Write binary/bytes 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'
+
+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

@@ -0,0 +1,56 @@
+#
+# 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 
+#      program will eventually timeout
+#      Displays a '.' for every request completed
+#      Used for performance measurements
+#
+
+# 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
+timeout = (ARGV[1] || 30000).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)
+  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 #{count} requests"
+    (1..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 "Received Response: #{reply.inspect}" if count < 10
+        puts "  Message:[#{reply.body.inspect}]" if count < 10
+        print "." if count >= 10
+      else
+        puts "Time out, No reply received after #{timeout/1000} seconds"
+      end
+      puts "#{i}" if i%1000 == 0
+  
+    end
+  end
+
+  duration = Time.now - start_time
+  puts "\nMade #{count} calls in #{duration} seconds at #{count/duration} synchronous requests per second"
+end

data/examples/{client/advanced/multi_client.rb → advanced/client_session_pooling.rb}

@@ -1,21 +1,22 @@
 #
-# HornetQ Requestor:
-#      Multithreaded clients all doing requests
+# HornetQ Requestor using session_pooling:
+#      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
 #
-# Shows how to use the session pool so that not every thread has to have its
-# own session
-#
 
 # 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 'yaml'
 require 'hornetq'
 
-$thread_count = (ARGV[0] || 1).to_i
+$thread_count = (ARGV[0] || 2).to_i
 $timeout = (ARGV[1] || 30000).to_i
 
 config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
@@ -24,10 +25,10 @@ config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
 def worker_thread(id, session_pool)
   begin
     # Obtain a session from the pool and return when complete
-    session_pool.requestor('jms.queue.ExampleQueue') do |session, requestor|
+    session_pool.requestor('ServerAddress') do |session, requestor|
       message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
       message.body = "Request Current Time"
-    
+
       # Send message to the queue
       puts "Thread[#{id}]: Sending Request"
       if reply = requestor.request(message, $timeout)
@@ -44,23 +45,26 @@ def worker_thread(id, session_pool)
   puts "Thread[#{id}]: Complete"
 end
 
-# Create a HornetQ Factory 
-HornetQ::Client::Factory.create_factory(config[:connector]) do |factory|
-  
+# Create a HornetQ Connection
+HornetQ::Client::Connection.connection(config[:connection]) do |connection|
+
   # Create a pool of session connections, all with the same session parameters
   # The pool is thread-safe and can be accessed concurrently by multiple threads
-  session_pool = factory.create_session_pool(config[:session])
-  threads = []
-  
-  # Do some work and then lets re-use the session in another thread below
-  worker_thread(9999, session_pool) 
-  
-  $thread_count.times do |i|
-    # Each thread will get a session from the session pool as needed
-    threads << Thread.new { worker_thread(i, session_pool) }
+  begin
+    session_pool = connection.create_session_pool(config[:session])
+    threads = []
+
+    # Do some work and then lets re-use the session in another thread below
+    worker_thread(9999, session_pool)
+
+    $thread_count.times do |i|
+      # Each thread will get a session from the session pool as needed
+      threads << Thread.new { worker_thread(i, session_pool) }
+    end
+    threads.each {|t| t.join}
+
+    # Important. Remember to close any open sessions in the pool
+  ensure
+    session_pool.close if session_pool
   end
-  threads.each {|t| t.join}
-  
-  # Important. Remember to close any open sessions in the pool
-  session_pool.close
 end

data/examples/advanced/consume_on_message.rb

@@ -0,0 +1,50 @@
+#
+# HornetQ Consumer:
+#          Use Connection::on_message to consume all messages in separate
+#          threads so as not to block the main thread
+#          Displays a '.' for every message received
+#          Used for performance measurements of consuming messages
+#
+
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+
+require 'yaml'
+require 'rubygems'
+require 'hornetq'
+
+sleep_time = (ARGV[0] || 60000).to_i
+session_count = (ARGV[1] || 1).to_i
+
+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!
+  # 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|
+    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
+end

data/examples/advanced/consumer.rb

@@ -0,0 +1,31 @@
+#
+# HornetQ Consumer:
+#          Consume all messages from the queue: TestQueue in the current thread
+#          Displays a '.' for every message received
+#          Used for performance measurements of consuming messages
+#
+
+# 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] || 1000).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 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 '.'
+    message.acknowledge
+  end
+  puts "Received #{stats[:count]} messages in #{stats[:duration]} seconds at #{stats[:messages_per_second]} messages per second"
+end

data/examples/{client/advanced → advanced}/hornetq.yml

@@ -1,10 +1,9 @@
 ---
 development:
-  :connector:
-    :uri: hornetq://localhost,192.168.0.22
+  :connection:
+    :uri: hornetq://localhost
     :failover_on_initial_connection: true
     :failover_on_server_shutdown: true
-    # 5 Connection attempts takes about 16 seconds before it switches to the backup server
     :reconnect_attempts: 5
   :session:
     :username: guest
@@ -12,11 +11,14 @@ development:
     
 # Example configuration showing all possible options and their default values if available
 full_example:
-  :connector:
+  :connection:
     # The uri is written as follows for the NettyConnectorFactory.
-    #   protocol=netty is the default and therefore not required
     :uri: hornetq://localhost:5445,backuphost:5445/?protocol=netty
-    # Or, the uri is written as follows for the InVM
+    # protocol=netty is the default and therefore not required
+    :uri: hornetq://localhost:5445,backuphost:5445
+    # And since the default port is 5445
+    :uri: hornetq://localhost,backuphost
+    # Or, the uri is written as follows for InVM
     :uri: hornetq://invm
     # Or, the uri is written as follows for auto-discovery
     :uri: hornetq://discoveryhost:5445/?protocol=discovery