jruby-hornetq 0.2.5.alpha → 0.3.0.alpha

data/lib/hornetq/client/message_handler.rb

@@ -12,10 +12,10 @@ module HornetQ::Client
     #              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)
+    def initialize(params={}, &proc)
       @proc = proc
 
-      if parms[:statistics]
+      if params[:statistics]
         @message_count = 0
         @start_time = Time.now
       end
@@ -54,7 +54,7 @@ module HornetQ::Client
       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,
+        :count => @message_count,
         :duration => duration,
         :messages_per_second => (@message_count/duration).to_i
       }

data/lib/hornetq/client/org_hornetq_api_core_client_client_session.rb

@@ -1,11 +1,94 @@
-# 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
+# For each thread that will be processing messages concurrently a separate
+# session is required. 
+# 
+# Interface org.hornetq.api.core.client.ClientSession
+# 
+# See: http://hornetq.sourceforge.net/docs/hornetq-2.1.0.Final/api/index.html?org/hornetq/api/core/client/ClientSession.html
+# 
+# Other methods still directly accessible through this class:
+#
+# add_failure_listener(SessionFailureListener listener)
+#   Adds a FailureListener to the session which is notified if a failure occurs on the session
+#
+# binding_query(SimpleString address)
+#  Queries information on a binding
+#
+# close()
+#  Closes this session
+#
+# commit()
+#   Commits the current transaction
+#            
+# ClientMessage 	create_message(boolean durable)
+#          Creates a ClientMessage.
+# ClientMessage 	create_message(byte type, boolean durable)
+#          Creates a ClientMessage.
+# ClientMessage 	create_message(byte type, boolean durable, long expiration, long timestamp, byte priority)
+#          Creates a ClientMessage.
+#          
+# ClientProducer 	create_producer()
+#          Creates a producer with no default address.
+# ClientProducer 	create_producer(SimpleString address)
+#          Creates a producer which sends messages to the given address
+# ClientProducer 	create_producer(SimpleString address, int rate)
+#          Creates a producer which sends messages to the given address
+# ClientProducer 	create_producer(String address)
+#          Creates a producer which sends messages to the given address
+#
+# void 	create_queue(String address, String queueName)
+#          Creates a non-temporary queue non-durable queue.
+# void 	create_queue(String address, String queueName, boolean durable)
+#          Creates a non-temporary queue.
+# void 	create_queue(String address, String queueName, String filter, boolean durable)
+#          Creates a non-temporaryqueue.
+#
+# void 	create_temporary_queue(String address, String queueName)
+#          Creates a temporary queue.
+# void 	create_temporary_queue(String address, String queueName, String filter)
+#          Creates a temporary queue with a filter.
+#
+# void 	delete_queue(String queueName)
+#          Deletes the queue.
+# int 	version()
+#          Returns the server's incrementingVersion.
+#
+# XAResource 	xa_resource()
+#          Returns the XAResource associated to the session.
+#          
+# auto_commit_acks?
+#          Returns whether the session will automatically commit its transaction every time a message is acknowledged by a ClientConsumer created by this session, false else
+# auto_commit_sends?
+#          Returns whether the session will automatically commit its transaction every time a message is sent by a ClientProducer created by this session, false else
+# block_on_acknowledge?
+#          Returns whether the ClientConsumer created by the session will block when they acknowledge a message
+# closed?
+#          Returns whether the session is closed or not.
+# rollback_only?
+#          Returns true if the current transaction has been flagged to rollback, false else
+# xa?
+#          Return true if the session supports XA, false else
+#
+# ClientSession.QueueQuery 	queue_query(SimpleString queueName)
+#          Queries information on a queue
+#
+# boolean 	removeFailureListener(SessionFailureListener listener)
+#          Removes a FailureListener to the session
+#          
+# void 	rollback()
+#          Rolls back the current transaction
+# void 	rollback(boolean considerLastMessageAsDelivered)
+#          Rolls back the current transaction
+#          
+# void 	set_send_acknowledgement_handler(SendAcknowledgementHandler handler)
+#          Sets a SendAcknowledgementHandler for this session
+#          
+# void 	start()
+#          Starts the session
+# void 	stop()
+#          Stops the session
+
 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
