jruby-hornetq 0.2.5.alpha → 0.3.0.alpha

data/examples/{advanced/transaction-failover → transaction-failover}/consumer.rb

@@ -4,6 +4,9 @@
 #          Write messages to the queue
 #
 
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+
 require 'rubygems'
 require 'yaml'
 require 'hornetq'
@@ -14,7 +17,7 @@ config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')
 constants = config['constants']
 
 # Create a HornetQ session
-HornetQ::Client::Factory.session(config['client']) do |session|
+HornetQ::Client::Connection.session(config['client']) do |session|
   consumer = session.create_consumer(constants[:queue])
   session.start
 

data/examples/{advanced/transaction-failover → transaction-failover}/hornetq.yml

@@ -12,12 +12,15 @@ live_server:
   :security_enabled:    false
 
 client:
-  :connector:
+  :connection:
     :uri:                            hornetq://localhost:15445,localhost:15446
     :failover_on_initial_connection: true
     :failover_on_server_shutdown:    true
-    # 5 Connection attempts takes about 16 seconds before it switches to the backup server
-    :reconnect_attempts:             5
+    # Retry at 0.5, 1.0, 2.0, 4.0, 5.0
+    :reconnect_attempts:             4
+    :retry_interval:                 500
+    :retry_interval_multiplier:      2.0
+    :max_retry_interval:             5000
 
   :session:
     :username: guest

data/examples/{advanced/transaction-failover → transaction-failover}/producer.rb

@@ -4,6 +4,9 @@
 #          Write messages to the queue
 #
 
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+
 require 'rubygems'
 require 'yaml'
 require 'hornetq'
@@ -13,8 +16,8 @@ config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')
 constants = config['constants']
 
 # Create a HornetQ session
-HornetQ::Client::Factory.session(config['client']) do |session|
-  session.create_queue(constants[:address], constants[:queue], constants[:durable])
+HornetQ::Client::Connection.session(config['client']) do |session|
+  session.create_queue_ignore_exists(constants[:address], constants[:queue], constants[:durable])
   producer = session.create_producer(constants[:address])
   start_time = Time.now
 
@@ -23,7 +26,8 @@ HornetQ::Client::Factory.session(config['client']) do |session|
     message = session.create_message(HornetQ::Client::Message::TEXT_TYPE, true)
     # Set the message body text
     message.body = "Message ##{i}"
-    message.put_string_property(Java::org.hornetq.api.core.SimpleString.new(HornetQ::Client::Message::HDR_DUPLICATE_DETECTION_ID.to_s), Java::org.hornetq.api.core.SimpleString.new("uniqueid#{i}"))
+    # TODO: Figure out why this isn't working as expected
+    message[HornetQ::Client::Message::HDR_DUPLICATE_DETECTION_ID] = "uniqueid#{i}"
     # Send message to the queue
     begin
       producer.send(message)
@@ -41,3 +45,4 @@ HornetQ::Client::Factory.session(config['client']) do |session|
   duration = Time.now - start_time
   puts "Delivered #{count} messages in #{duration} seconds at #{count/duration} messages per second"
 end
+

data/examples/worker/hornetq.yml

@@ -0,0 +1,26 @@
+standalone_server:
+  :uri:                 hornetq://localhost
+  :data_directory:      ./data
+  :persistence_enabled: true
+  :security_enabled:    false
+
+client:
+  :connection:
+    :uri:   hornetq://localhost
+  :session:
+    :username:          guest
+    :password:          guest
+    :auto_close:        true
+  :session_pool:
+    :pool_size:         3
+    :pool_warn_timeout: 0.25
+    :username:          guest
+    :password:          guest
+
+  :constants:
+    :address1:    address1
+    :address2:    address2
+    :queue1_1:    queue1_1
+    :queue1_2:    queue1_2
+    :queue2_1:    queue2_1
+    :queue2_2:    queue2_2

