jruby-hornetq 0.2.3.alpha → 0.2.5.alpha

data/lib/hornetq/client/message_handler.rb

@@ -0,0 +1,63 @@
+module HornetQ::Client
+
+  # For internal use only
+  class MessageHandler
+    include Java::org.hornetq.api.core.client::MessageHandler
+
+    # Parameters:
+    #   :statistics Capture statistics on how many messages have been read
+    #      true  : Capture statistics on the number of messages received
+    #              and the time it took to process them.
+    #              The timer starts when the listener instance is created and finishes when either the last message was received,
+    #              or when Consumer::on_message_statistics is called. In this case on_message_statistics::statistics
+    #              can be called several times during processing without affecting the end time.
+    #              The start time and message count is never reset for this instance
+    def initialize(parms={}, &proc)
+      @proc = proc
+
+      if parms[:statistics]
+        @message_count = 0
+        @start_time = Time.now
+      end
+    end
+
+    # Method called for every message received on the queue
+    # Per the specification, this method will be called sequentially for each message on the queue.
+    # This method will not be called again until its prior invocation has completed.
+    # Must be onMessage() since on_message() does not work for interface methods that must be implemented
+    def onMessage(message)
+      begin
+        if @message_count
+          @message_count += 1
+          @last_time = Time.now
+        end
+        @proc.call message
+      rescue SyntaxError, NameError => boom
+        HornetQ::logger.error "Unhandled Exception processing Message. Doesn't compile: " + boom
+        HornetQ::logger.error "Ignoring poison message:\n#{message.inspect}"
+        HornetQ::logger.error boom.backtrace.join("\n")
+      rescue StandardError => bang
+        HornetQ::logger.error "Unhandled Exception processing Message. Doesn't compile: " + bang
+        HornetQ::logger.error "Ignoring poison message:\n#{message.inspect}"
+        HornetQ::logger.error boom.backtrace.join("\n")
+      rescue => exc
+        HornetQ::logger.error "Unhandled Exception processing Message. Exception occurred:\n#{exc}"
+        HornetQ::logger.error "Ignoring poison message:\n#{message.inspect}"
+        HornetQ::logger.error exc.backtrace.join("\n")
+      end
+    end
+
+    # Return Statistics gathered for this listener
+    # Note: These statistics are only useful if the queue is pre-loaded with messages
+    #       since the timer start immediately and stops on the last message received
+    def statistics
+      raise "First call Consumer::on_message with :statistics=>true before calling MessageConsumer::statistics()" unless @message_count
+      duration =(@last_time || Time.now) - @start_time
+      { 
+        :messages => @message_count,
+        :duration => duration,
+        :messages_per_second => (@message_count/duration).to_i
+      }
+    end
+  end
+end

data/lib/hornetq/client/org_hornetq_api_core_client_client_session.rb

@@ -1,16 +1,171 @@
 # Add methods to Session Interface
+# For more information on methods, see:
+# http://hornetq.sourceforge.net/docs/hornetq-2.1.0.Final/api/index.html?org/hornetq/api/core/client/ClientSession.html
 module Java::org.hornetq.api.core.client::ClientSession
   