@@ -34,12 +117,13 @@ module Java::org.hornetq.api.core.client::ClientSession
   #   
   # Example
   #   # Just browse the messages without consuming them
-  #   session.consumer(:queue_name => 'my_queue', :browse_only => true) do |consumer|
+  #   session.consumer(:queue_name => ##'my_queue', :browse_only => true) do |consumer|
   #     msg = consumer.receive_immediate
   #     p msg
   #     msg.acknowledge
   #   end
   def consumer(params={}, &block)
+    raise "Missing mandatory code block" unless block
     consumer = nil
     begin
       consumer = create_consumer_from_params(params)
@@ -49,23 +133,101 @@ module Java::org.hornetq.api.core.client::ClientSession
     end
   end
   
-  # Deprecated
+  # Consume or browse all messages matching the filter from the queue with the 
+  # given name, calls the supplied block for every message received from the 
+  # queue. Once the timeout has been reached it closes the consumer
+  # 
+  # 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
+  #   :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.
+  #
+  #   :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
+  #   
+  #   Note: If either :window_size or :max_rate is supplied, then BOTH are required
+  #  
+  # Returns the statistics gathered when :statistics => true, otherwise nil
+  #
+  # Example
+  #   session.consume(:queue_name => 'my_queue', :timeout => 1000) do |message|
+  #     p message
+  #     message.acknowledge
+  #   end
+  #   
+  # Example
+  #   # Just browse the messages without consuming them
+  #   session.consume(:queue_name => 'my_queue', :timeout => 1000, :browse_only => true) do |message|
+  #     p message
+  #     message.acknowledge
+  #   end
+  def consume(params, &block)
+    raise "Missing mandatory code block" unless block
+    c = self.create_consumer_from_params(params)
+    begin
+      c.each(params, &block)
+    ensure
+      c.close
+    end
+  end
+  
+  # Create a consumer using named parameters. The following Java create_consumer
+  # methods are still directly accessible:
+  #   create_consumer(String queueName)
+  #          Creates a ClientConsumer to consume messages from the queue with the given name
+  #   create_consumer(String queueName, boolean browseOnly)
+  #          Creates a ClientConsumer to consume or browse messages from the queue with the given name.
+  #   create_consumer(String queueName, String filter)
+  #          Creates a ClientConsumer to consume messages matching the filter from the queue with the given name.
+  #   create_consumer(String queueName, String filter, boolean browseOnly)
+  #          Creates a ClientConsumer to consume or browse messages matching the filter from the queue with the given name.
+  #   create_consumer(String queueName, String filter, int windowSize, int maxRate, boolean browseOnly)
+  #          Creates a ClientConsumer to consume or browse messages matching the filter from the queue with the given name.
+  # 
+  # 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 a new Consumer that can be used for consuming messages from
+  # the queue
   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])
+    if params.kind_of?(Hash)      
+      raise("Missing mandatory parameter :queue_name") unless queue_name = params[:queue_name]
+      
+      if params[:max_rate] || params[:window_size]
+        self.create_consumer(
+          queue_name, 
+          params[:filter], 
+          params[:window_size],
+          params[:max_rate],
+          params.fetch(:browse_only, false))
+      else
+        self.create_consumer(
+          queue_name, 
+          params[:filter], 
+          params.fetch(:browse_only, false))
+      end
     else
-      self.create_consumer(
-        queue_name, 
-        params[:filter], 
-        params[:browse_only].nil? ? false : params[:browse_only])
+      self.create_consumer(params)
     end
   end
 
@@ -130,8 +292,7 @@ module Java::org.hornetq.api.core.client::ClientSession
   # 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
+  def requestor(request_address,&block)
     begin
       requestor = self.create_requestor(request_address)
       block.call(requestor)
@@ -150,7 +311,6 @@ module Java::org.hornetq.api.core.client::ClientSession
   # 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)
