jruby-hornetq 0.2.5.alpha → 0.3.0.alpha

data/lib/hornetq/client/session_pool.rb

@@ -15,7 +15,7 @@ module HornetQ::Client
   #   end
   #
   # Parameters:
-  #   see regular session parameters from: HornetQ::Client::Factory::create_session
+  #   see regular session parameters from: HornetQ::Client::Connection::create_session
   #
   # Additional parameters for controlling the session pool itself
   #   :pool_name         Name of the pool as it shows up in the logger.
@@ -30,12 +30,12 @@ module HornetQ::Client
   #                      For example: Rails.logger
   #                      Default: None.
   # Example:
-  #   session_pool = factory.create_session_pool(config)
+  #   session_pool = connection.create_session_pool(config)
   #   session_pool.session do |session|
   #      ....
   #   end
   class SessionPool
-    def initialize(factory, params={})
+    def initialize(connection, params={})
       # Save Session params since it will be used every time a new session is
       # created in the pool
       session_params = params.nil? ? {} : params.dup
@@ -46,7 +46,7 @@ module HornetQ::Client
         :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)
+        s = connection.create_session(session_params)
         # Start the session since it will be used immediately upon creation
         s.start
         s

data/lib/hornetq/common/log_delegate.rb

@@ -4,9 +4,9 @@ module HornetQ
   # 
   private
 
-  # HornetQ requires a factory from which it can create a logger per thread and/or class 
+  # HornetQ requires a connection from which it can create a logger per thread and/or class 
   class LogDelegateFactory
-    include 
+    include Java::org.hornetq.spi.core.logging::LogDelegateFactory
     
     def createDelegate(klass)
       LogDelegate.new(klass.name)
@@ -24,23 +24,25 @@ module HornetQ
     
     # DRY, generate a method for each required log level
     ['debug', 'error', 'fatal', 'info', 'trace', 'warn'].each do |level|
-      eval <<-LOG_LEVEL_METHOD
-      def #{level}(message)
-        @logger.#{level}("[\#{@class_name}] \#{message}") if is#{level.capitalize}Enabled
-      end
-
-      def #{level}(message, t)
-        if is#{level.capitalize}Enabled
-          @logger.#{level}("[\#{@class_name}] \#{message}. \#{t.to_string}")
-          @logger.#{level}(t.stack_trace.to_string)
+      eval <<LOG_LEVEL_METHOD
+    def #{level}(message, t=nil)
+      logger =  HornetQ::logger
+      if logger.#{level}?
+        if t
+          logger.#{level}("[\#{@class_name}] \#{message}. \#{t.toString}")
+          logger.#{level}(t.stack_trace.toString)
+        else
+          logger.#{level}{"[\#{@class_name}] \#{message}"}
         end
       end
+    end
 
-      def is#{level.capitalize}Enabled
-        @logger.#{level}?
-      end
-      LOG_LEVEL_METHOD
+    def is#{level.capitalize}Enabled
+      HornetQ::logger.#{level}?
     end
 
+LOG_LEVEL_METHOD
+    end
+    
   end
 end

data/lib/hornetq/common/logging.rb

@@ -2,7 +2,7 @@
 module HornetQ
   # Returns the logger being used by both HornetQ and jruby-hornetq
   def self.logger
-    @logger ||= (rails_logger || default_logger)
+    @logger ||= (self.rails_logger || self.default_logger)
   end
 
   # Replace the logger for both HornetQ and jruby-hornetq
@@ -10,10 +10,26 @@ module HornetQ
   def self.logger=(logger)
     @logger = logger
     # Also replace the HornetQ logger
-    Java::org.hornetq.core.logging::Logger.setDelegateFactory(HornetQ::LogDelegateFactory.new)
+    if @logger
+      Java::org.hornetq.core.logging::Logger.setDelegateFactory(HornetQ::LogDelegateFactory.new)
+    else
+      Java::org.hornetq.core.logging::Logger.reset      
+    end
     # TODO org.hornetq.core.logging.Logger.setDelegateFactory(org.hornetq.integration.logging.Log4jLogDelegateFactory.new)
   end
 
+  # Use the ruby logger, but add needed trace level logging which will result
+  # in debug log entries
+  def self.ruby_logger(level=nil, target=STDOUT)
+    require 'logger'
+
+    l = ::Logger.new(target)
+    l.instance_eval "alias :trace :debug"
+    l.instance_eval "alias :trace? :debug?"
+    l.level = level || ::Logger::INFO
+    l
+  end
+
   private
   def self.rails_logger
     (defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger) ||
@@ -22,11 +38,8 @@ module HornetQ
 
   # By default we use the HornetQ Logger
   def self.default_logger
