jruby-hornetq 0.2.0.alpha → 0.2.1.alpha

data/lib/hornetq/{org_hornetq_api_core_client_client_session.rb → client/org_hornetq_api_core_client_client_session.rb}

@@ -4,13 +4,13 @@ module Java::org.hornetq.api.core.client::ClientSession
   # To be consistent create Requestor from Session
   def create_requestor(request_address)
     #Java::org.hornetq.api.core.client::ClientRequestor.new(self, request_address);
-    HornetQClient::ClientRequestor.new(self, request_address)
+    HornetQ::Client::Requestor.new(self, request_address)
   end
   
   # Create a server handler for receiving requests and responding with
   # replies to the supplied address
   def create_server(input_queue, timeout=0)
-    HornetQClient::ClientServer.new(self, input_queue, timeout)
+    HornetQ::Client::Server.new(self, input_queue, timeout)
   end
 end
 

data/lib/hornetq/{org_hornetq_core_client_impl_client_message_impl.rb → client/org_hornetq_core_client_impl_client_message_impl.rb}

@@ -18,7 +18,7 @@ class Java::OrgHornetqCoreClientImpl::ClientMessageImpl
   # Set the Reply To Queue Name
   #  When supplied, the consumer of the message is expected to send a response to the
   #  specified queue. However, this is by convention, so no response is guaranteed
-  # Note: Rather than set this directly, consider creating a ClientRequestor:
+  # Note: Rather than set this directly, consider creating a Client::Requestor:
   #     requestor = session.create_requestor('Request Queue')
   #
   def reply_to_queue_name=(name)
@@ -42,8 +42,13 @@ class Java::OrgHornetqCoreClientImpl::ClientMessageImpl
   # WARNING: Do not call after setting the body otherwise the send will have
   #          an empty body
   def body
+    # Allow this buffer to be read multiple times
+    body_buffer.reset_reader_index
+
     case type
     when Java::org.hornetq.api.core.Message::BYTES_TYPE  #4
+      buf = body_buffer
+      String.new(buf.read_bytes(buf.readable_bytes))
     when Java::org.hornetq.api.core.Message::DEFAULT_TYPE 	#0
     when Java::org.hornetq.api.core.Message::MAP_TYPE 	#5
       Java::org.hornetq.utils::TypedProperties.new.decode(body_buffer)
@@ -60,10 +65,11 @@ class Java::OrgHornetqCoreClientImpl::ClientMessageImpl
   # 
   # Data is automatically converted based on the message type
   # 
-  # TODO Support non-string Types
+  # DEPRECATED
   def <<(data)
     case type
     when Java::org.hornetq.api.core.Message::BYTES_TYPE  #4
+      body_buffer.write_bytes(data)
     when Java::org.hornetq.api.core.Message::DEFAULT_TYPE 	#0
       raise "Cannot use Message#<< when the Message#type has not been set"
     when Java::org.hornetq.api.core.Message::MAP_TYPE 	#5
@@ -89,6 +95,60 @@ class Java::OrgHornetqCoreClientImpl::ClientMessageImpl
     end
   end
   
+  # Set the body of the message
+  # The type of the message is automatically set based on the type passed in.
+  # The following types are automatically supported in order of priority
+  #   String                                   => :text
+  #   Java::org.hornetq.api.core::SimpleString => :text
+  #   Java::org.hornetq.utils::TypedProperties => :map
+  #   Hash (actually any object responding to  => :map
+  def body=(data)
+    body_buffer.reset_writer_index
+    if data.is_a? String
+      # Ruby String
+      self.type = Java::org.hornetq.api.core.Message::TEXT_TYPE
+      body_buffer.writeNullableSimpleString(Java::org.hornetq.api.core::SimpleString.new(data))
+    elsif data.is_a? Java::org.hornetq.api.core::SimpleString
+      # SimpleString instance
+      self.type = Java::org.hornetq.api.core.Message::TEXT_TYPE
+      body_buffer.writeNullableSimpleString(data)
+    elsif data.is_a? Java::org.hornetq.utils::TypedProperties
+      # TypedProperties
+      self.type = Java::org.hornetq.api.core.Message::MAP_TYPE
+      data.encode(body_buffer)
+    elsif data.responds_to? :each_pair
+      # Ruby Hash, or anything that responds to :each_pair
+      # TODO What about Hash inside of Hash?
+      self.type = Java::org.hornetq.api.core.Message::MAP_TYPE
+      properties = Java::org.hornetq.utils::TypedProperties.new
+      data.each_pair do |key, val|
+        properties[key.to_s] = val
+      end
+      properties.encode(body_buffer)
+    elsif data.responds_to? :to_s
+      # Can be converted to a Ruby String
+      self.type = Java::org.hornetq.api.core.Message::TEXT_TYPE
+      body_buffer.writeNullableSimpleString(Java::org.hornetq.api.core::SimpleString.new(data.to_s))
+    else
+      # Otherwise Serialize Ruby object
+      self.type = Java::org.hornetq.api.core.Message::BYTES_TYPE
+      self['encoding', 'jruby']
+      # If BYTES type is not working we could use Base64.encode64
+      self << Marshal.dump(data)
+      self.text = encoded
+    end
+  end
+  
+  # Serialize JRuby object and base64 encode
+  def decode
+    if self.get_string_property( 'torquebox_encoding' ) == 'base64'
+      serialized = Base64.decode64( self.text )
+      Marshal.restore( serialized )
+    else
+      self.text
+    end
+  end
+  
   # Get a property
   def [](key)
     getObjectProperty(key.to_s)

