jruby-jms 1.1.0-java

data/lib/jms/session_pool.rb

@@ -0,0 +1,168 @@
+require 'gene_pool'
+
+module JMS
+  # 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
+  # multiple threads.
+  #
+  # Each thread can request a session and then return it once it is no longer
+  # needed by that thread. The only way to get a session is pass a block so that
+  # the Session is automatically returned to the pool upon completion of the block.
+  #
+  # Parameters:
+  #   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
+  #   :pool_timeout      Number of seconds to wait before raising a TimeoutError
+  #                      if no sessions are available in the poo
+  #                      Default: 60
+  #   :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
+  # Example:
+  #   session_pool = connection.create_session_pool(config)
+  #   session_pool.session do |session|
+  #      ....
+  #   end
+  class SessionPool
+    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
+      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)
+      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?
+      end
+    end
+
+    # 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
+    #
+    # In the event a JMS Exception is thrown the session will be closed and removed
+    # from the pool to prevent re-using sessions that are no longer valid
+    def session(&block)
+      s = nil
+      begin
+        s = @pool.checkout
+        block.call(s)
+      rescue javax.jms.JMSException => e
+        s.close rescue nil
+        @pool.remove(s)
+        s = nil # Do not check back in since we have removed it
+        raise e
+      ensure
+        @pool.checkin(s) if s
+      end
+    end
+
+    # Obtain a session from the pool and create a MessageConsumer.
+    # Pass both into the supplied block.
+    # Once the block is complete the consumer is closed and the session is
+    # returned to the pool.
+    #
+    # Parameters:
+    #   :queue_name => String: Name of the Queue to return
+    #                  Symbol: :temporary => 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
+    #                  Mandatory unless :queue_name is supplied
+    #     Or,
+    #   :destination=> Explicit javaxJms::Destination to use
+    #
+    #   :selector   => Filter which messages should be returned from the queue
+    #                  Default: All messages
+    #   :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|
+    #     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)
+        ensure
+          consumer.close if consumer
+        end
+      end
+    end
+
+    # Obtain a session from the pool and create a MessageProducer.
+    # Pass both into the supplied block.
+    # Once the block is complete the producer is closed and the session is
+    # returned to the pool.
+    #
+    # Parameters:
+    #   :queue_name => String: Name of the Queue to send messages to
+    #                  Symbol: :temporary => 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
+    #                  Mandatory unless :queue_name is supplied
+    #     Or,
+    #   :destination=> Explicit JMS::Destination to use
+    #
+    # Example
+    #   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)
+        ensure
+          producer.close if producer
+        end
+      end
+    end
+
+    # Immediately Close all sessions in the pool and release from the pool
+    #
+    # Note: This is an immediate close, active sessions will be aborted
+    #
+    # 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
+    end
+
+  end
+
+end

data/lib/jms/text_message.rb

@@ -0,0 +1,31 @@
+################################################################################
+#  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
+    getText
+  end
+
+  def data=(val)
+    setText(val.to_s)
+  end
+
+  def to_s
+    data
+  end
+
+end

data/lib/jms/version.rb

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

data/nbproject/private/private.properties

@@ -0,0 +1,3 @@
+file.reference.jruby-jms-examples=/Users/rmorrison/Sandbox/jruby-jms/examples
+file.reference.jruby-jms-lib=/Users/rmorrison/Sandbox/jruby-jms/lib
+file.reference.jruby-jms-test=/Users/rmorrison/Sandbox/jruby-jms/test

data/nbproject/private/rake-d.txt

@@ -0,0 +1,5 @@
+clean=Remove any temporary products.
+clobber=Remove any generated file.
+doc=Generate RDOC documentation
+gem=Build gem
+test=Run Test Suite

data/parallel_minion.gemspec

