jruby-hornetq 0.2.0.alpha → 0.2.1.alpha

data/examples/{server.rb → client/advanced/server.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,22 +15,19 @@ 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|
+HornetQ::Client::Factory.create_session(config) do |session|
   server = session.create_server('jms.queue.ExampleQueue', timeout)
   session.start
   
   count = 0
   start_time = Time.now
+  puts "Server started and waiting for requests ..."
   server.run do |request_message|
-    count = count + 1
-    #puts "=================================="
-    text = request_message.body
-    #p text
-    #p request_message
-    #print "."
+    count += 1
+    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 = session.create_message(HornetQ::Client::Message::TEXT_TYPE, false)
     reply_message << "Test Response"
     reply_message
   end

data/examples/client/client.rb

@@ -0,0 +1,31 @@
+#
+# 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 'hornetq'
+
+timeout = (ARGV[0] || 5000).to_i
+
+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

data/examples/client/consumer.rb

@@ -0,0 +1,22 @@
+#
+# HornetQ Consumer:
+#          Write a single message 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::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

data/examples/client/invm.rb

@@ -0,0 +1,38 @@
+#
+# HornetQ In VM Producer and consumer:
+#   Example of how to produce and consume messages with the same Java VM
+#
+
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+
+require 'rubygems'
+require 'hornetq'
+
+# Create and start an InVM HornetQ server instance
+HornetQ::Server::Factory.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|
+    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 << "#{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}]"
+      message.acknowledge
+    else
+      puts "No message found"
+    end
+  end
+end

data/examples/client/producer.rb

@@ -0,0 +1,21 @@
+#
+# 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'
+
+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

data/examples/client/server.rb

@@ -0,0 +1,31 @@
+#
+# 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 'hornetq'
+
+timeout = (ARGV[0] || 60000).to_i
+
+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
+    reply_message
+  end
+
+  # Server will stop after timeout period after no messages received. Set to 0 to wait foreve
+  server.close
+end

data/examples/server/backup_server.yml

@@ -0,0 +1,6 @@
+backup: true
+data_directory: ../data_backup
+host: 0.0.0.0
+port: 5446
+
+uri: hornetq://0.0.0.0:5446/?backup=true&data_directory=./data_backup

data/examples/server/live_server.yml

@@ -0,0 +1 @@
+uri: hornetq://0.0.0.0:5445,localhost:5446/?data_directory=./data

data/examples/server/standalone_server.yml

@@ -0,0 +1 @@
+uri: hornetq://0.0.0.0/?data_directory=./data

data/lib/hornetq.rb

@@ -1,9 +1,30 @@
-require File.dirname(__FILE__) + '/hornetq/lib/hornetq-core-client.jar'
-require File.dirname(__FILE__) + '/hornetq/lib/netty.jar'
-require 'hornetq/org_hornetq_api_core_client_client_session'
-require 'hornetq/org_hornetq_core_client_impl_client_message_impl'
-require 'hornetq/org_hornetq_utils_typed_properties'
-require 'hornetq/hornet_q_client'
-require 'hornetq/client_requestor'
-require 'hornetq/client_server'
-require 'hornetq/session_pool'
+include Java
+require 'hornetq/server'
+require 'hornetq/client'
+require 'hornetq/uri'
+
+module HornetQ
+
+  # Netty Class name
+  NETTY_CONNECTOR_CLASS_NAME = 'org.hornetq.core.remoting.impl.netty.NettyConnectorFactory'
+  NETTY_ACCEPTOR_CLASS_NAME  = 'org.hornetq.core.remoting.impl.netty.NettyAcceptorFactory'
+  INVM_CONNECTOR_CLASS_NAME  = 'org.hornetq.core.remoting.impl.invm.InVMConnectorFactory'
+  INVM_ACCEPTOR_CLASS_NAME   = 'org.hornetq.core.remoting.impl.invm.InVMAcceptorFactory'
+
+  DEFAULT_NETTY_PORT     = java.lang.Integer.new(5445)
+  DEFAULT_DATA_DIRECTORY = './data'
+
+  # Allow override of our included jars so we don't have to keep up with hornetq releases
+  def self.require_jar(jar_name)
+    if ENV['HORNETQ_HOME']
+      require "#{ENV['HORNETQ_HOME']}/lib/#{jar_name}.jar"
+    else
+      require "hornetq/java/#{jar_name}.jar"
+    end
+  end
+
+  def self.netty_port(port)
+    port ||= DEFAULT_NETTY_PORT
+    return java.lang.Integer.new(port)
+  end
+end

data/lib/hornetq/client.rb

@@ -0,0 +1,19 @@
+module HornetQ
+  module Client
+    # Only load as needed
+    def self.load_requirements
+      HornetQ.require_jar 'hornetq-core-client'
+      HornetQ.require_jar 'netty'
+      require 'hornetq/client/org_hornetq_api_core_client_client_session'
+      require 'hornetq/client/org_hornetq_core_client_impl_client_message_impl'
+      require 'hornetq/client/org_hornetq_utils_typed_properties'
+
+      # Import Message Constants
+      import Java::org.hornetq.api.core::Message
+    end
+  end
+end
+
+require 'hornetq/client/factory'
+require 'hornetq/client/requestor'
+require 'hornetq/client/server'

data/lib/hornetq/{hornet_q_client.rb → client/factory.rb}

@@ -1,14 +1,6 @@
 require 'uri'
 
-module HornetQClient
-
-  # Import Message Constants
-  import Java::org.hornetq.api.core.Message
-
-  # Netty Class name
-  NETTY_CLASS_NAME ='org.hornetq.core.remoting.impl.netty.NettyConnectorFactory'
-  INVM_CLASS_NAME = 'org.hornetq.core.remoting.impl.invm.InVMAcceptorFactory'
-  DEFAULT_NETTY_PORT = 5445
+module HornetQ::Client
 
   class Factory
     # Create a new Factory from which sessions can be created
@@ -16,7 +8,7 @@ module HornetQClient
     # Parameters:
     # * a Hash consisting of one or more of the named parameters
     # * Summary of parameters and their default values
-    #  HornetQClient::Factory.new(
+    #  HornetQ::Client::Factory.new(
     #    :uri                            => 'hornetq://localhost',
     #    :ack_batch_size                 => ,
     #    :auto_group                     => ,
@@ -106,75 +98,59 @@ module HornetQClient
     # * :thread_pool_max_size
     # * :use_global_pools
 
-    def initialize(parms={})
-      raise "Missing :uri under :connector in config" unless uri = parms[:uri]
+    def initialize(params={})
+      HornetQ::Client.load_requirements
+      uri = nil
       # TODO: Support :uri as an array for cluster configurations
-
-      scheme, userinfo, host, port, registry, path, opaque, query, fragment = URI.split(uri)
-      raise InvalidURIError,"bad URI(only scheme hornetq:// is supported): #{uri}" unless scheme == 'hornetq'
-      backup_host = backup_port = nil
-
-      # Check for multiple server names
-      if registry
-        host, backup_host = registry.split(',')
-        host, port = host.split(':')
-        backup_host, backup_port = backup_host.split(':')
-      end
-
-      # Extract settings passed in query
-      settings = {}
-      if query
-        query.split(';').each do |i|
-          key, value = i.split('=')
-          settings[key] = value
-        end
+      if params.kind_of?(String)
+        uri = HornetQ::URI.new(params)
+        params = uri.params
+      else
+        raise "Missing :uri param in HornetQ::Server.create_server" unless params[:uri]
+        uri = HornetQ::URI.new(params.delete(:uri))
+        # params override uri params
+        params = uri.params.merge(params)
       end
-
-      # Determine transport protocol
-      factory = nil
+      
+      @factory = nil
       # In-VM Transport has no fail-over or additional parameters
-      if host == 'invm'
-        transport = Java::org.hornetq.api.core.TransportConfiguration.new(INVM_CLASS_NAME)
-        factory = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport)
-      elsif settings[:protocol]
+      if uri.host == 'invm'
+        transport = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::INVM_CONNECTOR_CLASS_NAME)
+        @factory = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport)
+      elsif params[:protocol]
         # Auto-Discovery just has a host name and port