data/examples/worker/producer.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env jruby
+#
+# HornetQ Producer:
+#          Write messages to the queue
+#
+
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+
+require 'rubygems'
+require 'yaml'
+require 'hornetq'
+require 'logger'
+require 'json'
+require 'test_object'
+
+config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')
+client = config['client']
+
+# Create a HornetQ session
+logger = Logger.new($stdout)
+connection = HornetQ::Client::Connection.new(client[:connection])
+session_pool = connection.create_session_pool(client[:session_pool])
+
+['HUP', 'INT', 'TERM'].each do |signal_name|
+  Signal.trap(signal_name) do
+    puts "caught #{signal_name}"
+    $stopped = true
+  end
+end
+
+$stopped = false
+threads = []
+(1..5).each do |i|
+  threads << Thread.new(i) do |thread_count|
+    msg_count = 0
+    while !$stopped
+      msg_count += 1
+      obj = TestObject.new("Message ##{thread_count}-#{msg_count}")
+      session_pool.producer('address1') do |session, producer|
+        message = session.create_message(HornetQ::Client::Message::BYTES_TYPE, true)
+        message.body = Marshal.dump(obj)
+        message['format'] = 'ruby_marshal'
+        puts "Sending on address1 #{obj.inspect}"
+        producer.send(message)
+      end
+      # session_pool.send('address1', obj, :persistent => true, :format => :ruby_marshal)
+      sleep 1
+    end
+  end
+end
+(6..10).each do |i|
+  threads << Thread.new(i) do |thread_count|
+    msg_count = 0
+    while !$stopped
+      msg_count += 1
+      obj = {:thread => thread_count, :message => msg_count}
+      session_pool.producer('address2') do |session, producer|
+        message = session.create_message(HornetQ::Client::Message::TEXT_TYPE, false)
+        message.body = obj.to_json
+        message['format'] = 'json'
+        puts "Sending on address2 #{obj.inspect}"
+        producer.send(message)
+      end
+      # session_pool.send('address2', obj, :persistent => false, :format => :json)
+      sleep 2
+    end
+  end
+end
+
+threads.each { |thread| thread.join }

data/examples/worker/worker.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env jruby
+#
+# HornetQ Worker:
+#          Creates multiple threads for processing of messages.
+#
+
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+
+require 'rubygems'
+require 'yaml'
+require 'hornetq'
+require 'test_object'
+require 'json'
+
+$config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')
+$client_config = $config['client']
+$session_config = $client_config[:session]
+$connection = HornetQ::Client::Connection.new($client_config[:connection])
+
+['HUP', 'INT', 'TERM'].each do |signal_name|
+  Signal.trap(signal_name) do
+    puts "caught #{signal_name}"
+    $connection.close
+  end
+end
+
+$threads = []
+def create_workers(address, queue, count, sleep_time, is_durable, &block)
+  (1..count).each do |i|
+    session = $connection.create_session($session_config)
+    puts "Creating queue address=#{address} queue=#{queue}" if i==1
+    session.create_queue_ignore_exists(address, queue, is_durable) if i == 1
+    $threads << Thread.new(i, session) do |thread_count, session|
+      prefix = "#{address}-#{queue}-#{thread_count}"
+      begin
+        consumer = session.create_consumer(queue)
+        session.start
+        puts "#{prefix} waiting for message"
+        while msg = consumer.receive
+          case msg['format']
+            when 'json'
+              object = JSON::Parser.new(msg.body).parse
+            when 'ruby_marshal'
+              object =  Marshal.load(msg.body)
+            else
+              object = msg.body
+          end
+          puts "#{prefix} read #{object.inspect}"
+          sleep sleep_time
+        end
+        puts "#{prefix} end of thread"
+      rescue Java::org.hornetq.api.core.HornetQException => e
+        if e.cause.code != Java::org.hornetq.api.core.HornetQException::OBJECT_CLOSED
+          puts "#{prefix} HornetQException: #{e.message}\n#{e.backtrace.join("\n")}"
+        else
+          # Normal exit
+        end
+      rescue Exception => e
+        puts "#{prefix} Exception: #{e.message}\n#{e.backtrace.join("\n")}"
+      end
+    end
+  end
+end
+
+create_workers('address1', 'address1', 5, 1, false)
+create_workers('address1', 'queue1_1', 5, 1, false)
+create_workers('address1', 'queue1_2', 5, 2, true)
+create_workers('address2', 'queue2_1', 5, 2, true)
+create_workers('address2', 'queue2_2', 5, 1, false)
+
+$threads.each { |thread| thread.join }

data/lib/hornetq/client.rb

@@ -8,7 +8,7 @@ module HornetQ
   end
 end
 
-require 'hornetq/client/factory'
+require 'hornetq/client/connection'
 require 'hornetq/common/org_hornetq_core_logging_logger'
 require 'hornetq/client/org_hornetq_api_core_client_client_session'
 require 'hornetq/client/org_hornetq_core_client_impl_client_message_impl'

data/lib/hornetq/client/{factory.rb → connection.rb}

@@ -1,69 +1,72 @@
 module HornetQ
   module Client
 
-    class Factory
-      # Create a new Factory and Session
+    class Connection
+      # Create a new Connection and Session
       #
