jruby-jms 1.1.0-java → 1.2.0-java

data/lib/jms/session_pool.rb

@@ -14,8 +14,6 @@ module JMS
   #   see regular session parameters from: JMS::Connection#initialize
   #
   # Additional parameters for controlling the session pool itself
-  #   :pool_name         Name of the pool as it shows up in the logger.
-  #                      Default: 'JMS::SessionPool'
   #   :pool_size         Maximum Pool Size. Default: 10
   #                      The pool only grows as needed and will never exceed
   #                      :pool_size
@@ -25,9 +23,8 @@ module JMS
   #   :pool_warn_timeout Number of seconds to wait before logging a warning when a
   #                      session in the pool is not available
   #                      Default: 5
-  #   :pool_logger       Supply a logger that responds to #debug, #info, #warn and #debug?
-  #                      For example: Rails.logger
-  #                      Default: JMS.logger
+  #   :pool_name         Name of the pool as it shows up in the logger.
+  #                      Default: 'JMS::SessionPool'
   # Example:
   #   session_pool = connection.create_session_pool(config)
   #   session_pool.session do |session|
@@ -38,22 +35,26 @@ module JMS
       # Save Session params since it will be used every time a new session is
       # created in the pool
       session_params = params.nil? ? {} : params.dup
-      logger = session_params[:pool_logger] || JMS.logger
-      # Define how GenePool can create new sessions
-      @pool = GenePool.new(
-        :name         => session_params[:pool_name] || self.class.name,
-        :pool_size    => session_params[:pool_size] || 10,
-        :warn_timeout => session_params[:pool_warn_timeout] || 5,
-        :timeout      => session_params[:pool_timeout] || 60,
-        :close_proc   => nil,
-        :logger       => logger) do
-        connection.create_session(session_params)
+      logger         = SemanticLogger[session_params[:pool_name] || self.class]
+
+      # Use GenePool can create and manage the pool of sessions
+      @pool          = GenePool.new(
+        name:         '',
+        pool_size:    session_params[:pool_size] || 10,
+        warn_timeout: session_params[:pool_warn_timeout] || 5,
+        timeout:      session_params[:pool_timeout] || 60,
+        close_proc:   nil,
+        logger:       logger
+      ) do
+        session                      = connection.create_session(session_params)
+        # Turn on Java class persistence: https://github.com/jruby/jruby/wiki/Persistence
+        session.class.__persistent__ = true
+        session
       end
 
       # Handle connection failures
       connection.on_exception do |jms_exception|
-        logger.error "JMS Connection Exception has occurred: #{jms_exception}" if logger
-        #TODO: Close all sessions in the pool and release from the pool?
+        logger.error "JMS Connection Exception has occurred: #{jms_exception.inspect}"
       end
     end
 
@@ -83,30 +84,29 @@ module JMS
     # returned to the pool.
     #
     # Parameters:
-    #   :queue_name => String: Name of the Queue to return
-    #                  Symbol: :temporary => Create temporary queue
+    #   queue_name: [String] Name of the Queue to return
+    #               [Symbol] Create temporary queue
     #                  Mandatory unless :topic_name is supplied
     #     Or,
-    #   :topic_name => String: Name of the Topic to write to or subscribe to
-    #                  Symbol: :temporary => Create temporary topic
+    #   topic_name: [String] Name of the Topic to write to or subscribe to
+    #               [Symbol] Create temporary topic
     #                  Mandatory unless :queue_name is supplied
     #     Or,
-    #   :destination=> Explicit javaxJms::Destination to use
+    #   destination: [javaxJms::Destination] Destination to use
     #
-    #   :selector   => Filter which messages should be returned from the queue
+    #   selector:   Filter which messages should be returned from the queue
     #                  Default: All messages
-    #   :no_local   => Determine whether messages published by its own connection
+    #   no_local:   Determine whether messages published by its own connection
     #                  should be delivered to it
     #                  Default: false
     #
     # Example
-    #   session_pool.consumer(:queue_name => 'MyQueue') do |session, consumer|
+    #   session_pool.consumer(queue_name: 'MyQueue') do |session, consumer|
     #     message = consumer.receive(timeout)
     #     puts message.data if message
     #   end
     def consumer(params, &block)
       session do |s|