+  # Document Methods from Java Docs:
+  # create_queue(address, queue_name, durable?)
+
+  # Creates a ClientConsumer to consume or browse messages matching the filter 
+  # from the queue with the given name, calls the supplied block, then close the
+  # consumer
+  # 
+  # If the parameter is a String, then it must be the queue name to consume
+  # messages from. Otherwise, the parameters can be supplied in a Hash
+  # 
+  # The parameters for creating the consumer are as follows:
+  #   :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.
+  #   
+  #   Note: If either :window_size or :max_rate is supplied, then BOTH are required
+  #  
+  # Returns the result from the block
+  #  
+  # Example
+  #   session.consumer('my_queue') do |consumer|
+  #     msg = consumer.receive_immediate
+  #     p msg
+  #     msg.acknowledge
+  #   end
+  #   
+  # Example
+  #   # Just browse the messages without consuming them
+  #   session.consumer(:queue_name => 'my_queue', :browse_only => true) do |consumer|
+  #     msg = consumer.receive_immediate
+  #     p msg
+  #     msg.acknowledge
+  #   end
+  def consumer(params={}, &block)
+    consumer = nil
+    begin
+      consumer = create_consumer_from_params(params)
+      block.call(consumer)
+    ensure
+      consumer.close if consumer
+    end
+  end
+  
+  # Deprecated
+  def create_consumer_from_params(params={})
+    queue_name = params.kind_of?(Hash) ? params[:queue_name] : params
+    raise("Missing mandatory parameter :queue_name") unless queue_name
+    
+    if params[:max_rate] || params[:window_size]
+      self.create_consumer(
+        queue_name, 
+        params[:filter], 
+        params[:window_size],
+        params[:max_rate],
+        params[:browse_only].nil? ? false : params[:browse_only])
+    else
+      self.create_consumer(
+        queue_name, 
+        params[:filter], 
+        params[:browse_only].nil? ? false : params[:browse_only])
+    end
+  end
+
+  # Creates a ClientProducer to send messages, calls the supplied block, 
+  # then close the consumer
+  #  
+  # If the parameter is a String, then it must be the address to send messages to
+  # Otherwise, the parameters can be supplied in a Hash
+  # 
+  # The parameters for creating the consumer are as follows:
+  #   :address     => The address to which to send messages. If not supplied here,
+  #                   then the destination address must be supplied with every message
+  #   :rate        => The producer rate
+  #   
+  # Returns the result from the block
+  #  
+  # Example
+  #   session.producer('MyAddress') do |producer|
+  #     msg = session.create_message
+  #     msg.type = :text
+  #     producer.send(msg)
+  #   end
+  #   
+  # Example
+  #   # Send to a different address with each message
+  #   session.producer do |producer|
+  #     msg = session.create_message
+  #     msg.type = :text
+  #     producer.send('Another address', msg)
+  #   end
+  def producer(params=nil, &block)
+    address = nil
+    rate = nil
+    if params.kind_of?(Hash)
+      address = params[:address]
+      rate = params[:rate]
+    else
+      address = params
+    end
+    
+    producer = nil
+    begin
+      producer = if rate
+        self.create_producer(address, rate)
+      elsif address
+        self.create_producer(address)
+      else
+        self.create_producer
+      end
+      block.call(producer)
+    ensure
+      producer.close if producer
+    end
+  end
+    
   # To be consistent create Requestor from Session
   def create_requestor(request_address)
     #Java::org.hornetq.api.core.client::ClientRequestor.new(self, request_address);
-    HornetQ::Client::Requestor.new(self, request_address)
+    HornetQ::Client::RequestorPattern.new(self, request_address)
+  end
+  
+  # Creates a RequestorPattern to send a request and to synchronously wait for
+  # the reply, call the supplied block, then close the requestor
+  # Returns the result from the block
+  def requestor(request_address)
+    requestor = nil
+    begin
+      requestor = self.create_requestor(request_address)
+      block.call(requestor)
+    ensure
+      requestor.close if requestor
+    end
   end
   
   # Create a server handler for receiving requests and responding with
   # replies to the supplied address
   def create_server(input_queue, timeout=0)
-    HornetQ::Client::Server.new(self, input_queue, timeout)
+    HornetQ::Client::ServerPattern.new(self, input_queue, timeout)
+  end
+
+  # Creates a ServerPattern to send messages to consume messages and send
+  # replies, call the supplied block, then close the server
+  # Returns the result from the block
+  def server(input_queue, timeout=0, &block)
+    server = nil
+    begin
+      server = self.create_server(input_queue, timeout)
+      block.call(server)
+    ensure
+      server.close if server
+    end
   end