-      #  Creates a new factory and session, then passes the session to the supplied
-      #  block. Upon completion the session and factory are both closed
-      # See Factory::initialize and Factory::create_session for the list
+      #  Creates a new connection and session, then passes the session to the supplied
+      #  block. Upon completion the session and connection are both closed
+      # See Connection::initialize and Connection::create_session for the list
       #  of parameters
+      #
+      # Returns result of block
       def self.session(params={},&proc)
         raise "Missing mandatory code block" unless proc
-        factory = nil
+        connection = nil
         session = nil
         begin
           if params.kind_of?(String)
             # TODO: Support passing username and password from URI to Session
-            factory = self.new(params)
-            session = factory.session({}, &proc)
+            connection = self.new(params)
+            connection.session({}, &proc)
           else
-            factory = self.new(params[:connector] || {})
-            session = factory.session(params[:session] || {}, &proc)
+            connection = self.new(params[:connection] || {})
+            connection.session(params[:session] || {}, &proc)
           end
         ensure
-          session.close if session
-          factory.close if factory
+          connection.close if connection
         end
       end
 
-      # Create a new Factory along with a Session, and then start the session
+      # Create a new Connection along with a Session, and then start the session
       #
-      #  Creates a new factory and session, then passes the session to the supplied
-      #  block. Upon completion the session and factory are both closed
-      # See Factory::initialize and Factory::create_session for the list
+      #  Creates a new connection and session, then passes the session to the supplied
+      #  block. Upon completion the session and connection are both closed
+      # See Connection::initialize and Connection::create_session for the list
       #  of parameters
-      def self.start(params={},&proc)
+      #  
+      # Returns result of block
+      def self.start_session(params={},&proc)
         session(params) do |session|
           session.start
           proc.call(session)
         end
       end
 
-      # Call the supplied code block after creating a factory instance
+      # Call the supplied code block after creating a connection instance
       # See initialize for the parameter list
-      # The factory is closed before returning
+      # The connection is closed before returning
       #
       # Returns the result of the code block
-      def self.create_factory(params={}, &proc)
+      def self.connection(params={}, &proc)
         raise "Missing mandatory code block" unless proc
-        factory = nil
+        connection = nil
         result = nil
         begin
-          factory=self.new(params)
-          result = proc.call(factory)
+          connection=self.new(params)
+          result = proc.call(connection)
         ensure
-          factory.close
+          connection.close
         end
         result
       end
 
-      # Create a new Factory from which sessions can be created
+      # Create a new Connection from which sessions can be created
       #
       # Parameters:
       # * a Hash consisting of one or more of the named parameters
       # * Summary of parameters and their default values
-      #  HornetQ::Client::Factory.new(
+      #  HornetQ::Client::Connection.new(
       #    :uri                            => 'hornetq://localhost',
       #    :ack_batch_size                 => ,
       #    :auto_group                     => ,
@@ -154,6 +157,7 @@ module HornetQ
       # * :use_global_pools
 
       def initialize(params={})
+        params =params.clone
         uri = nil
         # TODO: Support :uri as an array for cluster configurations
         if params.kind_of?(String)
@@ -166,43 +170,44 @@ module HornetQ
           params = uri.params.merge(params)
         end
 
-        @factory = nil
+        @connection = nil
+        @sessions = []
+        @consumers = []
         # In-VM Transport has no fail-over or additional parameters
         if uri.host == 'invm'
           transport = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::INVM_CONNECTOR_CLASS_NAME)
-          @factory = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport)
+          @connection = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport)
         elsif params[:protocol]
           # Auto-Discovery just has a host name and port
           if params[:protocol] == 'discovery'
-            @factory = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(uri.host, uri.port)
+            @connection = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(uri.host, uri.port)
           elsif params[:protocol] != 'netty'
             raise "Unknown HornetQ protocol:#{params[:protocol]}"
           end
         end
 
-        # Unless already created, then the factory will use the netty protocol
-        unless @factory
+        # Unless already created, then the connection will use the netty protocol
+        unless @connection
           # Primary Transport
           transport = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::NETTY_CONNECTOR_CLASS_NAME, {'host' => uri.host, 'port' => uri.port })
 
           # Check for backup server connection information
           if uri.backup_host
             backup_transport = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::NETTY_CONNECTOR_CLASS_NAME, {'host' => uri.backup_host, 'port' => uri.backup_port })
-            @factory = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport, backup_transport)
+            @connection = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport, backup_transport)
           else
-            @factory = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport)
+            @connection = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport)
           end
         end
 