-        if settings[:protocol] == 'discovery'
-          factory = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(host, port)
-        elsif settings[:protocol] != 'netty'
-          raise "Unknown HornetQ protocol:#{settings[:protocol]}"
+        if params[:protocol] == 'discovery'
+          @factory = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(uri.host, uri.port)
+        elsif params[:protocol] != 'netty'
+          raise "Unknown HornetQ protocol:#{params[:protocol]}"
         end
       end
 
       # Unless already created, then the factory will use the netty protocol
-      unless factory
+      unless @factory
         # Primary Transport
-        raise "Mandatory hostname missing in :uri" unless host
-        port ||= DEFAULT_NETTY_PORT
-        transport = Java::org.hornetq.api.core.TransportConfiguration.new(NETTY_CLASS_NAME, {'host' => host, 'port' => Java::java.lang.Integer.new(port)})
+        transport = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::NETTY_CONNECTOR_CLASS_NAME, {'host' => uri.host, 'port' => uri.port })
 
         # Check for backup server connection information
-        if backup_host
-          backup_port ||= DEFAULT_NETTY_PORT
-          backup_transport = Java::org.hornetq.api.core.TransportConfiguration.new(NETTY_CLASS_NAME, {'host' => backup_host, 'port' => Java::java.lang.Integer.new(backup_port)})
-          factory = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport, backup_transport)
+        if uri.backup_host
+          backup_transport = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::NETTY_CONNECTOR_CLASS_NAME, {'host' => uri.backup_host, 'port' => uri.backup_port })
+          @factory = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport, backup_transport)
         else