-        consumer = nil
         begin
           consumer = s.consumer(params)
           block.call(s, consumer)
@@ -122,23 +122,22 @@ module JMS
     # returned to the pool.
     #
     # Parameters:
-    #   :queue_name => String: Name of the Queue to send messages to
-    #                  Symbol: :temporary => Create temporary queue
+    #   queue_name: [String] Name of the Queue to return
+    #               [Symbol] Create temporary queue
     #                  Mandatory unless :topic_name is supplied
     #     Or,
-    #   :topic_name => String: Name of the Topic to send message to
-    #                  Symbol: :temporary => Create temporary topic
+    #   topic_name: [String] Name of the Topic to write to or subscribe to
+    #               [Symbol] Create temporary topic
     #                  Mandatory unless :queue_name is supplied
     #     Or,
-    #   :destination=> Explicit JMS::Destination to use
+    #   destination: [javaxJms::Destination] Destination to use
     #
     # Example
-    #   session_pool.producer(:queue_name => 'ExampleQueue') do |session, producer|
+    #   session_pool.producer(queue_name: 'ExampleQueue') do |session, producer|
     #     producer.send(session.message("Hello World"))
     #   end
     def producer(params, &block)
       session do |s|
-        producer = nil
         begin
           producer = s.producer(params)
           block.call(s, producer)
@@ -154,15 +153,9 @@ module JMS
     #
     # Note: Once closed a session pool cannot be re-used. A new instance must
     #       be created
-    #
-    # TODO: Allow an option to wait for active sessions to be returned before
-    #       closing
     def close
-      @pool.each do |s|
-        s.close
-      end
+      @pool.each { |s| s.close }
     end
 
   end
-
-end
+end

data/lib/jms/text_message.rb

@@ -1,19 +1,3 @@
-################################################################################
-#  Copyright 2008, 2009, 2010, 2011  J. Reid Morrison
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-################################################################################
-
 #Interface javax.jms.TextMessage
 module JMS::TextMessage
   def data

data/lib/jms/version.rb

@@ -1,3 +1,3 @@
 module JMS #:nodoc
-  VERSION = "1.1.0"
+  VERSION = '1.2.0'
 end

data/test/connection_test.rb

@@ -1,68 +1,43 @@
-# 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 'jms'
-require 'yaml'
-
-# Set Log4J properties file so that it does not need to be in the CLASSPATH
-java.lang.System.properties['log4j.configuration'] = "test/log4j.properties"
-
-class JMSTest < Test::Unit::TestCase
-  context 'JMS Connection' do
-    # Load configuration from jms.yml
-    setup do
-      # To change the JMS provider, edit jms.yml and change :default
-
-      # Load Connection parameters from configuration file
-      cfg = YAML.load_file(File.join(File.dirname(__FILE__), 'jms.yml'))
-      jms_provider = cfg['default']
-      @config = cfg[jms_provider]
-      raise "JMS Provider option:#{jms_provider} not found in jms.yml file" unless @config
-      @queue_name = @config.delete(:queue_name) || raise("Mandatory :queue_name missing from jms.yml")
-      @topic_name = @config.delete(:topic_name) || raise("Mandatory :topic_name missing from jms.yml")
+require_relative 'test_helper'
+
+class ConnectionTest < Minitest::Test
+  describe JMS::Connection do
+    before do
+      @config, @queue_name, @topic_name = read_config
     end
 
-    should 'Create Connection to the Broker/Server' do
+    it 'Create Connection to the Broker/Server' do
       connection = JMS::Connection.new(@config)
-      JMS::logger.info connection.to_s
-      assert_not_nil connection
+      JMS.logger.info connection.to_s
+      assert connection
       connection.close
     end
 
-    should 'Create and start Connection to the Broker/Server with block' do
+    it 'Create and start Connection to the Broker/Server with block' do
       JMS::Connection.start(@config) do |connection|
-        assert_not_nil connection
+        assert connection
       end
     end
 
-    should 'Create and start Connection to the Broker/Server with block and start one session' do
+    it 'Create and start Connection to the Broker/Server with block and start one session' do
       JMS::Connection.session(@config) do |session|
