jruby-hornetq 0.2.0.alpha

data/examples/client.rb

@@ -0,0 +1,49 @@
+#
+# HornetQ Requestor:
+#      Submit a request and wait for a reply
+#
+
+# 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
+HornetQClient::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)
+    # 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"
+    if reply = requestor.request(message, timeout)
+      puts "Received Response: #{reply.inspect}"
+      puts "  Message:[#{reply.body.inspect}]"
+      #print "."
+    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
+  
+  requestor.close
+  duration = Time.now - start_time
+  puts "\nMade #{count} calls in #{duration} seconds at #{count/duration} messages per second"
+end

data/examples/consumer.rb

@@ -0,0 +1,35 @@
+#
+# HornetQ Consumer:
+#          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 'yaml'
+require 'hornetq'
+
+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|
+  consumer = session.create_consumer('jms.queue.ExampleQueue')
+  session.start
+  
+  count = 0
+  start_time = Time.now
+  while message = consumer.receive(timeout)
+    count = count + 1
+    message.acknowledge
+    puts "=================================="
+    text = message.body
+    p text
+    p message
+    puts "Durable" if message.durable
+  end
+  duration = Time.now - start_time - timeout/1000
+  puts "Received #{count} messages in #{duration} seconds at #{count/duration} messages per second"
+end

data/examples/hornetq.yml

@@ -0,0 +1,36 @@
+---
+development:
+  :connector:
+    :uri: hornetq://localhost,192.168.0.22
+    :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
+    :password: guest
+    
+# Example configuration showing all possible options and their default values if available
+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
+    # Or, the uri is written as follows for the InVM
+    :uri: hornetq://localhost/?protocol=invm
+    # Or, the uri is written as follows for auto-discovery
+    :uri: hornetq://discoveryserver: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
+    # 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
+  :session:
+    :username: guest
+    :password: guest

data/examples/live_server.yml

@@ -0,0 +1,5 @@
+data_directory: ../data
+host: 0.0.0.0
+port: 5445
+backup_host: localhost
+backup_port: 5446

data/examples/multi_client.rb

@@ -0,0 +1,63 @@
+#
+# HornetQ Requestor:
+#      Multithreaded clients all doing requests
+#      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
+#
+
+# 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'
+
+$thread_count = (ARGV[0] || 1).to_i
+$timeout = (ARGV[1] || 30000).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, 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 << "Request Current Time"
+    
+      # Send message to the queue
+      puts "Thread[#{id}]: Sending Request"
+      if reply = requestor.request(message, $timeout)
+        puts "Thread[#{id}]: Received Response: #{reply.inspect}"
+        puts "Thread[#{id}]:   Message:[#{reply.body.inspect}]"
+      else
+        puts "Thread[#{id}]: Time out, No reply received after #{$timeout/1000} seconds"
+      end
+    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 Factory 
+HornetQClient::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
+  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) }
+  end
+  threads.each {|t| t.join}
+  
+  # Important. Remember to close any open sessions in the pool
+  session_pool.close
+end

data/examples/multi_consumer.rb

@@ -0,0 +1,54 @@
+#
+# HornetQ Consumer:
+#          Multi-threaded Consumer
+#
+
+# 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'
+
+# Arguments: 'number of threads' 'timeout'
+$thread_count = (ARGV[0] || 3).to_i
+$timeout = (ARGV[1] || 1000).to_i
+
+config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
+
+def worker(id, session)
+  begin
+    consumer = session.create_consumer('jms.queue.ExampleQueue')
+    session.start
+  
+    count = 0
+    start_time = Time.now
+    while message = consumer.receive($timeout)
+      count = count + 1
+      message.acknowledge
+      #puts "=================================="
+      #text = message.body
+      #p text
+      #p message
+      puts "Durable" if message.durable
+      print "#{id}."
+    end
+    duration = Time.now - start_time - $timeout/1000
+    puts "\nReceived #{count} messages in #{duration} seconds at #{count/duration} messages per second"
+  rescue Exception => exc
+    puts "Thread #{id} Terminating"
+    p exc
+  ensure
+    session.close
+  end
+end
+
+# Create a HornetQ session
+HornetQClient::Factory.create_factory(config[:connector]) do |factory|
+  threads = []
+  $thread_count.times do |i|
+    session = factory.create_session(config[:session])
+    threads << Thread.new { worker(i, session) }
+  end
+  threads.each {|t| t.join}
+end

data/examples/producer.rb