@@ -0,0 +1,21 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain gem's version:
+require 'jms/version'
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |spec|
+  spec.name        = 'jruby-jms'
+  spec.version     = JMS::VERSION
+  spec.platform    = 'java'
+  spec.authors     = ['Reid Morrison']
+  spec.email       = ['reidmo@gmail.com']
+  spec.homepage    = 'https://github.com/reidmorrison/jruby-jms'
+  spec.summary     = 'JRuby interface into JMS'
+  spec.description = 'JRuby-JMS is a Java and Ruby library that exposes the Java JMS API in a ruby friendly way. For JRuby only.'
+  spec.files       = FileList["./**/*"].exclude('*.gem', './nbproject/*').map{|f| f.sub(/^\.\//, '')}
+  spec.test_files  = Dir["test/**/*"]
+  spec.license     = "Apache License V2.0"
+  spec.has_rdoc    = true
+  spec.add_dependency 'gene_pool'
+end

data/test/connection_test.rb

@@ -0,0 +1,160 @@
+# 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")
+    end
+
+    should 'Create Connection to the Broker/Server' do
+      connection = JMS::Connection.new(@config)
+      JMS::logger.info connection.to_s
+      assert_not_nil connection
+      connection.close
+    end
+
+    should 'Create and start Connection to the Broker/Server with block' do
+      JMS::Connection.start(@config) do |connection|
+        assert_not_nil connection
+      end
+    end
+
+    should '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
+      end
+    end
+
+    should 'Start and stop connection' do
+      connection = JMS::Connection.new(@config)
+      assert_not_nil connection
+      assert_nil connection.start
+
+      assert_nil connection.stop
+      assert_nil connection.close
+    end
+
+    should '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
+      assert_equal session.transacted?, false
+      assert_nil session.close
+
+      assert_nil connection.stop
+      assert_nil connection.close
+    end
+
+    should 'Create a session with a block' do
+      connection = JMS::Connection.new(@config)
+
+      connection.session do |session|
+        assert_not_nil session
+        assert_equal session.transacted?, false
+      end
+
+      assert_nil connection.stop
+      assert_nil connection.close
+    end
+
+    should 'create a session without a block and throw exception' do
+      connection = JMS::Connection.new(@config)
+
+      assert_raise(RuntimeError) { connection.session }
+
+      assert_nil connection.stop
+      assert_nil connection.close
+    end
+
+    should '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
+      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
+      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
+      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
+          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
+        end
+      end
+    end
+
+    should '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
+          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
+        JMS::Connection.start(@config) do |connection|
+          value = nil
+          connection.on_message(:transacted => true, :queue_name => :temporary) do |message|
+            value = "received"
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/test/jms.yml

@@ -0,0 +1,111 @@
+# This YAML file contains the configuration options for several different
+# JMS Providers
+#
+# The Examples that ship with jruby-jms will use the entry 'default' unless
+# overriden at the command line. For example:
+#    jruby producer.rb activemq
+#
+---
+# Which JMS Provider to use by default
+
+#default: hornetq222
+#default: hornetq225
+#default: activemq543
+#default: activemq551
+default: activemq590
+#default: webspheremq6
+#default: webspheremq7
+
+activemq543:
+  :factory: org.apache.activemq.ActiveMQConnectionFactory
+  :broker_url: tcp://localhost:61616
+  :require_jars:
+    - ~/jms/apache-activemq-5.4.3/activemq-all-5.4.3.jar
+  :queue_name: TestQueue
+  :topic_name: TestTopic
+
+activemq551:
+  :factory: org.apache.activemq.ActiveMQConnectionFactory
+  :broker_url: tcp://localhost:61616
+  :require_jars:
+    - ~/jms/apache-activemq-5.5.1/activemq-all-5.5.1.jar
+    - ~/jms/apache-activemq-5.5.1/lib/optional/slf4j-log4j12-1.5.11.jar
+    - ~/jms/apache-activemq-5.5.1/lib/optional/log4j-1.2.14.jar
+  :queue_name: TestQueue
+  :topic_name: TestTopic
+
+activemq590:
+  :factory: org.apache.activemq.ActiveMQConnectionFactory
+  :broker_url: tcp://localhost:61616
+  :require_jars:
+    - /usr/local/Cellar/activemq/5.9.0/libexec/activemq-all-5.9.0.jar
+    - /usr/local/Cellar/activemq/5.9.0/libexec/lib/optional/log4j-1.2.17.jar
+  :queue_name: TestQueue
+  :topic_name: TestTopic
+
+hornetq225:
+  # Connect to a local HornetQ Broker using JNDI
+  :jndi_name: /ConnectionFactory
+  :jndi_context:
+    java.naming.factory.initial: org.jnp.interfaces.NamingContextFactory
+    java.naming.provider.url: jnp://localhost:1099
+    java.naming.factory.url.pkgs: org.jboss.naming:org.jnp.interfaces
+    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
+  :queue_name: TestQueue
+  :topic_name: TestTopic
+
+hornetq222:
+  # Connect to a local HornetQ Broker using JNDI
+  :jndi_name: /ConnectionFactory
+  :jndi_context:
+    java.naming.factory.initial: org.jnp.interfaces.NamingContextFactory
+    java.naming.provider.url: jnp://localhost:1099
+    java.naming.factory.url.pkgs: org.jboss.naming:org.jnp.interfaces
+    java.naming.security.principal: guest
+    java.naming.security.credentials: guest
+  :require_jars:
+    - ~/jms/hornetq-2.2.2.Final/lib/hornetq-core-client.jar
+    - ~/jms/hornetq-2.2.2.Final/lib/netty.jar
+    - ~/jms/hornetq-2.2.2.Final/lib/hornetq-jms-client.jar
+    - ~/jms/hornetq-2.2.2.Final/lib/jboss-jms-api.jar
+    - ~/jms/hornetq-2.2.2.Final/lib/jnp-client.jar
+  :queue_name: TestQueue
+  :topic_name: TestTopic
+
+webspheremq7:
+  :factory: com.ibm.mq.jms.MQConnectionFactory
+  :queue_manager: MYQM
+  :host_name: 127.0.0.1
+  :channel: SRVCONCHA
+  :port: 61414
+  # Transport Type: com.ibm.mq.jms.JMSC::MQJMS_TP_CLIENT_MQ_TCPIP
+  :transport_type: 1
+  :username: mqm
+  :require_jars:
+    - ~/jms/libs-ibmqm7/com.ibm.mqjms.jar
+    - ~/jms/libs-ibmqm7/jms.jar
+    - ~/jms/libs-ibmqm7/com.ibm.mq.jmqi.jar
+    - ~/jms/libs-ibmqm7/dhbcore.jar
+  :queue_name: TestQueue
+  :topic_name: TestTopic
+
+webspheremq6:
+  :factory: com.ibm.mq.jms.MQConnectionFactory
+  :queue_manager: MYQM
+  :host_name: 127.0.0.1
+  :channel: SRVCONCHA
+  :port: 61414
+  # Transport Type: com.ibm.mq.jms.JMSC::MQJMS_TP_CLIENT_MQ_TCPIP
+  :transport_type: 1
+  :username: mqm
+  :require_jars:
+    - ~/jms/libs-ibmqm6/com.ibm.mqjms.jar
+  :queue_name: TestQueue
+  :topic_name: TestTopic