data/lib/hornetq/{client_requestor.rb → client/requestor.rb}

@@ -1,7 +1,7 @@
-module HornetQClient
+module HornetQ::Client
 
   # Send a request to a server and wait for a reply  
-  class ClientRequestor
+  class Requestor
     def initialize(session, request_address)
       @session = session
       @producer = session.create_producer(request_address)

data/lib/hornetq/{client_server.rb → client/server.rb}

@@ -1,8 +1,8 @@
-module HornetQClient
+module HornetQ::Client
   # Create a Server for receiving requests and replying
   #   to arbitrary queues
   # Create an instance of this class per thread
-  class ClientServer
+  class Server
     def initialize(session, request_queue, timeout)
       @session = session
       @consumer = session.create_consumer(request_queue)

data/lib/hornetq/{session_pool.rb → client/session_pool.rb}

@@ -1,6 +1,6 @@
 require 'gene_pool'
 
-module HornetQClient
+module HornetQ::Client
   # Since a Session can only be used by one thread at a time, we could create
   # a Session for every thread. That could result in excessive unused Sessions.
   # An alternative is to create a pool of sessions that can be shared by
@@ -15,11 +15,11 @@ module HornetQClient
   #   end
   #
   # Parameters:
-  #   see regular session parameters from: HornetQClient::Factory::create_session
+  #   see regular session parameters from: HornetQ::Client::Factory::create_session
   #
   # Additional parameters for controlling the session pool itself
   #   :pool_name         Name of the pool as it shows up in the logger.
-  #                      Default: 'HornetQClient::SessionPool'
+  #                      Default: 'HornetQ::Client::SessionPool'
   #   :pool_size         Maximum Pool Size. Default: 10
   #                      The pool only grows as needed and will never exceed
   #                      :pool_size
@@ -35,18 +35,18 @@ module HornetQClient
   #      ....
   #   end
   class SessionPool
-    def initialize(factory, parms={})
-      # Save Session parms since it will be used every time a new session is
+    def initialize(factory, params={})
+      # Save Session params since it will be used every time a new session is
       # created in the pool
-      session_parms = parms.dup
+      session_params = params.nil? ? {} : params.dup
       # TODO Use same logger as HornetQ?
       # TODO How to shrink unused connections?
       @pool = GenePool.new(
-        :name => parms[:pool_name] || self.class.name,
-        :pool_size => parms[:pool_size] || 10,
-        :warn_timeout => parms[:pool_warn_timeout] || 5,
-        :logger       => parms[:pool_logger]) do
-        s = factory.create_session(session_parms)
+        :name => session_params[:pool_name] || self.class.name,
+        :pool_size => session_params[:pool_size] || 10,
+        :warn_timeout => session_params[:pool_warn_timeout] || 5,
+        :logger       => session_params[:pool_logger]) do
+        s = factory.create_session(session_params)
         # Start the session since it will be used immediately upon creation
         s.start
         puts "Creating Session"
@@ -56,7 +56,7 @@ module HornetQClient
       # Obtain a session from the pool and pass it to the supplied block
       # The session is automatically returned to the pool once the block completes
       def session(&block)
-        @pool.with_connection {|s| block.call(s)}
+        @pool.with_connection &block
       end
 
       # Obtain a session from the pool and create a ClientConsumer. 
@@ -64,7 +64,7 @@ module HornetQClient
       # Once the block is complete the consumer is closed and the session is
       # returned to the pool.
       # 