+    # Needs an actual Java class, so give it: org.hornetq.api.core.client::HornetQClient
     Java::org.hornetq.core.logging::Logger.getLogger(org.hornetq.api.core.client::HornetQClient)
-    #    require 'logger'
-    #    l = Logger.new(STDOUT)
-    #    l.level = Logger::INFO
-    #    l
   end
-
+ 
 end

data/lib/hornetq/common/org_hornetq_core_logging_logger.rb

@@ -1,9 +1,9 @@
 # Extend HornetQ Logger class to respond to standard Rails/Ruby log methods
-#   
+#
 # The following methods are already implemented by the java class
 #   initialize
 #   delegate
-#   
+#
 # The following methods are being replaced so that they can support blocks
 #   trace
 #   debug
@@ -11,7 +11,7 @@
 #   warn
 #   error
 #   fatal
-#   
+#
 # The following methods are new
 #   trace?
 #   debug?
@@ -19,7 +19,7 @@
 #   warn?
 #   error?
 #   fatal?
-#   
+#
 
 # This has to be a "mix-in" because the class can return instances of itself
 class org.hornetq.core.logging::Logger
@@ -29,21 +29,23 @@ class org.hornetq.core.logging::Logger
   def #{level}?
     #{level}_enabled?
   end
-  
-  # Support logging with block parameters that only get evaluated if the 
+
+  alias :java_#{level} :#{level}
+
+  # Support logging with block parameters that only get evaluated if the
   # matching log level is enabled
   def #{level}(message=nil, &block)
     if #{level}?
       if block
-        java_send :#{level}, block.call
+        java_#{level}(block.call.to_s.to_java_string)
       else
-        java_send :#{level}, message        
+        java_#{level}(message.to_s.to_java_string)
       end
     end
   end
 LOG_LEVEL_METHOD
   end
-  
+
   private
   # Implement since not implemented by Logger
   def error_enabled?

data/lib/hornetq/server.rb

@@ -4,9 +4,92 @@ module HornetQ
     def self.load_requirements
       HornetQ.require_jar 'hornetq-core'
       HornetQ.require_jar 'netty'
-      require 'hornetq/org_hornetq_core_server_hornet_q_server'
+      require 'hornetq/server/org_hornetq_core_server_hornet_q_server'
+    end
+
+    def self.create_server(params={})
+      self.load_requirements
+
+      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
+      config = Java::org.hornetq.core.config.impl.ConfigurationImpl.new
+      data_directory = params.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"
+
+      if uri.host == 'invm'
+        acceptor = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::INVM_ACCEPTOR_CLASS_NAME)
+        config.persistence_enabled = false
+        config.security_enabled    = false
+      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 Java::org.hornetq.core.journal.impl.AIOSequentialFileFactory.isSupported
+        config.journal_type = Java::org.hornetq.core.server.JournalType::ASYNCIO
+      else
+        require 'rbconfig'
+        if Config::CONFIG['target_os'] == 'linux'
+          HornetQ.logger("AIO wasn't located on this platform, it will fall back to using pure Java NIO. Install LibAIO to enable the AIO journal")
+        end
+        config.journal_type = Java::org.hornetq.core.server.JournalType::NIO
+      end
+
+      if params[:backup]
+        HornetQ.logger.info "Creating backup server"
+        config.backup = true
+        config.shared_store = false
+      elsif uri.backup_host
+        HornetQ.logger.info "Creating live server"
+        #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'
+        HornetQ.logger.info 'Creating invm server'
+      else
+        HornetQ.logger.info 'Creating standalone server'
+      end
+
+      params.each_pair do |key, val|
+        method = key.to_s+'='
+        if config.respond_to? method
+          config.send method, val
+          #HornetQ.logger.debug "#{key} = #{config.send key}" if config.respond_to? key.to_sym
+        else
+          HornetQ.logger.warn "Option:#{key} class=#{key.class} with value:#{val} is invalid and being ignored"
+        end
+      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
-
-require 'hornetq/server/factory'

data/lib/hornetq/{org_hornetq_core_server_hornet_q_server.rb → server/org_hornetq_core_server_hornet_q_server.rb}

@@ -5,7 +5,7 @@ module Java::org.hornetq.core.server::HornetQServer
   def enable_shutdown_on_signal
     ['HUP', 'INT', 'TERM'].each do |signal_name|
       Signal.trap(signal_name) do
-        puts "caught #{signal_name}"
+        HornetQ.logger.info "Caught #{signal_name}, stopping server"
         stop
       end
     end

data/lib/hornetq/uri.rb

@@ -55,5 +55,9 @@ module HornetQ
     def [](key)
       @params[key]
     end
+
+    def backup?
+      !!@params[:backup]
+    end
   end
 end

data/test/client_connection_test.rb

