jruby-hornetq 0.2.0.alpha → 0.2.1.alpha

data/HISTORY.md

@@ -1,4 +1,12 @@
+## 0.2.1 (2011-01-26)
 
+* Support for InVM Server
+* InVM Example
+
+## 0.2.0 (2011-01-19)
+
+* New Namespace HornetQ::Server and HornetQ::Client
+* Improved Examples
 
 ## 0.0.1 (2011-01-18)
 

data/README.md

@@ -111,14 +111,96 @@ Producer-Consumer
 
 Producer: Write messages to a queue:
 
-  ....
+    require 'rubygems'
+    require 'hornetq'
+    
+    HornetQ::Client::Factory.create_session(:connector=> {: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')
+      
+      # Create a non-durable message to send
+      message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
+      message << "#{Time.now}: ### Hello, World ###"
+      
+      producer.send(message)
+    end
+
 
 Consumer: Read message from a queue: 
-  ....
+
+    require 'rubygems'
+    require 'hornetq'
+    
+    HornetQ::Client::Factory.start(:connector=> {:uri => 'hornetq://localhost'}) do |session|
+      consumer = session.create_consumer('jms.queue.ExampleQueue')
+      
+      # 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
 
 Client-Server
 -------------
 
+Server: Receive requests and send back a reply
+
+    require 'rubygems'
+    require 'hornetq'
+    
+    # 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|
+      server = session.create_server('jms.queue.ExampleQueue', timeout)
+    
+      puts "Waiting for Requests..."  
+      server.run do |request_message|
+        puts "Received:[#{request_message.body}]"
+        
+        # Create Reply Message
+        reply_message = session.create_message(HornetQ::Client::Message::TEXT_TYPE, false)
+        reply_message.body = "Echo [#{request_message.body}]"
+        
+        # The result of the block is the message to be sent back to the client
+        reply_message
+      end
+    
+      # Server will stop after timeout period after no messages received
+      server.close
+    end
+
+
+Client: Send a request and wait for a reply
+
+    require 'rubygems'
+    require 'hornetq'
+    
+    # Wait 5 seconds for a reply
+    timeout = 5000
+    
+    HornetQ::Client::Factory.start(:connector=> {:uri => 'hornetq://localhost'}) do |session|
+      requestor = session.create_requestor('jms.queue.ExampleQueue')
+    
+      # Create non-durable message
+      message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
+      message.body = "Request Current Time"
+      
+      # Send message to the queue
+      puts "Send request message and wait for Reply"
+      if reply = requestor.request(message, timeout)
+        puts "Received Response: #{reply.inspect}"
+        puts "  Message: #{reply.body.inspect}"
+      else
+        puts "Time out, No reply received after #{timeout/1000} seconds"
+      end
+      
+      requestor.close
+    end
+
 
 Threading
 ---------
@@ -164,12 +246,12 @@ client, it also supports using JRuby to launch a Broker instance
 
 #### Starting up a standalone hornetq server:
 
-  bin/hornetq_server examples/standalone_server.yml
+  bin/hornetq_server examples/server/standalone_server.yml
 
 #### Starting up a backup/live combination
 
-  bin/hornetq_server examples/backup_server.yml
-  bin/hornetq_server examples/live_server.yml
+  bin/hornetq_server examples/server/backup_server.yml
+  bin/hornetq_server examples/server/live_server.yml
 
 Development
 -----------
@@ -222,6 +304,7 @@ Authors
 -------
 
 Reid Morrison :: rubywmq@gmail.com :: @reidmorrison
+
 Brad Pardee :: bpardee@gmail.com
 
 [1]: http://help.github.com/forking/

data/Rakefile

@@ -8,10 +8,10 @@ desc "Build gem"
 task :gem  do |t|
   gemspec = Gem::Specification.new do |s|
     s.name = 'jruby-hornetq'
-    s.version = '0.2.0.alpha'
-    s.author = 'Reid Morrison'
-    s.email = 'rubywmq@gmail.com'
-    s.homepage = 'http://www.reidmorrison.com/'
+    s.version = '0.2.1.alpha'
+    s.authors = ['Reid Morrison', 'Brad Pardee']
+    s.email = ['rubywmq@gmail.com', 'bpardee@gmail.com']
+    s.homepage = 'https://github.com/ClarityServices/jruby-hornetq'
     s.date = Date.today.to_s
     s.description = 'JRuby-HornetQ is a Java and Ruby library that exposes the HornetQ Java API in a ruby friendly way. For JRuby only.'
     s.summary = 'JRuby interface into HornetQ'

data/bin/hornetq_server

@@ -1,70 +1,41 @@
 #!/usr/bin/env jruby
 
+require 'rubygems'
 require 'yaml'
-
-raise 'Environment variable HORNETQ_HOME not set' unless ENV['HORNETQ_HOME']
-require "#{ENV['HORNETQ_HOME']}/lib/hornetq-core.jar"
-require "#{ENV['HORNETQ_HOME']}/lib/netty.jar"
+require 'hornetq'
 
 unless ARGV[0]
-  $stderr.puts "Usage: hornetq_server <yml-file>"
-  exit 1
-end
-yaml = YAML.load_file(ARGV[0])
-data_directory = yaml['data_directory'] || './data'
-host = yaml['host'] || 'localhost'
-port = yaml['port'] || 5445
+  $stderr.puts <<EOF
 
-config = Java::org.hornetq.core.config.impl.ConfigurationImpl.new
-config.persistence_enabled = false
-config.security_enabled = false
-config.paging_directory = "#{data_directory}/paging"
-config.bindings_directory = "#{data_directory}/bindings"
-config.journal_directory = "#{data_directory}/journal"
-config.journal_min_files = 10
-config.large_messages_directory = "#{data_directory}/large-messages"
+Usage: hornetq_server <uri-or-yml-file>
 
-if Java::org.hornetq.core.journal.impl.AIOSequentialFileFactory.isSupported
-  config.journal_type = Java::org.hornetq.core.server.JournalType::ASYNCIO
-else
-  puts("AIO wasn't located on this platform, it will fall back to using pure Java NIO. If your platform is Linux, install LibAIO to enable the AIO journal");
-  config.journal_type = Java::org.hornetq.core.server.JournalType::NIO
-end
+  Examples:
 
-netty_acceptor_class_name = Java::org.hornetq.core.remoting.impl.netty.NettyAcceptorFactory.java_class.name
-netty_connector_class_name = Java::org.hornetq.core.remoting.impl.netty.NettyConnectorFactory.java_class.name
+    # start standalone server on port #{HornetQ::DEFAULT_NETTY_PORT}
+    hornetq_server hornetq://0.0.0.0/?data_directory=./data
 
-transport_conf_params = java.util.HashMap.new
-transport_conf_params.put('host', host)
-transport_conf_params.put('port', java.lang.Integer.new(port))
-transport_conf = Java::org.hornetq.api.core.TransportConfiguration.new(netty_acceptor_class_name, transport_conf_params);
+    # start backup server
+    hornetq_server hornetq://0.0.0.0:5446/?backup=true\\&data_directory=./data_backup
 
-transport_conf_set = java.util.HashSet.new
-transport_conf_set.add(transport_conf)
+    # start live server attached to backup on same server
+    hornetq_server hornetq://0.0.0.0:5445,localhost:5446/?data_directory=./data
 
-config.acceptor_configurations = transport_conf_set
+EOF
+  exit 1
+end
 
-if yaml['backup']
-  puts "backup"
-  config.backup = true
-  config.shared_store = false
-elsif yaml['backup_host']
-  puts "live"
-  backup_params = java.util.HashMap.new
-  backup_params.put('host', yaml['backup_host'])
-  backup_port = yaml['backup_port'] || 5445
-  backup_params.put('port', java.lang.Integer.new(backup_port))
-  #backup_params.put('reconnectAttempts', -1)
-  backup_connector_conf = Java::org.hornetq.api.core.TransportConfiguration.new(netty_connector_class_name, backup_params);
-  
-  connector_conf_map = java.util.HashMap.new
-  connector_conf_map.put('backup-connector', backup_connector_conf)
-  
-  config.connector_configurations = connector_conf_map
-  config.backup_connector_name = 'backup-connector'
+# Check if the argument is a yaml file or a uri
+if ARGV[0] =~ /\.ya?ml$/
+  config = YAML.load_file(ARGV[0])
+  # Allow sub items
+  (1...ARGV.size).each do |i|
+    config = config[ARGV[i]] || config[ARGV[i].to_sym]
+  end
+  puts "config=#{config.inspect}"
+  server = HornetQ::Server::Factory.create_server(config)
 else
-  puts 'standalone'
+  uri = ARGV[0]
+  server = HornetQ::Server::Factory.create_server(uri)
 end
-
-server = Java::org.hornetq.core.server.HornetQServers.newHornetQServer(config)
+server.enable_shutdown_on_signal
 server.start

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

@@ -2,9 +2,17 @@
 # HornetQ Batch Requestor:
 #      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
 
 # 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'
@@ -13,7 +21,6 @@ require 'sync'
 
 total_count = (ARGV[0] || 100).to_i
 batching_size = (ARGV[1] || 10).to_i
-timeout = (ARGV[2] || 10000).to_i
 request_address = 'jms.queue.ExampleQueue'
 
 config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
@@ -55,7 +62,7 @@ class BatchClient
     #print "Sending #{total_count} messages"
     start_time = Time.now
     total_count.times do |i|
-      message = @session.create_message(HornetQClient::Message::TEXT_TYPE,false)
+      message = @session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
       message.reply_to_queue_name = @consumer.queue_name
       message << "Request Current Time. #{i}"
       @producer.send(message)
@@ -89,7 +96,7 @@ class BatchClient
 end
 
 # Create a HornetQ session
-HornetQClient::Factory.create_session(config) do |session|
+HornetQ::Client::Factory.create_session(config) do |session|
   batching_size = total_count if batching_size > total_count
   
   client = BatchClient.new(session, request_address)

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

@@ -4,7 +4,7 @@
 #
 
 # 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'
@@ -16,29 +16,27 @@ timeout = (ARGV[1] || 30000).to_i
 config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
 
 # Create a HornetQ session
-HornetQClient::Factory.create_session(config) do |session|
+HornetQ::Client::Factory.create_session(config) do |session|
   #session.create_queue('Example', 'Example', true)
   requestor = session.create_requestor('jms.queue.ExampleQueue')
   session.start
   start_time = Time.now
 
   puts "Sending messages"
-  count.times do |i|
-    message = session.create_message(HornetQClient::Message::TEXT_TYPE,false)
+  (1..count).each do |i|
+    message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
     # Set the message body text
     message << "Request Current Time"
     # Set the user managed message id
     message.user_id = Java::org.hornetq.utils::UUIDGenerator.getInstance.generateUUID
-    # Send message to the queue
-    puts "Sending Request"
+    # Send request message and wait for reply
     if reply = requestor.request(message, timeout)
-      puts "Received Response: #{reply.inspect}"
-      puts "  Message:[#{reply.body.inspect}]"
-      #print "."
+      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
-    #p message
     puts "#{i}" if i%1000 == 0
     puts "Durable" if message.durable
   end

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

@@ -4,7 +4,7 @@
 #
 
 # 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'
@@ -15,7 +15,7 @@ timeout = (ARGV[0] || 1000).to_i
 config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
 
 # Create a HornetQ session
-HornetQClient::Factory.create_session(config) do |session|
+HornetQ::Client::Factory.create_session(config) do |session|
   consumer = session.create_consumer('jms.queue.ExampleQueue')
   session.start
   

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

@@ -15,22 +15,23 @@ full_example:
   :connector:
     # The uri is written as follows for the NettyConnectorFactory.
     #   protocol=netty is the default and therefore not required
-    :uri: hornetq://localhost:5445,backupserver:5445/?protocol=netty
+    :uri: hornetq://localhost:5445,backuphost:5445/?protocol=netty
     # Or, the uri is written as follows for the InVM
-    :uri: hornetq://localhost/?protocol=invm
+    :uri: hornetq://invm
     # Or, the uri is written as follows for auto-discovery
-    :uri: hornetq://discoveryserver:5445/?protocol=discovery
+    :uri: hornetq://discoveryhost:5445/?protocol=discovery
     
     # For a static cluster list as an array of URI's
     :uri:
-      - netty://server1:5445,server1backup:5445
-      - netty://server2:5445,server2backup:5445
+      - hornetq://server1:5445,server1backup:5445
+      - hornetq://server2:5445,server2backup:5445
     # URI format:
-    #  [netty|invm|discovery]://host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]
-    :options:
-        :failover_on_initial_connection: true
-        :failover_on_server_shutdown: true
-        :reconnect_attempts: -1
+    #  hornetq://host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]
+    #    where options can be any of
+    #      protocol=[netty|invm|discovery]
+    :failover_on_initial_connection: true
+    :failover_on_server_shutdown: true
+    :reconnect_attempts: -1
   :session:
     :username: guest
     :password: guest

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

@@ -4,9 +4,12 @@
 #      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'
@@ -22,7 +25,7 @@ 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|
-      message = session.create_message(HornetQClient::Message::TEXT_TYPE,false)
+      message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
       message << "Request Current Time"
     
       # Send message to the queue
@@ -42,7 +45,7 @@ def worker_thread(id, session_pool)
 end
 
 # Create a HornetQ Factory 
-HornetQClient::Factory.create_factory(config[:connector]) do |factory|
+HornetQ::Client::Factory.create_factory(config[:connector]) do |factory|
   
   # 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

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

@@ -4,7 +4,7 @@
 #
 
 # 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'
@@ -44,7 +44,7 @@ def worker(id, session)
 end
 
 # Create a HornetQ session
-HornetQClient::Factory.create_factory(config[:connector]) do |factory|
+HornetQ::Client::Factory.create_factory(config[:connector]) do |factory|
   threads = []
   $thread_count.times do |i|
     session = factory.create_session(config[:session])

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

@@ -4,7 +4,7 @@
 #
 
 # 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'
@@ -14,14 +14,13 @@ count = (ARGV[0] || 1).to_i
 config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
 
 # Create a HornetQ session
-HornetQClient::Factory.create_session(config) do |session|
-  #session.create_queue('Example', 'Example', true)
+HornetQ::Client::Factory.create_session(config) do |session|
   producer = session.create_producer('jms.queue.ExampleQueue')
   start_time = Time.now
 
   puts "Sending messages"
   (1..count).each do |i|
-    message = session.create_message(HornetQClient::Message::TEXT_TYPE,false)
+    message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
     # Set the message body text
     message << "#{Time.now}: ### Hello, World ###"
     # Send message to the queue