-      # See  HornetQClient::ClientConsumer for more information on the consumer
+      # See  HornetQ::Client::ClientConsumer for more information on the consumer
       #      parameters
       #
       # Example
@@ -89,12 +89,12 @@ module HornetQClient
       # Once the block is complete the consumer is closed and the session is
       # returned to the pool.
       # 
-      # See  HornetQClient::ClientProducer for more information on the producer
+      # See  HornetQ::Client::ClientProducer for more information on the producer
       #      parameters
       #
       # Example
       #   session_pool.producer('MyAddress') do |session, producer|
-      #     message = session.create_message(HornetQClient::Message::TEXT_TYPE,false)
+      #     message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
       #     message << "#{Time.now}: ### Hello, World ###"
       #     producer.send(message)
       #   end
@@ -110,15 +110,15 @@ module HornetQClient
         end
       end
       
-      # Obtain a session from the pool and create a ClientRequestor. 
+      # Obtain a session from the pool and create a Client::Requestor.
       # Pass both into the supplied block. 
       # Once the block is complete the requestor is closed and the session is
       # returned to the pool.
       # 
-      # See  HornetQClient::ClientRequestor for more information on the requestor
+      # See  HornetQ::Client::Requestor for more information on the requestor
       #
       # Example
-      #   session_pool.requestor(parms) do |session, requestor|
+      #   session_pool.requestor(params) do |session, requestor|
       #     ....
       #   end
       def requestor(address, &block)
@@ -133,12 +133,12 @@ module HornetQClient
         end
       end
       
-      # Obtain a session from the pool and create a ClientServer. 
+      # Obtain a session from the pool and create a Client::Server.
       # Pass both into the supplied block. 
       # Once the block is complete the requestor is closed and the session is
       # returned to the pool.
       # 
-      # See  HornetQClient::ClientServer for more information on the server
+      # See  HornetQ::Client::Server for more information on the server
       #
       # Example
       #   session_pool.server(queue, timeout) do |session, server|

data/lib/hornetq/org_hornetq_core_server_hornet_q_server.rb

@@ -0,0 +1,13 @@
+# Add methods to Server Interface
+module Java::org.hornetq.core.server::HornetQServer
+
+  # Shutdown the server when a typical interrupt signal (1,2,15) is caught
+  def enable_shutdown_on_signal
+    ['HUP', 'INT', 'TERM'].each do |signal_name|
+      Signal.trap(signal_name) do
+        puts "caught #{signal_name}"
+        stop
+      end
+    end
+  end
+end

data/lib/hornetq/server.rb

@@ -0,0 +1,12 @@
+module HornetQ
+  module Server
+    # Only load as needed
+    def self.load_requirements
+      HornetQ.require_jar 'hornetq-core'
+      HornetQ.require_jar 'netty'
+      require 'hornetq/org_hornetq_core_server_hornet_q_server'
+    end
+  end
+end
+
+require 'hornetq/server/factory'

data/lib/hornetq/server/factory.rb

@@ -0,0 +1,86 @@
+module HornetQ::Server
+
+  class Factory
+    def self.create_server(parms={})
+      HornetQ::Server.load_requirements
+
+      if parms.kind_of?(String)
+        uri = HornetQ::URI.new(parms)
+        parms = uri.params
+      else
+        raise "Missing :uri param in HornetQ::Server.create_server" unless parms[:uri]
+        uri = HornetQ::URI.new(parms.delete(:uri))
+        # parms override uri params
+        parms = uri.params.merge(parms)
+      end
+      config = Java::org.hornetq.core.config.impl.ConfigurationImpl.new
+      data_directory = parms.delete(:data_directory) || HornetQ::DEFAULT_DATA_DIRECTORY
+      config.paging_directory = "#{data_directory}/paging"
+      config.bindings_directory = "#{data_directory}/bindings"
+      config.journal_directory = "#{data_directory}/journal"
+      config.large_messages_directory = "#{data_directory}/large-messages"
+
+      parms.each_pair do |key, val|
+        method = key.to_s+'='
+        if config.respond_to? method
+          config.send method, val
+          #puts "Debug: #{key} = #{config.send key}" if config.respond_to? key.to_sym
+        else
+          puts "Warning: Option:#{key} class=#{key.class} with value:#{val} is invalid and being ignored"
+        end
+      end
+
+      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
+
+      if uri.host == 'invm'
+        acceptor = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::INVM_ACCEPTOR_CLASS_NAME)
+      else
+        acceptor = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::NETTY_ACCEPTOR_CLASS_NAME, {'host' => uri.host, 'port' => uri.port })
+        connector = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::NETTY_CONNECTOR_CLASS_NAME, {'host' => uri.host, 'port' => uri.port })
+        connector_conf_map = java.util.HashMap.new
+        connector_conf_map.put('netty-connector', connector)
+        config.connector_configurations = connector_conf_map
+      end
+      acceptor_conf_set = java.util.HashSet.new
+      acceptor_conf_set.add(acceptor)
+      config.acceptor_configurations = acceptor_conf_set
+
+
+      if parms[:backup]
+        puts "backup"
+        config.backup = true
+        config.shared_store = false
+      elsif uri.backup_host
+        puts "live"
+        #backup_params.put('reconnectAttempts', -1)
+        backup_connector = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::NETTY_CONNECTOR_CLASS_NAME, {'host' => uri.backup_host, 'port' => uri.backup_port })
+        connector_conf_map.put('backup-connector', backup_connector)
+        config.backup_connector_name = 'backup-connector'
+      elsif uri.host == 'invm'
+        puts 'invm'
+      else
+        puts 'standalone'
+      end
+
+      return Java::org.hornetq.core.server.HornetQServers.newHornetQServer(config)
+    end
+    
+    # Start a new server instance and stop it once the supplied block completes
+    def self.start(params={}, &block)
+      server = nil
+      begin
+        server = self.create_server(params)
+        server.start
+        block.call(server)
+      ensure
+        server.stop if server
+      end
+    end
+    
+  end
+end