+  
+  def create_queue_ignore_exists(address, queue, durable)
+    begin
+      create_queue(address, queue, durable)
+    rescue Java::org.hornetq.api.core.HornetQException => e
+      raise unless e.cause.code == Java::org.hornetq.api.core.HornetQException::QUEUE_EXISTS
+    end
+  end
+
 end
 

data/lib/hornetq/client/org_hornetq_core_client_impl_client_consumer_impl.rb

@@ -0,0 +1,94 @@
+# Consumer Class
+
+# For the HornetQ Java documentation for this class see:
+#  http://hornetq.sourceforge.net/docs/hornetq-2.1.0.Final/api/index.html?org/hornetq/api/core/client/ClientConsumer.html
+
+class Java::org.hornetq.core.client.impl::ClientConsumerImpl
+  
+  # For each message available to be consumed call the block supplied
+  # 
+  # Returns the statistics gathered when :statistics => true, otherwise nil
+  #
+  # Parameters:
+  #   :timeout How to timeout waiting for messages
+  #     -1 : Wait forever
+  #      0 : Return immediately if no message is available (default)
+  #      x : Wait for x milli-seconds for a message to be received from the server
+  #           Note: Messages may still be on the queue, but the server has not supplied any messages
+  #                 in the time interval specified
+  #      Default: 0
+  #
+  #   :statistics Capture statistics on how many messages have been read
+  #      true  : This method will capture statistics on the number of messages received
+  #              and the time it took to process them.
+  #              Statistics are cumulative between calls to ::each and will only be
+  #              reset when ::each is called again with :statistics => true
+  def each(parms={}, &proc)
+    raise "Consumer::each requires a code block to be executed for each message received" unless proc
+
+    message_count = nil
+    start_time = nil
+    timeout = (parms[:timeout] || 0).to_i
+
+    if parms[:statistics]
+      message_count = 0
+      start_time = Time.now
+    end
+
+    # Receive messages according to timeout
+    while message = self.receive_with_timeout(timeout) do
+      proc.call(message)
+      message_count += 1 if message_count
+    end
+
+    unless message_count.nil?
+      duration = Time.now - start_time
+      {:messages => message_count,
+        :duration => duration,
+        :messages_per_second => (message_count/duration).to_i}
+    end
+  end
+  
+  # Receive messages in a separate thread when they arrive
+  # Allows messages to be received in a separate thread. I.e. Asynchronously
+  # This method will return to the caller before messages are processed.
+  # It is then the callers responsibility to keep the program active so that messages
+  # can then be processed.
+  #
+  # Parameters:
+  #   :statistics Capture statistics on how many messages have been read
+  #      true  : This method will capture statistics on the number of messages received
+  #              and the time it took to process them.
+  #              The timer starts when each() is called and finishes when either the last message was received,
+  #              or when Destination::statistics is called. In this case MessageConsumer::statistics
+  #              can be called several times during processing without affecting the end time.
+  #              Also, the start time and message count is not reset until MessageConsumer::each
+  #              is called again with :statistics => true
+  #
+  #              The statistics gathered are returned when :statistics => true and :async => false
+  #
+  def on_message(parms={}, &proc)
+    raise "Consumer::on_message requires a code block to be executed for each message received" unless proc
+
+    @listener = HornetQ::Client::MessageHandler.new(parms, &proc)
+    self.setMessageListener @listener
+  end
+
+  # Return the current statistics for a running ::on_message
+  def on_message_statistics
+    stats = @listener.statistics if @listener
+    raise "First call Consumer::on_message with :statistics=>true before calling Consumer::statistics()" unless stats
+    stats
+  end
+  
+  private
+  def receive_with_timeout(timeout)
+    if timeout == -1
+      self.receive
+    elsif timeout == 0
+      self.receive_immediate
+    else
+      self.receive(timeout)
+    end
+  end
+end

data/lib/hornetq/client/org_hornetq_core_client_impl_client_message_impl.rb