@@ -158,7 +318,8 @@ module Java::org.hornetq.api.core.client::ClientSession
       server.close if server
     end
   end
-  
+
+  # Create a queue if it doesn't already exist
   def create_queue_ignore_exists(address, queue, durable)
     begin
       create_queue(address, queue, durable)

data/lib/hornetq/client/org_hornetq_core_client_impl_client_consumer_impl.rb

@@ -2,7 +2,24 @@
 
 # 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
-
+#
+# Other methods still directly accessible through this class:
+#
+# void 	close()
+#          Closes the consumer
+#          
+# boolean 	closed?
+#          Returns whether the consumer is closed or not
+#
+# Note: receive can be used directly, but it is recommended to use #each where possible 
+#                    
+# ClientMessage 	receive()
+#          Receives a message from a queue
+# ClientMessage 	receive(long timeout)
+#          Receives a message from a queue
+# ClientMessage 	receive_immediate()
+#          Receives a message from a queue
+#          
 class Java::org.hornetq.core.client.impl::ClientConsumerImpl
   
   # For each message available to be consumed call the block supplied
@@ -23,27 +40,27 @@ class Java::org.hornetq.core.client.impl::ClientConsumerImpl
   #              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)
+  def each(params={}, &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
+    timeout = (params[:timeout] || 0).to_i
 
-    if parms[:statistics]
+    if params[:statistics]
       message_count = 0
       start_time = Time.now
     end
 
     # Receive messages according to timeout
-    while message = self.receive_with_timeout(timeout) do
+    while message = 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,
+      { :count => message_count,
         :duration => duration,
         :messages_per_second => (message_count/duration).to_i}
     end
@@ -67,11 +84,11 @@ class Java::org.hornetq.core.client.impl::ClientConsumerImpl
   #
   #              The statistics gathered are returned when :statistics => true and :async => false
   #
-  def on_message(parms={}, &proc)
+  def on_message(params={}, &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
+    @listener = HornetQ::Client::MessageHandler.new(params, &proc)
+    setMessageHandler @listener
   end
 
   # Return the current statistics for a running ::on_message

data/lib/hornetq/client/org_hornetq_core_client_impl_client_message_impl.rb

@@ -1,6 +1,119 @@
-
-# Cannot add to the interface Java::org.hornetq.api.core::Message because these
-# methods access instance variables in the Java object
+# 
+# Message
+# 
+# A Message is a routable instance that has a payload.
+# 
+# The payload (the "body") is opaque to the messaging system. A Message also has
+# a fixed set of headers (required by the messaging system) and properties 
+# (defined by the users) that can be used by the messaging system to route the 
+# message (e.g. to ensure it matches a queue filter). 
+# 
+# See: http://hornetq.sourceforge.net/docs/hornetq-2.1.0.Final/api/org/hornetq/api/core/client/ClientMessage.html
+# 
+# Other methods still directly accessible through this class:
+#
+# void 	acknowledge()
+#          Acknowledge reception of this message. If the session responsible to 
+#          acknowledge this message has :auto_commit_acks => true, the 
+#          transaction will automatically commit the current transaction. 
+#          Otherwise, this acknowledgement will not be committed until the 
+#          client commits the session transaction
+#          
+# Message attribute methods available directly from the Java Message class:
+# 
+# String address()
+#          Returns the address this message is sent to.
+# void 	address=(SimpleString address)
+#          Sets the address to send this message to
+#          
+# int 	body_size()
+#          Return the size (in bytes) of this message's body
+#          
+# int 	delivery_count()
+#          Returns the number of times this message was delivered
+#          
+# boolean durable?()
+#          Returns whether this message is durable or not
+# void 	durable=(boolean durable)
+#          Sets whether this message is durable or not.
+#          
+# int 	encode_size()
+#          Returns the size of the encoded message
+#          
+# boolean expired?()
+#          Returns whether this message is expired or not
+#          
+# long 	expiration()
+#          Returns the expiration time of this message
+# void 	expiration=(long expiration)
+#          Sets the expiration of this message.
+#          
+# boolean large_message?()
+#          Returns whether this message is a large message or a regular message
+#          
+# long 	message_id()
+#          Returns the messageID
+#          
+# byte 	priority()
+#          Returns the message priority. 
+#          Values range from 0 (less priority) to 9 (more priority) inclusive. 
+# void 	priority=(byte priority)
+#          Sets the message priority.
+#          Value must be between 0 and 9 inclusive. 
+#          
+# #TODO Add timestamp_time attribute that converts to/from expiration under the covers
+# long 	timestamp()
+#          Returns the message timestamp. The timestamp corresponds to the time 
+#          this message was handled by a HornetQ server. 
+# void 	timestamp=(long timestamp)
+#          Sets the message timestamp.
+#          
+# byte 	type()
+#          Returns this message type
+#          See: type_sym below for dealing with message types using Ruby Symbols
+#          
+# org.hornetq.utils.UUID 	user_id()
+#          Returns the userID - this is an optional user specified UUID that can be set to identify the message and will be passed around with the message
+# void 	user_id=(org.hornetq.utils.UUID userID)
+#          Sets the user ID
+#
+# Methods available directly for dealing with properties:
+# 
+#  boolean 	contains_property?(key)
+#          Returns true if this message contains a property with the given key, false else
+#          
+#  Note: Several other property methods are available directly, but since JRuby
+#        deals with the conversion for you they are not documented here
+#
+# Other methods still directly accessible through this class from its child classes:
+# 
+# HornetQBuffer 	body_buffer()
+#          Returns the message body as a HornetQBuffer
+#           
+# Map<String,Object> 	toMap()
+# 
+# 
+# Methods for dealing with large messages:
+# 
+# void 	save_to_output_stream(OutputStream out)
+#          Saves the content of the message to the OutputStream. 
+#          It will block until the entire content is transfered to the OutputStream. 
+#          
+# void 	body_input_stream=(InputStream bodyInputStream)
+#          Sets the body's IntputStream.
+#          This method is used when sending large messages 
+#          
+# void 	output_stream=(OutputStream out)
+#          Sets the OutputStream that will receive the content of a message received 
+#          in a non blocking way. This method is used when consuming large messages 
+#          
+# boolean 	wait_output_stream_completion(long timeMilliseconds)
+#          Wait the outputStream completion of the message. This method is used when consuming large messages 
+#          timeMilliseconds - - 0 means wait forever 
+#
+# Developer notes:           
+#   Cannot add to the interface Java::org.hornetq.api.core::Message because these
+#   methods access instance variables in the Java object
 class Java::OrgHornetqCoreClientImpl::ClientMessageImpl
   # Attributes
   # attr_accessor :address, :type, :durable, :expiration, :priority, :timestamp, :user_id
@@ -31,18 +144,78 @@ class Java::OrgHornetqCoreClientImpl::ClientMessageImpl
 
     put_string_property(Java::OrgHornetqCoreClientImpl::ClientMessageImpl::REPLYTO_HEADER_NAME, val)
   end
+  
+  # Returns the message type as one of the following symbols
+  #   :text    => org.hornetq.api.core.Message::TEXT_TYPE
+  #   :bytes   => org.hornetq.api.core.Message::BYTES_TYPE
+  #   :map     => org.hornetq.api.core.Message::MAP_TYPE
+  #   :object  => org.hornetq.api.core.Message::OBJECT_TYPE
+  #   :stream  => org.hornetq.api.core.Message::STREAM_TYPE
+  #   :default => org.hornetq.api.core.Message::DEFAULT_TYPE
+  #   :unknown => Any other value for message type
+  #   
+  # If the type is none of the above, nil is returned
+  #
+  def type_sym
+    case self.type
+    when Java::org.hornetq.api.core.Message::TEXT_TYPE 	#3
+      :text
+    when Java::org.hornetq.api.core.Message::BYTES_TYPE  #4
+      :bytes
+    when Java::org.hornetq.api.core.Message::MAP_TYPE 	#5
+      :map
+    when Java::org.hornetq.api.core.Message::OBJECT_TYPE 	#2
+      :object
+    when Java::org.hornetq.api.core.Message::STREAM_TYPE 	#6
+      :stream
+    when Java::org.hornetq.api.core.Message::DEFAULT_TYPE 	#0
+      :default
+    else
+      :unknown
+    end
+  end
+
+  # Set the message type using a Ruby symbol
+  # Parameters
+  #  sym: Must be any one of the following symbols
+  #   :text    => org.hornetq.api.core.Message::TEXT_TYPE
+  #   :bytes   => org.hornetq.api.core.Message::BYTES_TYPE
+  #   :map     => org.hornetq.api.core.Message::MAP_TYPE
+  #   :object  => org.hornetq.api.core.Message::OBJECT_TYPE
+  #   :stream  => org.hornetq.api.core.Message::STREAM_TYPE
+  #   :default => org.hornetq.api.core.Message::DEFAULT_TYPE
+  #   
+  def type_sym=(sym)
+    case sym
+    when :text
+      self.type = Java::org.hornetq.api.core.Message::TEXT_TYPE 	#3
+    when :bytes
+      self.type = Java::org.hornetq.api.core.Message::BYTES_TYPE  #4
+    when :map
+      self.type = Java::org.hornetq.api.core.Message::MAP_TYPE 	#5
+    when :object
+      self.type = Java::org.hornetq.api.core.Message::OBJECT_TYPE 	#2
+    when :stream
+      self.type = Java::org.hornetq.api.core.Message::STREAM_TYPE 	#6
+    when :default
+      self.type = Java::org.hornetq.api.core.Message::DEFAULT_TYPE 	#0
+    else
+      raise "Invalid message type_sym:#{sym.to_s}"
+    end
+  end
 
   # Return the body for this message
   # TODO: Do remaining message Types
   def body
     # Allow this buffer to be read multiple times
-    body_buffer.reset_reader_index
+    buf = body_buffer
+    buf.reset_reader_index
+    available = body_size
+    
+    return nil if available == 0
 
     case type
     when Java::org.hornetq.api.core.Message::BYTES_TYPE  #4
-      buf = body_buffer
-      buf.reset_reader_index
-      available = body_size
       result = ""      
       bytes_size = 1024
       bytes = Java::byte[bytes_size].new
@@ -145,29 +318,6 @@ class Java::OrgHornetqCoreClientImpl::ClientMessageImpl
     property_exists(key.to_s) == true
   end
 
-  # call-seq:
-  #   body_buffer
-  #
-  # Return the message body as a HornetQBuffer
-  #
-
-  # call-seq:
-  #   to_map
-  #
-  # Return the Message as a Map
-  #
-
-  # call-seq:
-  #   remove_property(key)
-  #
-  # Remove a property
-
-  # call-seq:
-  #   contains_property(key)
-  #
-  # Returns true if this message contains a property with the given key
-  # TODO: Symbols?
-
   # Return TypedProperties
   def getProperties
     properties
@@ -187,19 +337,24 @@ class Java::OrgHornetqCoreClientImpl::ClientMessageImpl
   def attributes
     {
       :address => address.nil? ? '' : address.to_string,
-      :type => type,
-      :durable => durable,
+      :body_size => body_size,
+      :delivery_count => delivery_count,
+      :durable? => durable?,
+      :encode_size => encode_size,
+      :expired? => expired?,
       :expiration => expiration,
-      :priority => priority,
+      :large_message? => large_message?,
+      :message_id => message_id,
+      :priority => priority,      
       :timestamp => timestamp,
+      :type_sym => type_sym,
       :user_id => user_id,
-      :encode_size => encode_size
     }
   end
 
   # Does not include the body since it can only read once
   def inspect
-    "#{self.class.name}:\nAttributes: #{attributes.inspect}\nProperties: #{properties.inspect}"
+    "#{self.class.name}:\nBody: #{body.inspect}\nAttributes: #{attributes.inspect}\nProperties: #{properties.inspect}"
   end
 
 end