data/lib/hornetq/uri.rb

@@ -0,0 +1,59 @@
+module HornetQ
+  class URI
+    attr_reader :scheme, :host, :port, :backup_host, :backup_port, :path, :params
+
+    # hornetq://localhost
+    # hornetq://localhost,192.168.0.22
+    # hornetq://localhost:5445,backupserver:5445/?protocol=netty
+    # hornetq://localhost/?protocol=invm
+    # hornetq://discoveryserver:5445/?protocol=discovery
+
+    def initialize(uri)
+      raise Exception,"Invalid protocol format: #{uri}" unless uri =~ /(.*):\/\/(.*)/
+      @scheme, @host = $1, $2
+      raise Exception,"Bad URI(only scheme hornetq:// is supported): #{uri}" unless @scheme == 'hornetq'
+      raise 'Mandatory hostname missing in uri' if @host.empty?
+      if @host =~ /(.*?)(\/.*)/
+        @host, @path = $1, $2
+      else
+        @path = '/'
+      end
+      if @host =~ /(.*),(.*)/
+        @host, @backup_host = $1, $2
+      end
+      if @host =~ /(.*):(.*)/
+        @host, @port = $1, HornetQ.netty_port($2)
+      else
+        @port = HornetQ::DEFAULT_NETTY_PORT
+      end
+      if @backup_host
+        if @backup_host =~ /(.*):(.*)/
+          @backup_host, @backup_port = $1, HornetQ.netty_port($2)
+        else
+          @backup_port = HornetQ::DEFAULT_NETTY_PORT
+        end
+      end
+      query = nil
+      if @path =~ /(.*)\?(.*)/
+        @path, query = $1, $2
+      end
+
+      # Extract settings passed in query
+      @params = {}
+      if query
+        query.split('&').each do |i|
+          key, value = i.split('=')
+          value = true if value == 'true'
+          value = false if value == 'false'
+          value = value.to_i if value =~ /^\d+$/
+          value = value.to_f if value =~ /^\d+\.\d*$/
+          @params[key.to_sym] = value
+        end
+      end
+    end
+
+    def [](key)
+      @params[key]
+    end
+  end
+end

data/test/server_factory_test.rb