@@ -32,15 +32,8 @@ class Java::OrgHornetqCoreClientImpl::ClientMessageImpl
     put_string_property(Java::OrgHornetqCoreClientImpl::ClientMessageImpl::REPLYTO_HEADER_NAME, val)
   end
 
-  # Return the size of the encoded message
-  # attr_reader :encode_size
-
   # Return the body for this message
   # TODO: Do remaining message Types
-  # 
-  # WARNING: This method can only be called ONCE!
-  # WARNING: Do not call after setting the body otherwise the send will have
-  #          an empty body
   def body
     # Allow this buffer to be read multiple times
     body_buffer.reset_reader_index

data/lib/hornetq/client/{requestor.rb → requestor_pattern.rb}

@@ -1,7 +1,8 @@
 module HornetQ::Client
 
-  # Send a request to a server and wait for a reply  
-  class Requestor
+  # Implements the Requestor Pattern 
+  #   Send a request to a server and wait for a reply  
+  class RequestorPattern
     def initialize(session, request_address)
       @session = session
       @producer = session.create_producer(request_address)

data/lib/hornetq/client/{server.rb → server_pattern.rb}

@@ -1,8 +1,8 @@
 module HornetQ::Client
-  # Create a Server for receiving requests and replying
-  #   to arbitrary queues
+  # Create a Server following the ServerPattern for receiving requests and 
+  # replying to arbitrary queues
   # Create an instance of this class per thread
-  class Server
+  class ServerPattern
     def initialize(session, request_queue, timeout)
       @session = session
       @consumer = session.create_consumer(request_queue)

data/lib/hornetq/client/session_pool.rb

@@ -49,7 +49,6 @@ module HornetQ::Client
         s = factory.create_session(session_params)
         # Start the session since it will be used immediately upon creation
         s.start
-        puts "Creating Session"
         s
       end
 

data/lib/hornetq/common/log_delegate.rb

@@ -0,0 +1,46 @@
+module HornetQ
+  # Internal use only class for delegating HornetQ logging into the Rails or Ruby
+  # loggers
+  # 
+  private
+
+  # HornetQ requires a factory from which it can create a logger per thread and/or class 
+  class LogDelegateFactory
+    include 
+    
+    def createDelegate(klass)
+      LogDelegate.new(klass.name)
+    end
+  end
+  
+  # Delegate HornetQ log calls to Rails, Ruby or custom logger
+  class LogDelegate
+    include Java::org.hornetq.spi.core.logging::LogDelegate
+    
+    # TODO: Carry class_name over into logging entries depending on implementation
+    def initialize(class_name)
+      @class_name = class_name
+    end
+    
+    # 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)
+        end
+      end
+
+      def is#{level.capitalize}Enabled
+        @logger.#{level}?
+      end
+      LOG_LEVEL_METHOD
+    end
+
+  end
+end

data/lib/hornetq/common/logging.rb

@@ -0,0 +1,32 @@
+# Add HornetQ logging capabilities
+module HornetQ
+  # Returns the logger being used by both HornetQ and jruby-hornetq
+  def self.logger
+    @logger ||= (rails_logger || default_logger)
+  end
+
+  # Replace the logger for both HornetQ and jruby-hornetq
+  # TODO Directly support Log4J as logger since HornetQ has direct support for Log4J
+  def self.logger=(logger)
+    @logger = logger
+    # Also replace the HornetQ logger
+    Java::org.hornetq.core.logging::Logger.setDelegateFactory(HornetQ::LogDelegateFactory.new)
+    # TODO org.hornetq.core.logging.Logger.setDelegateFactory(org.hornetq.integration.logging.Log4jLogDelegateFactory.new)
+  end
+
+  private
+  def self.rails_logger
+    (defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger) ||
+      (defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER.respond_to?(:debug) && RAILS_DEFAULT_LOGGER)
+  end
+
+  # By default we use the HornetQ Logger
+  def self.default_logger
+    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