-        assert_not_nil session
+        assert session
       end
     end
 
-    should 'Start and stop connection' do
+    it 'Start and stop connection' do
       connection = JMS::Connection.new(@config)
-      assert_not_nil connection
+      assert connection
       assert_nil connection.start
 
       assert_nil connection.stop
       assert_nil connection.close
     end
 
-    should 'Create a session from the connection' do
+    it 'Create a session from the connection' do
       connection = JMS::Connection.new(@config)
-
-      session_parms = {
-        :transacted => true,
-        :options => JMS::Session::AUTO_ACKNOWLEDGE
-      }
-
-      session = connection.create_session
-      assert_not_nil session
+      session    = connection.create_session
+      assert session
       assert_equal session.transacted?, false
       assert_nil session.close
 
@@ -70,11 +45,10 @@ class JMSTest < Test::Unit::TestCase
       assert_nil connection.close
     end
 
-    should 'Create a session with a block' do
+    it 'Create a session with a block' do
       connection = JMS::Connection.new(@config)
-
       connection.session do |session|
-        assert_not_nil session
+        assert session
         assert_equal session.transacted?, false
       end
 
@@ -82,25 +56,19 @@ class JMSTest < Test::Unit::TestCase
       assert_nil connection.close
     end
 
-    should 'create a session without a block and throw exception' do
+    it 'create a session without a block and throw exception' do
       connection = JMS::Connection.new(@config)
 
-      assert_raise(RuntimeError) { connection.session }
+      assert_raises(ArgumentError) { connection.session }
 
       assert_nil connection.stop
       assert_nil connection.close
     end
 
-    should 'Create a session from the connection with params' do
+    it 'Create a session from the connection with params' do
       connection = JMS::Connection.new(@config)
-
-      session_parms = {
-        :transacted => true,
-        :options => JMS::Session::AUTO_ACKNOWLEDGE
-      }
-
-      session = connection.create_session(session_parms)
-      assert_not_nil session
+      session    = connection.create_session(transacted: true, options: JMS::Session::AUTO_ACKNOWLEDGE)
+      assert session
       assert_equal session.transacted?, true
       # When session is transacted, options are ignore, so ack mode must be transacted
       assert_equal session.acknowledge_mode, JMS::Session::SESSION_TRANSACTED
@@ -110,16 +78,10 @@ class JMSTest < Test::Unit::TestCase
       assert_nil connection.close
     end
 
-    should 'Create a session from the connection with block and params' do
+    it 'Create a session from the connection with block and params' do
       JMS::Connection.start(@config) do |connection|
-
-        session_parms = {
-          :transacted => true,
-          :options => JMS::Session::CLIENT_ACKNOWLEDGE
-        }
-
-        connection.session(session_parms) do |session|
-          assert_not_nil session
+        connection.session(transacted: true, options: JMS::Session::CLIENT_ACKNOWLEDGE) do |session|
+          assert session
           assert_equal session.transacted?, true
           # When session is transacted, options are ignore, so ack mode must be transacted
           assert_equal session.acknowledge_mode, JMS::Session::SESSION_TRANSACTED
@@ -127,33 +89,25 @@ class JMSTest < Test::Unit::TestCase
       end
     end
 
-    should 'Create a session from the connection with block and params opposite test' do
+    it 'Create a session from the connection with block and params opposite test' do
       JMS::Connection.start(@config) do |connection|
-
-        session_parms = {
-          :transacted => false,
-          :options => JMS::Session::AUTO_ACKNOWLEDGE
-        }
-
-        connection.session(session_parms) do |session|
-          assert_not_nil session
+        connection.session(transacted: false, options: JMS::Session::AUTO_ACKNOWLEDGE) do |session|
+          assert session
           assert_equal session.transacted?, false
           assert_equal session.acknowledge_mode, JMS::Session::AUTO_ACKNOWLEDGE
         end
       end
     end
 
-    context 'JMS Connection additional capabilities' do
-
-      should 'start an on_message handler' do
+    describe 'additional capabilities' do
+      it 'start an on_message handler' do
         JMS::Connection.start(@config) do |connection|
           value = nil