@@ -0,0 +1,184 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'hornetq'
+require 'fileutils'
+
+class MyThread < ::Thread
+  def initialize(name, &block)
+    super() do
+      begin
+        yield
+      rescue => e
+        puts("Thread #{name} died due to exception #{e.message}\n#{e.backtrace.join("\n")}")
+      end
+    end
+  end
+end
+
+class ServerFactoryTest < Test::Unit::TestCase
+  context 'standalone server' do
+    setup do
+      @server       = nil
+      @tmp_data_dir = "/tmp/data_dir/#{$$}"
+      @uri          = "hornetq://localhost:15445"
+      @server_thread = MyThread.new('standalone server') do
+        @server = HornetQ::Server::Factory.create_server(:uri => @uri, :data_directory => @tmp_data_dir)
+        @server.start
+      end
+      # Give the server time to startup
+      sleep 5
+    end
+
+    teardown do
+      @server.stop
+      @server_thread.join
+      FileUtils.rm_rf(@tmp_data_dir)
+    end
+
+    should 'pass simple messages' do
+      count      = 10
+      queue_name = 'test_queue'
+      config = {
+        :connector => { :uri => @uri },
+        :session   => { :username =>'guest', :password => 'guest'}
+      }
+
+      # Create a HornetQ session
+      HornetQ::Client::Factory.create_session(config) do |session|
+        session.create_queue(queue_name, queue_name, true)
+        producer = session.create_producer(queue_name)
+        (1..count).each do |i|
+          message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
+          message.durable = true
+          # Set the message body text
+          message << "Message ##{i}"
+          # Send message to the queue
+          producer.send(message)
+        end
+      end
+
+      HornetQ::Client::Factory.create_session(config) do |session|
+        consumer = session.create_consumer(queue_name)
+        session.start
+
+        i = 0
+        while message = consumer.receive(1000)
+          i += 1
+          message.acknowledge
+          assert_equal "Message ##{i}", message.body
+        end
+      end
+    end
+  end
+
+  context 'live and backup server' do
+    setup do
+      @count      = 20
+
+      @server              = nil
+      @tmp_data_dir        = "/tmp/data_dir/#{$$}"
+      @uri                 = "hornetq://localhost:15445,localhost:15446"
+
+      @backup_server       = nil
+      @backup_tmp_data_dir = "/tmp/backup_data_dir/#{$$}"
+      @backup_uri          = "hornetq://localhost:15446"
+
+      @backup_server_thread = MyThread.new('backup server') do
+        begin
+          @backup_server = HornetQ::Server::Factory.create_server(:uri => @backup_uri, :data_directory => @backup_tmp_data_dir, :backup => true)
+          @backup_server.start
+        rescue Exception => e
+          puts "Error in backup server thread: #{e.message}\n#{e.backtrace.join("\n")}"
+        end
+      end
+      # Give the backup server time to startup
+      sleep 10
+
+      @server_thread = MyThread.new('live server') do
+        begin
+          @server = HornetQ::Server::Factory.create_server(:uri => @uri, :data_directory => @tmp_data_dir)
+          @server.start
+        rescue Exception => e
+          puts "Error in live server thread: #{e.message}\n#{e.backtrace.join("\n")}"
+        end
+      end
+
+      # Give the live server time to startup
+      sleep 10
+
+      @queue_name = 'test_queue'
+      @config = {
+        :connector => {
+          :uri                            => @uri,
+          :failover_on_initial_connection => true,
+          :failover_on_server_shutdown    => true,
+        },
+        :session   => { :username =>'guest', :password => 'guest'}
+      }
+
+      @killer_thread = MyThread.new('killer') do
+        sleep 5
+        @server.stop
+      end
+
+      @producer_thread = MyThread.new('producer') do
+        # Create a HornetQ session
+        HornetQ::Client::Factory.create_session(@config) do |session|
+          session.create_queue(@queue_name, @queue_name, true)
+          producer = session.create_producer(@queue_name)
+          (1..@count).each do |i|
+            message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
+            message.durable = true
+            # Set the message body text
+            message << "Message ##{i}"
+            # Send message to the queue
+            begin
+              puts "Producing message: #{message.body}"
+              producer.send(message)
+              sleep 1
+            rescue Java::org.hornetq.api.core.HornetQException => e
+              puts "Received producer exception: #{e.message} with code=#{e.cause.code}"
+              if e.cause.getCode == Java::org.hornetq.api.core.HornetQException::UNBLOCKED
+                puts "Retrying the send"
+                retry
+              end
+            rescue Exception => e
+              puts "Received producer exception: #{e.message}"
+            end
+          end
+        end
+      end
+    end
+
+    teardown do
+      @server.stop
+      @backup_server.stop
+      [ @server_thread, @backup_server_thread, @killer_thread, @producer_thread ].each do |thread|
+        thread.join
+      end
+      FileUtils.rm_rf([@tmp_data_dir, @backup_tmp_data_dir])
+    end
+
+    should 'failover to backup server w/o message loss' do
+      # Let the producer create the queue
+      sleep 2
+      HornetQ::Client::Factory.create_session(@config) do |session|
+        consumer = session.create_consumer(@queue_name)
+        session.start
+
+        i = 0
+        while message = consumer.receive(1000)
+          i += 1
+          message.acknowledge
+          assert_equal "Message ##{i}", message.body
+          puts "Consuming message #{message.body}"
+        end
+        assert_equal @count, i
+      end
+
+      killer_thread.join
+      producer_thread.join
+    end
+  end
+end