-        # If any other options were supplied, apply them to the created Factory instance
+        # If any other options were supplied, apply them to the created Connection instance
         params.each_pair do |key, val|
-          next if key == :uri
           method = key.to_s+'='
-          if @factory.respond_to? method
-            @factory.send method, val
-            #puts "Debug: #{key} = #{@factory.send key}" if @factory.respond_to? key.to_sym
+          if @connection.respond_to? method
+            @connection.send method, val
+            #puts "Debug: #{key} = #{@connection.send key}" if @connection.respond_to? key.to_sym
           else
-            puts "Warning: Option:#{key}, with value:#{val} is invalid and being ignored"
+            HornetQ.logger.warn "Warning: Option:#{key}, with value:#{val} is invalid and being ignored"
           end
         end
       end
@@ -214,11 +219,11 @@ module HornetQ
       #
       # Note:
       # * The returned session MUST be closed once complete
-      #     factory = HornetQ::Client::Factory.new(:uri => 'hornetq://localhost/')
-      #     session = factory.create_session
+      #     connection = HornetQ::Client::Connection.new(:uri => 'hornetq://localhost/')
+      #     session = connection.create_session
       #       ...
       #     session.close
-      #     factory.close
+      #     connection.close
       #
       # Returns:
       # * A new HornetQ ClientSession
@@ -231,11 +236,11 @@ module HornetQ
       # Example:
       #   require 'hornetq'
       #
-      #   factory = nil
+      #   connection = nil
       #   session = nil
       #   begin
-      #     factory = HornetQ::Client::Factory.new(:uri => 'hornetq://localhost/')
-      #     session = factory.create_session
+      #     connection = HornetQ::Client::Connection.new(:uri => 'hornetq://localhost/')
+      #     session = connection.create_session
       #
       #     # Create a new queue
       #     session.create_queue('Example', 'Example', true)
@@ -251,13 +256,13 @@ module HornetQ
       #     producer.send(message)
       #   ensure
       #     session.close if session
-      #     factory.close if factory
+      #     connection.close if connection
       #   end
       #
       # Parameters:
       # * a Hash consisting of one or more of the named parameters
       # * Summary of parameters and their default values
-      #  factory.create_session(
+      #  connection.create_session(
       #   :username          => 'my_username',   # Default is no authentication
       #   :password          => 'password',      # Default is no authentication
       #   :xa                => false,
@@ -300,9 +305,18 @@ module HornetQ
       #  * :ack_batch_size
       #    * the batch size of the acknowledgements
       #
+      # * :managed
+      #   * true: The session will be managed by the connection. It will be
+      #           closed when the connection is closed.
+      #           Also the session will be started or stopped when
+      #           Connection#start_managed_sessions or
+      #           Connection#stop_managed_sessions is called
+      #   * false: The caller is responsible for closing the session
+      #   * Default: false
+      #
       def create_session(params={})