-          connection.on_message(:transacted => true, :queue_name => :temporary) do |message|
-            value = "received"
+          connection.on_message(transacted: true, queue_name: :temporary) do |message|
+            value = 'received'
           end
         end
       end
-
     end
 
   end

data/test/jms.yml

@@ -9,10 +9,10 @@
 # Which JMS Provider to use by default
 
 #default: hornetq222
-#default: hornetq225
+#default: hornetq2_4_0
 #default: activemq543
 #default: activemq551
-default: activemq590
+default: activemq5_11_1
 #default: webspheremq6
 #default: webspheremq7
 
@@ -43,7 +43,16 @@ activemq590:
   :queue_name: TestQueue
   :topic_name: TestTopic
 
-hornetq225:
+activemq5_11_1:
+  :factory: org.apache.activemq.ActiveMQConnectionFactory
+  :broker_url: tcp://localhost:61616
+  :require_jars:
+    - /usr/local/Cellar/activemq/5.11.1/libexec/activemq-all-5.11.1.jar
+    - /usr/local/Cellar/activemq/5.11.1/libexec/lib/optional/log4j-1.2.17.jar
+  :queue_name: TestQueue
+  :topic_name: TestTopic
+
+hornetq2_4_0:
   # Connect to a local HornetQ Broker using JNDI
   :jndi_name: /ConnectionFactory
   :jndi_context:
@@ -53,11 +62,12 @@ hornetq225:
     java.naming.security.principal: guest
     java.naming.security.credentials: guest
   :require_jars:
-    - ~/jms/hornetq-2.2.5.Final/lib/hornetq-core-client.jar
-    - ~/jms/hornetq-2.2.5.Final/lib/netty.jar
-    - ~/jms/hornetq-2.2.5.Final/lib/hornetq-jms-client.jar
-    - ~/jms/hornetq-2.2.5.Final/lib/jboss-jms-api.jar
-    - ~/jms/hornetq-2.2.5.Final/lib/jnp-client.jar
+    - /usr/local/Cellar/hornetq/2.4.0/libexec/lib/hornetq-commons.jar
+    - /usr/local/Cellar/hornetq/2.4.0/libexec/lib/hornetq-core-client.jar
+    - /usr/local/Cellar/hornetq/2.4.0/libexec/lib/hornetq-jms-client.jar
+    - /usr/local/Cellar/hornetq/2.4.0/libexec/lib/jboss-jms-api.jar
+    - /usr/local/Cellar/hornetq/2.4.0/libexec/lib/jnp-client.jar
+    - /usr/local/Cellar/hornetq/2.4.0/libexec/lib/netty.jar
   :queue_name: TestQueue
   :topic_name: TestTopic
 

data/test/message_test.rb

@@ -1,37 +1,21 @@
-# Allow examples to be run in-place without requiring a gem install
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require_relative 'test_helper'
 
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-require 'jms'
-require 'yaml'
-
-class JMSTest < Test::Unit::TestCase
-  context 'JMS Session' do
-    # Load configuration from jms.yml
-    setup do
-      # To change the JMS provider, edit jms.yml and change :default
-
-      # Load Connection parameters from configuration file
-      cfg = YAML.load_file(File.join(File.dirname(__FILE__), 'jms.yml'))
-      jms_provider = cfg['default']
-      @config = cfg[jms_provider]
-      raise "JMS Provider option:#{jms_provider} not found in jms.yml file" unless @config
-      @queue_name = @config.delete(:queue_name) || raise("Mandatory :queue_name missing from jms.yml")
-      @topic_name = @config.delete(:topic_name) || raise("Mandatory :topic_name missing from jms.yml")
+class MessageTest < Minitest::Test
+  describe 'JMS::Message' do
+    before do
+      @config, @queue_name, @topic_name = read_config
     end
 
-    should 'produce and consume messages to/from a temporary queue' do
+    it 'produce and consume messages to/from a temporary queue' do
       JMS::Connection.session(@config) do |session|
-        assert_not_nil session
+        assert session
         data = nil
-        session.producer(:queue_name => :temporary) do |producer|
+        session.producer(queue_name: :temporary) do |producer|
           # Send Message
           producer.send(session.message('Hello World'))
 
           # Consume Message
