jruby-jms 0.10.2 → 0.11.0

data/lib/jms/{javax_jms_session.rb → session.rb}

@@ -17,13 +17,13 @@
 # For each thread that will be processing messages concurrently a separate
 # session is required. All sessions can share a single connection to the same
 # JMS Provider.
-# 
+#
 # Interface javax.jms.Session
-# 
+#
 # See: http://download.oracle.com/javaee/6/api/javax/jms/Session.html
-# 
+#
 # Other methods still directly accessible through this class:
-# 
+#
 # create_browser(queue, message_selector)
 #   Creates a QueueBrowser object to peek at the messages on the specified queue using a message selector.
 #
@@ -32,9 +32,9 @@
 #
 # create_consumer(destination)
 #   Creates a MessageConsumer for the specified destination
-#   See: Connection::consumer 
-#   
-#   Example: 
+#   See: Connection::consumer
+#
+#   Example:
 #      destination = session.create_destination(:queue_name => "MyQueue")
 #      session.create_consumer(destination)
 #
@@ -49,7 +49,7 @@
 #
 # create_durable_subscriber(Topic topic, java.lang.String name, java.lang.String messageSelector, boolean noLocal)
 #   Creates a durable subscriber to the specified topic, using a message selector and specifying whether messages published by its own connection should be delivered to it.
-#   
+#
 #	create_map_Message()
 #   Creates a MapMessage object
 #
@@ -107,7 +107,8 @@
 # unsubscribe(name)
 #   Unsubscribes a durable subscription that has been created by a client
 #
-module javax.jms::Session
+# Interface javax.jms.Session
+module JMS::Session
   # Create a new message instance based on the type of the data being supplied
   #   String (:to_str)    => TextMessage
   #   Hash   (:each_pair) => MapMessage
@@ -129,13 +130,13 @@ module javax.jms::Session
   end
 
   # Create the destination based on the parameter supplied
-  # 
+  #
   # The idea behind this method is to allow the decision as to whether
   # one is sending to a topic or destination to be transparent to the code.
   # The supplied parameters can be externalized into say a YAML file
   # so that today it writes to a queue, later it can be changed to write
   # to a topic so that multiple parties can receive the same messages.
-  # 
+  #
   # Note: For Temporary Queues and Topics, remember to delete them when done
   #       or just use ::destination instead with a block and it will take care
   #       of deleting them for you
@@ -167,11 +168,11 @@ module javax.jms::Session
   #
   # Returns the result of the supplied block
   def create_destination(params)
-    # Allow a Java JMS destination object to be passed in 
-    return params[:destination] if params[:destination] && params[:destination].java_kind_of?(javax.jms::Destination)
-    
-    # :queue_name is deprecated
-    queue_name = params[:queue_name] || params[:queue_name]
+    # Allow a Java JMS destination object to be passed in
+    return params[:destination] if params[:destination] && params[:destination].java_kind_of?(JMS::Destination)
+
+    # :q_name is deprecated
+    queue_name = params[:queue_name] || params[:q_name]
     topic_name = params[:topic_name]
     raise "Missing mandatory parameter :queue_name or :topic_name to Session::producer, Session::consumer, or Session::browser" unless queue_name || topic_name
 
@@ -181,9 +182,9 @@ module javax.jms::Session
       topic_name == :temporary ? create_temporary_topic : create_topic(topic_name)
     end
   end
-  
+
   # Create a queue or topic to send or receive messages from
-  # 
+  #
   # A block must be supplied so that if it is a temporary topic or queue
   # it will be deleted after the proc is complete
   #
@@ -223,7 +224,7 @@ module javax.jms::Session
       # Delete Temporary Queue / Topic
       dest.delete if dest && dest.respond_to?(:delete)
     end
-  end  
+  end
 
   # Return the queue matching the queue name supplied
   # Call the Proc if supplied
@@ -291,12 +292,9 @@ module javax.jms::Session
   #                  Symbol: :temporary => Create temporary topic
   #                  Mandatory unless :queue_name is supplied
   #     Or,
-  #   :destination=> Explicit javax.jms::Destination to use
+  #   :destination=> Explicit JMS::Destination to use
   def producer(params, &proc)
-    destination = create_destination(params)
-    # Call original java method with this destination
-    #p = java_send :create_producer, [javax.jms::Destination], destination
-    p = create_producer(destination)
+    p = self.create_producer(self.create_destination(params))
     if proc
       begin
         proc.call(p)
@@ -314,7 +312,7 @@ module javax.jms::Session
   # Call the Proc if supplied, then automatically close the consumer
   #
   # Parameters:
-  #   :queue_name     => String: Name of the Queue to return
+  #   :queue_name => String: Name of the Queue to return
   #                  Symbol: :temporary => Create temporary queue
   #                  Mandatory unless :topic_name is supplied
   #     Or,

data/lib/jms/session_pool.rb

@@ -0,0 +1,148 @@
+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_warn_timeout Number of seconds to wait before logging a warning when a
+  #                      session in the pool is not available. Measured in seconds
+  #                      Default: 5.0
+  #   :pool_logger       Supply a logger that responds to #debug, #info, #warn and #debug?
+  #                      For example: Rails.logger
+  #                      Default: None
+  # 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]
+      # 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,
+        :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
+    def session(&block)
+      #TODO Check if session is open?
+      @pool.with_connection &block
+      #TODO Catch connection failures and release from pool?
+    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
+    #
+    # TODO: Allow an option to wait for active sessions to be returned before
+    #       closing
+    def close
+      @pool.each do |s|
+        #@pool.remove(s)
+        s.close
+        #@pool.remove(s)
+      end
+    end
+
+  end
+
+end

data/lib/jms/{javax_jms_text_message.rb → text_message.rb}

@@ -15,7 +15,7 @@
 ################################################################################
 
 #Interface javax.jms.TextMessage
-module javax.jms::TextMessage
+module JMS::TextMessage
   def data
     getText
   end

data/test/connection_test.rb

@@ -12,12 +12,14 @@ class JMSTest < Test::Unit::TestCase
     # 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
@@ -32,114 +34,114 @@ class JMSTest < Test::Unit::TestCase
         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 = { 
+
+      session_parms = {
         :transacted => true,
-        :options => javax.jms.Session::AUTO_ACKNOWLEDGE
+        :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 = { 
+
+      session_parms = {
         :transacted => true,
-        :options => javax.jms.Session::AUTO_ACKNOWLEDGE
+        :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, javax.jms.Session::SESSION_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 = { 
+
+        session_parms = {
           :transacted => true,
-          :options => javax.jms.Session::CLIENT_ACKNOWLEDGE
+          :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, javax.jms.Session::SESSION_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 = { 
+
+        session_parms = {
           :transacted => false,
-          :options => javax.jms.Session::AUTO_ACKNOWLEDGE
+          :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, javax.jms.Session::AUTO_ACKNOWLEDGE
+          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
@@ -148,8 +150,8 @@ class JMSTest < Test::Unit::TestCase
           end
         end
       end
-      
+
     end
-    
+
   end
 end