-          factory = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport)
+          @factory = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport)
         end
       end
 
       # If any other options were supplied, apply them to the created Factory instance
-      parms.each_pair do |key, val|
+      params.each_pair do |key, val|
         next if key == :uri
         method = key.to_s+'='
-        if factory.respond_to? method
-          factory.send method, val
-          #puts "Debug: #{key} = #{factory.send key}" if factory.respond_to? key.to_sym
+        if @factory.respond_to? method
+          @factory.send method, val
+          #puts "Debug: #{key} = #{@factory.send key}" if @factory.respond_to? key.to_sym
         else
           puts "Warning: Option:#{key}, with value:#{val} is invalid and being ignored"
         end
       end
-
-      @factory = factory
     end
 
     # Create a new HornetQ session
@@ -188,14 +164,14 @@ module HornetQClient
     #
     # Note:
     # * The returned session MUST be closed once complete
-    #     factory = HornetQClient::Factory.new(:uri => 'hornetq://localhost/')
+    #     factory = HornetQ::Client::Factory.new(:uri => 'hornetq://localhost/')
     #     session = factory.create_session
     #       ...
     #     session.close
     #     factory.close
-    # * It is recommended to rather call HornetQClient::Factory.create_session
+    # * It is recommended to rather call HornetQ::Client::Factory.create_session
     #   so that all resouces are closed automatically
-    #     HornetQClient::Factory.create_session(:uri => 'hornetq://localhost/') do |session|
+    #     HornetQ::Client::Factory.create_session(:uri => 'hornetq://localhost/') do |session|
     #       ...
     #     end
     #
@@ -212,7 +188,7 @@ module HornetQClient
     #
     #   factory = nil
     #   begin
-    #     factory = HornetQClient::Factory.new(:uri => 'hornetq://localhost/')
+    #     factory = HornetQ::Client::Factory.new(:uri => 'hornetq://localhost/')
     #     factory.create_session do |session|
     #
     #       # Create a new queue
@@ -222,7 +198,7 @@ module HornetQClient
     #       producer = session.create_producer('Example')
     #
     #       # Create a Text Message
-    #       message = session.create_message(HornetQClient::Message::TEXT_TYPE,true)
+    #       message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,true)
     #       message << 'Hello World'
     #
     #       # Send the message
@@ -238,7 +214,7 @@ module HornetQClient
     #   factory = nil
     #   session = nil
     #   begin
-    #     factory = HornetQClient::Factory.new(:uri => 'hornetq://localhost/')
+    #     factory = HornetQ::Client::Factory.new(:uri => 'hornetq://localhost/')
     #     session = factory.create_session
     #
     #     # Create a new queue
@@ -248,7 +224,7 @@ module HornetQClient
     #     producer = session.create_producer('Example')
     #
     #     # Create a Text Message