-          session.consume(:destination => producer.destination, :timeout=>1000) do |message|
+          session.consume(destination: producer.destination, timeout: 1000) do |message|
             assert_equal message.java_kind_of?(JMS::TextMessage), true
             data = message.data
           end
@@ -40,23 +24,23 @@ class JMSTest < Test::Unit::TestCase
       end
     end
 
-    should 'produce, browse and consume messages to/from a queue' do
+    it 'produce, browse and consume messages to/from a queue' do
       JMS::Connection.session(@config) do |session|
-        assert_not_nil session
-        data = :timed_out
+        assert session
+        data        = :timed_out
         browse_data = :timed_out
-        session.producer(:queue_name => @queue_name) do |producer|
+        session.producer(queue_name: @queue_name) do |producer|
           # Send Message
           producer.send(session.message('Hello World'))
 
           # Browse Message
-          session.browse(:queue_name => @queue_name, :timeout=>1000) do |message|
+          session.browse(queue_name: @queue_name, timeout: 1000) do |message|
             assert_equal message.java_kind_of?(JMS::TextMessage), true
             browse_data = message.data
           end
 
           # Consume Message
-          session.consume(:queue_name => @queue_name, :timeout=>1000) do |message|
+          session.consume(queue_name: @queue_name, timeout: 1000) do |message|
             assert_equal message.java_kind_of?(JMS::TextMessage), true
             data = message.data
           end
@@ -66,9 +50,9 @@ class JMSTest < Test::Unit::TestCase
       end
     end
 
-    should 'support setting persistence using symbols and the java constants' do
+    it 'support setting persistence using symbols and the java constants' do
       JMS::Connection.session(@config) do |session|
-        message = session.message('Hello World')
+        message                       = session.message('Hello World')
         message.jms_delivery_mode_sym = :non_persistent
         assert_equal message.jms_delivery_mode_sym, :non_persistent
         message.jms_delivery_mode_sym = :persistent
@@ -76,12 +60,12 @@ class JMSTest < Test::Unit::TestCase
       end
     end
 
-    should 'produce and consume non-persistent messages' do
+    it 'produce and consume non-persistent messages' do
       JMS::Connection.session(@config) do |session|
-        assert_not_nil session
+        assert session
         data = nil
-        session.producer(:queue_name => :temporary) do |producer|
-          message = session.message('Hello World')
+        session.producer(queue_name: :temporary) do |producer|
+          message                       = session.message('Hello World')
           message.jms_delivery_mode_sym = :non_persistent
           assert_equal :non_persistent, message.jms_delivery_mode_sym
           assert_equal false, message.persistent?
@@ -90,7 +74,7 @@ class JMSTest < Test::Unit::TestCase
           producer.send(message)
 
           # Consume Message
-          session.consume(:destination => producer.destination, :timeout=>1000) do |message|
+          session.consume(destination: producer.destination, timeout: 1000) do |message|
             assert_equal message.java_kind_of?(JMS::TextMessage), true
             data = message.data
             #assert_equal :non_persistent, message.jms_delivery_mode
@@ -101,12 +85,12 @@ class JMSTest < Test::Unit::TestCase
       end
     end
 
-    should 'produce and consume persistent messages' do
+    it 'produce and consume persistent messages' do
       JMS::Connection.session(@config) do |session|
-        assert_not_nil session
+        assert session
         data = nil
-        session.producer(:queue_name => @queue_name) do |producer|
-          message = session.message('Hello World')
+        session.producer(queue_name: @queue_name) do |producer|
+          message                       = session.message('Hello World')
           message.jms_delivery_mode_sym = :persistent
           assert_equal :persistent, message.jms_delivery_mode_sym
           assert_equal true, message.persistent?
@@ -115,7 +99,7 @@ class JMSTest < Test::Unit::TestCase
           producer.send(message)
 
           # Consume Message
-          session.consume(:destination => producer.destination, :timeout=>1000) do |message|
+          session.consume(destination: producer.destination, timeout: 1000) do |message|
             assert_equal message.java_kind_of?(JMS::TextMessage), true
             data = message.data
             assert_equal :persistent, message.jms_delivery_mode_sym