@@ -0,0 +1,36 @@
+#
+# 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 'yaml'
+require 'hornetq'
+
+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)
+  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)
+    # Set the message body text
+    message << "#{Time.now}: ### Hello, World ###"
+    # Send message to the queue
+    producer.send(message)
+    #puts message
+    puts "#{i}\n" if i%1000 == 0
+    puts "Durable" if message.durable
+  end
+
+  duration = Time.now - start_time
+  puts "Delivered #{count} messages in #{duration} seconds at #{count/duration} messages per second"
+end

data/examples/run_broker.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env jruby
+
+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"
+
+backup_host = ARGV[0]
+is_backup = backup_host.nil?
+
+config = Java::org.hornetq.core.config.impl.ConfigurationImpl.new
+config.persistence_enabled = false
+config.security_enabled = false
+config.paging_directory = '../data/paging'
+config.bindings_directory = '../data/bindings'
+config.journal_directory = '../data/journal'
+config.journal_min_files = 10
+config.large_messages_directory = '../data/large-messages'
+
+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
+
+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
+
+transport_conf_params = java.util.HashMap.new
+transport_conf_params.put('host', '0.0.0.0')
+transport_conf_params.put('port', 5445)
+transport_conf = Java::org.hornetq.api.core.TransportConfiguration.new(netty_acceptor_class_name, transport_conf_params);
+
+transport_conf_set = java.util.HashSet.new
+transport_conf_set.add(transport_conf)
+
+config.acceptor_configurations = transport_conf_set
+
+if is_backup
+  puts "backup"
+  config.backup = true
+  config.shared_store = false
+else
+  puts "live"
+  backup_params = java.util.HashMap.new
+  backup_params.put('host', backup_host)
+  backup_params.put('port', 5445)
+  #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'
+end
+
+server = Java::org.hornetq.core.server.HornetQServers.newHornetQServer(config)
+server.start

data/examples/server.rb

@@ -0,0 +1,42 @@
+#
+# 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
+HornetQClient::Factory.create_session(config) do |session|
+  server = session.create_server('jms.queue.ExampleQueue', timeout)
+  session.start
+  
+  count = 0
+  start_time = Time.now
+  server.run do |request_message|
+    count = count + 1
+    #puts "=================================="
+    text = request_message.body
+    #p text
+    #p request_message
+    #print "."
+    puts "#{count}" if count%1000 == 0
+    puts "Durable" if request_message.durable
+    reply_message = session.create_message(HornetQClient::Message::TEXT_TYPE, false)
+    reply_message << "Test Response"
+    reply_message
+  end
+  
+  duration = Time.now - start_time - timeout/1000
+  puts "\nReceived #{count} requests in #{duration} seconds at #{count/duration} messages per second"
+  
+  server.close
+end

data/examples/standalone_server.yml

@@ -0,0 +1,3 @@
+data_directory: ../data
+host: 0.0.0.0
+port: 5445

data/lib/hornetq/client_requestor.rb

@@ -0,0 +1,30 @@
+module HornetQClient
+
+  # Send a request to a server and wait for a reply  
+  class ClientRequestor
+    def initialize(session, request_address)
+      @session = session
+      @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)
+    end
+  
+    def request(request_message, timeout)
+      request_message.putStringProperty(Java::OrgHornetqCoreClientImpl::ClientMessageImpl::REPLYTO_HEADER_NAME, @consumer.queue_name);
+      @producer.send(request_message)
+      @consumer.receive(timeout)
+    end
+    
+    def close
+      @producer.close if @producer
+      @consumer.close if @consumer
+      @session.delete_queue(@consumer.queue_name)
+    end
+  end
+  
+end

data/lib/hornetq/client_server.rb

@@ -0,0 +1,47 @@
+module HornetQClient
+  # Create a Server for receiving requests and replying
+  #   to arbitrary queues
+  # Create an instance of this class per thread
+  class ClientServer
+    def initialize(session, request_queue, timeout)
+      @session = session
+      @consumer = session.create_consumer(request_queue)
+      @producer = session.create_producer
+      @timeout = timeout
+    end
+  
+    def run(&block)
+      while request_message = @consumer.receive(@timeout)
+        # Block should return a message reply object, pass in request
+        # TODO: ensure..
+        reply_message = block.call(request_message)
+      
+        # Send a reply?
+        reply(request_message, reply_message) if request_message.request?
+        request_message.acknowledge
+      end
+    end
+
+    # Send a reply to the received request message
+    #   request: is the message received
+    #   reply:   is the message to send to the client
+    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)
+        #puts "Sent reply to #{reply_to.to_s}: #{reply_message.inspect}"
+      end
+      request_message.acknowledge
+    end
+  
+    # Close out resources
+    def close
+      @consumer.close if @consumer
+      @producer.close if @producer
+    end
+  end
+end