-    #     message = session.create_message(HornetQClient::Message::TEXT_TYPE,true)
+    #     message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,true)
     #     message.body_buffer.write_string('Hello World')
     #
     #     # Send the message
@@ -304,21 +280,20 @@ module HornetQClient
     #  * :ack_batch_size
     #    * the batch size of the acknowledgements
     #
-    def create_session(parms={}, &proc)
-      raise "HornetQClient Factory Already Closed" unless @factory
+    def create_session(params={}, &proc)
+      raise "HornetQ::Client::Factory Already Closed" unless @factory
       if proc
         session = nil
         result = nil
         begin
-          #session = @factory.create_session(true, true)
           session = @factory.create_session(
-            parms[:username],
-            parms[:password],
-            parms[:xa] || false,
-            parms[:auto_commit_sends].nil? ? true : parms[:auto_commit_sends],
-            parms[:auto_commit_acks].nil? ? true : parms[:auto_commit_acks],
-            parms[:pre_acknowledge] || false,
-            parms[:ack_batch_size] || 1)
+            params[:username],
+            params[:password],
+            params[:xa] || false,
+            params[:auto_commit_sends].nil? ? true : params[:auto_commit_sends],
+            params[:auto_commit_acks].nil? ? true : params[:auto_commit_acks],
+            params[:pre_acknowledge] || false,
+            params[:ack_batch_size] || 1)
           result = proc.call(session)
         ensure
           session.close if session
@@ -326,19 +301,21 @@ module HornetQClient
         result
       else
         @factory.create_session(
-          parms[:username],
-          parms[:password],
-          parms[:xa] || false,
-          parms[:auto_commit_sends].nil? ? true : parms[:auto_commit_sends],
-          parms[:auto_commit_acks].nil? ? true : parms[:auto_commit_acks],
-          parms[:pre_acknowledge] || false,
-          parms[:ack_batch_size] || 1)
+          params[:username],
+          params[:password],
+          params[:xa] || false,
+          params[:auto_commit_sends].nil? ? true : params[:auto_commit_sends],
+          params[:auto_commit_acks].nil? ? true : params[:auto_commit_acks],
+          params[:pre_acknowledge] || false,
+          params[:ack_batch_size] || 1)
       end
     end
 
     # Create a Session pool
-    def create_session_pool(parms={})
-      SessionPool.new(self, parms)
+    # TODO Raise an exception when gene_pool is not available
+    def create_session_pool(params={})
+      require 'hornetq/client/session_pool'
+      SessionPool.new(self, params)
     end
     
     # Close Factory connections
@@ -353,29 +330,49 @@ module HornetQClient
     #  block. Upon completion the session and factory are both closed
     # See Factory::initialize and Factory::create_session for the list
     #  of parameters
-    def self.create_session(parms={},&proc)
+    def self.create_session(params={},&proc)
       raise "Missing mandatory code block" unless proc
       factory = nil
       session = nil
       begin
-        factory = self.new(parms[:connector] || {})
-        session = factory.create_session(parms[:session] || {}, &proc)
+        if params.kind_of?(String)
+          # TODO: Support passing username and password from URI to Session
+          factory = self.new(params)
+          session = factory.create_session({}, &proc)
+        else
+          factory = self.new(params[:connector] || {})
+          session = factory.create_session(params[:session] || {}, &proc)
+        end
       ensure
+        session.close if session
         factory.close if factory
       end
     end
     
+    # Create a new Factory along with a Session, and then start the session
+    # 
+    #  Creates a new factory and session, then passes the session to the supplied
+    #  block. Upon completion the session and factory are both closed
+    # See Factory::initialize and Factory::create_session for the list
+    #  of parameters
+    def self.start(params={},&proc)
+      create_session(params) do |session|
+        session.start
+        proc.call(session)
+      end
+    end
+    
     # Call the supplied code block after creating a factory instance
     # See initialize for the parameter list
     # The factory is closed before returning
     # 
     # Returns the result of the code block
-    def self.create_factory(parms={}, &proc)
+    def self.create_factory(params={}, &proc)
       raise "Missing mandatory code block" unless proc
       factory = nil
       result = nil
       begin
-        factory=self.new(parms)
+        factory=self.new(params)
         result = proc.call(factory)
       ensure
         factory.close