@@ -0,0 +1,158 @@
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'hornetq'
+require 'yaml'
+
+class ClientConnectionTest < Test::Unit::TestCase
+  context 'Client Connection' do
+    
+    setup do
+      # This test requires a hornetq running local on the default port
+      @config = 'hornetq://localhost'
+    end
+
+    should 'Create Connection to the Server' do
+      connection = HornetQ::Client::Connection.new(@config)
+      #HornetQ::logger.info connection.to_s
+      assert_not_nil connection
+      connection.close
+    end
+
+    should 'Create and start Connection to the Server with block' do
+      HornetQ::Client::Connection.connection(@config) do |connection|
+        assert_not_nil connection
+      end
+    end
+   
+    should 'Create and start Connection to the Server with block and start one session' do
+      HornetQ::Client::Connection.session(@config) do |session|
+        assert_not_nil session
+      end
+    end
+    
+    should 'Start and stop connection' do
+      # Connection is started when created
+      connection = HornetQ::Client::Connection.new(@config)
+      assert_not_nil connection      
+      assert_nil connection.close
+    end
+
+    should 'Create a session from the connection' do
+      connection = HornetQ::Client::Connection.new(@config)
+      session = connection.create_session
+      assert_not_nil session
+      
+      assert_nil session.start
+      
+      assert_equal session.auto_commit_acks?, true
+      assert_equal session.auto_commit_sends?, true
+      assert_equal session.block_on_acknowledge?, false
+      assert_equal session.closed?, false
+      assert_equal session.rollback_only?, false
+      assert_equal session.xa?, false
+      
+      assert_nil session.stop
+      
+      # Close the session
+      assert_nil session.close
+      assert_equal session.closed?, true
+      
+      assert_nil connection.close
+    end
+
+    should 'Create a session with a block' do
+      connection = HornetQ::Client::Connection.new(@config)
+      
+      connection.session do |session|
+        assert_not_nil session
+        assert_equal session.auto_commit_acks?, true
+        assert_equal session.auto_commit_sends?, true
+        assert_equal session.block_on_acknowledge?, false
+        assert_equal session.rollback_only?, false
+        
+        assert_equal session.xa?, false
+        assert_equal session.closed?, false
+      end
+      
+      assert_nil connection.close
+    end
+
+    should 'create a session without a block and throw exception' do
+      connection = HornetQ::Client::Connection.new(@config)
+      
+      assert_raise(RuntimeError) { connection.session }
+      
+      assert_nil connection.close
+    end
+
+#    should 'Create a session from the connection with params' do
+#      connection = HornetQ::Client::Connection.new(@config)
+#      
+#      session_parms = { 
+#        :transacted => true,
+#        :options => javax.jms.Session::AUTO_ACKNOWLEDGE
+#      }
+#
+#      session = connection.create_session(session_parms)
+#      assert_not_nil session
+#      assert_equal session.transacted?, true
+#      # When session is transacted, options are ignore, so ack mode must be transacted
+#      assert_equal session.acknowledge_mode, javax.jms.Session::SESSION_TRANSACTED
+#      assert_nil session.close
+#      
+#      assert_nil connection.stop
+#      assert_nil connection.close
+#    end
+#
+#    should 'Create a session from the connection with block and params' do
+#      HornetQ::Client::Connection.start_session(@config) do |connection|
+#      
+#        session_parms = { 
+#          :transacted => true,
+#          :options => javax.jms.Session::CLIENT_ACKNOWLEDGE
+#        }
+#
+#        connection.session(session_parms) do |session|
+#          assert_not_nil session
+#          assert_equal session.transacted?, true
+#          # When session is transacted, options are ignore, so ack mode must be transacted
+#          assert_equal session.acknowledge_mode, javax.jms.Session::SESSION_TRANSACTED
+#        end
+#      end
+#    end
+#
+#    should 'Create a session from the connection with block and params opposite test' do
+#      HornetQ::Client::Connection.start_session(@config) do |connection|
+#      
+#        session_parms = { 
+#          :transacted => false,
+#          :options => javax.jms.Session::AUTO_ACKNOWLEDGE
+#        }
+#
+#        connection.session(session_parms) do |session|
+#          assert_not_nil session
+#          assert_equal session.transacted?, false
+#          assert_equal session.acknowledge_mode, javax.jms.Session::AUTO_ACKNOWLEDGE
+#        end
+#      end
+#    end
+#  
+#    context 'HornetQ::Client Connection additional capabilities' do
+#    
+#      should 'start an on_message handler' do
+#        HornetQ::Client::Connection.start_session(@config) do |connection|
+#          value = nil
+#          connection.on_message(:transacted => true, :queue_name => :temporary) do |message|
+#            value = "received"
+#          end
+#        end
+#      end
+#      
+#    end
+    
+  end
+end