-        raise "HornetQ::Client::Factory Already Closed" unless @factory
-        @factory.create_session(
+        raise "HornetQ::Client::Connection Already Closed" unless @connection
+        session = @connection.create_session(
           params[:username],
           params[:password],
           params[:xa] || false,
@@ -310,6 +324,8 @@ module HornetQ
           params[:auto_commit_acks].nil? ? true : params[:auto_commit_acks],
           params[:pre_acknowledge] || false,
           params[:ack_batch_size] || 1)
+        (@sessions << session) if params.fetch(:managed, false)
+        session
       end
 
       # Create a session, call the supplied block and once it completes
@@ -318,34 +334,23 @@ module HornetQ
       #
       # Returns the result of the block
       #
-      # Example
-      #     HornetQ::Client::Factory.create_session(:uri => 'hornetq://localhost/') do |session|
-      #       session.create_queue("Address", "Queue")
-      #     end
-      #
       # Example:
       #   require 'hornetq'
       #
-      #   factory = nil
-      #   begin
-      #     factory = HornetQ::Client::Factory.new(:uri => 'hornetq://localhost/')
-      #     factory.create_session do |session|
-      #
-      #       # Create a new queue
-      #       session.create_queue('Example', 'Example', true)
+      #   HornetQ::Client::Connection.connection('hornetq://localhost/') do |connection
+      #     connection.session do |session|
       #
       #       # Create a producer to send messages
-      #       producer = session.create_producer('Example')
+      #       session.producer('Example') do |producer|
       #
-      #       # Create a Text Message
-      #       message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,true)
-      #       message.body = 'Hello World'
+      #         # Create a Text Message
+      #         message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,true)
+      #         message.body = 'Hello World'
       #
-      #       # Send the message
-      #       producer.send(message)
+      #         # Send the message
+      #         producer.send(message)
+      #       end
       #     end
-      #   ensure
-      #     factory.close if factory
       #   end
       def session(params={}, &proc)
         raise "HornetQ::Client::session mandatory block missing" unless proc
@@ -358,17 +363,54 @@ module HornetQ
         end
       end
 
+      # Create a session, start the session, call the supplied block 
+      # and once the block completes close the session.
+      # 
+      # See: #session_create for the Parameters
+      #
+      # Returns the result of the block
+      #
+      #
+      # Example:
+      #   require 'hornetq'
+      #
+      #   HornetQ::Client::Connection.connection('hornetq://localhost/') do |connection
+      #     # Must start the session other we cannot consume messages using it
+      #     connection.start_session do |session|
+      #
+      #       # Create a consumer to receive messages
+      #       session.consumer('TestQueue') do |consumer|
+      #
+      #         consumer.each do |message|
+      #           message.acknowledge
+      #         end
+      #
+      #       end
+      #     end
+      #   end
+      def start_session(params={}, &proc)
+        raise "HornetQ::Client::session mandatory block missing" unless proc
+        session = nil
+        begin
+          session = create_session(params)
+          session.start
+          proc.call(session)
+        ensure
+          session.close if session
+        end
+      end
+
       # Create a Session pool
-      # TODO Raise an exception when gene_pool is not available
       def create_session_pool(params={})
         require 'hornetq/client/session_pool'
         SessionPool.new(self, params)
       end
 
-      # Close Factory connections
+      # Close Connection connections
       def close
-        @factory.close if @factory
-        @factory = nil
+        @sessions.each { |session| session.close }
+        @connection.close if @connection
+        @connection = nil
       end
 
       # Receive messages in a separate thread when they arrive
@@ -392,13 +434,16 @@ module HornetQ
       #                    Default: 1
       #
       # Consumer Parameters:
-      #   :queue_name => Name of the Queue to read messages from
-      #
-      #   :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
+      #   :queue_name  => The name of the queue to consume messages from. Mandatory
+      #   :filter      => Only consume messages matching the filter: Default: nil
+      #   :browse_only => Whether to just browse the queue or consume messages
+      #                   true | false. Default: false
+      #   :window_size => The consumer window size.
+      #   :max_rate    => The maximum rate to consume messages.
+      #   :auto_start  => Immediately start processing messages.
+      #                   If set to false, call Connection#start_managed_sessions
+      #                   to manually start receive messages later
+      #                   Default: true
       #
       #   :statistics Capture statistics on how many messages have been read
       #      true  : This method will capture statistics on the number of messages received
@@ -418,17 +463,18 @@ module HornetQ
       #          Any Exception => The session is rolled back
       #
       # Notes:
-      # * Remember to call ::start on the factory otherwise the on_message will not
+      # * Remember to call ::start on the connection otherwise the on_message will not
       #   start consuming any messages
       # * Remember to call message.acknowledge before completing the block so that
       #       the message will be removed from the queue
       # * If the block throws an exception, the
-      def on_message(parms, &proc)
-        consumer_count = parms[:session_count] || 1
+      def on_message(params, &proc)
+        consumer_count = params[:session_count] || 1
         consumer_count.times do
-          session = self.create_session(parms)
-          consumer = session.create_consumer_from_params(parms)
-          consumer.on_message(parms, &proc)
+          session = self.create_session(params)
+          consumer = session.create_consumer_from_params(params)
+          consumer.on_message(params, &proc)
+          session.start if params.fetch(:auto_start, true)
           @consumers << consumer
           @sessions << session
         end
@@ -437,7 +483,28 @@ module HornetQ
       def on_message_statistics
         @consumers.collect{|consumer| consumer.on_message_statistics}
       end
+      
+      # Start all sessions managed by this connection
+      # 
+      # Sessions created via #create_session are not managed unless
+      # :auto_close => true was specified when the session was created
+      # 
+      # Session are Only managed when created through the following methods:
+      #   Connection#on_message
+      #   Connection#create_session And :auto_close => true
+      #
+      # This call does not do anything to sessions in a session pool
+      def start_managed_sessions
+        @sessions.each {|session| session.start}
+      end
 
+      # Stop all sessions managed by this connection so that they no longer
+      # receive messages for processing
+      #
+      # See: #start_managed_sessions for details on which sessions are managed
+      def stop_managed_sessions
+        @sessions.each {|session| session.stop}
+      end
     end
   end  
 end