jruby-jms 0.9.0

data/lib/jms/javax_jms_map_message.rb

@@ -0,0 +1,91 @@
+################################################################################
+#  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.MapMessage
+module javax.jms::MapMessage
+  # Since each is defined, add support for: inject, map, include?, and find_all?
+  # <=> also allows support for:  min, max, and sort
+  include Enumerable
+
+  # Return Map Message as a hash
+  def to_h
+    h = {}
+    each_pair {|key, value| h[key] = value}
+    h
+  end
+
+  # Return Map Message as a hash
+  def data
+    to_h
+  end
+
+  # Copy values from supplied hash into this MapMessage
+  # Converts Ruby types to Java native Data types as follows:
+  #   Fixnum   => long
+  #   Float    => double
+  #   Bignum   => long
+  #   true     => boolean
+  #   false    => boolean
+  #   nil      => null
+  #   Otherwise it calls ::to_s on the supplied data type
+  def data=(data)
+    data.each_pair do |key,val|
+      case
+      when val.class == Fixnum # 1
+        setLong(key.to_s,val)
+      when val.class == Float #1.1
+        setDouble(key.to_s,val)
+      when val.class == Bignum # 11111111111111111
+        setLong(key.to_s,val)
+      when (val.class == TrueClass) || (val.class == FalseClass)
+        setBoolean(key.to_s,val)
+      when val.class == NilClass
+        setObject(key.to_s,val)
+      else
+        setString(key.to_s,val.to_s)
+      end
+    end
+  end
+
+  # Return each name value pair
+  def each(&proc)
+    # When key and value are expected separately. Should actually be calling each_pair anyway
+    if proc.arity == 2
+      each_pair(proc)
+    else
+      enum = getMapNames
+      while enum.has_more_elements
+        key = enum.next_element
+        proc.call [key, getObject(key)]
+      end
+    end
+  end
+
+  # Return each name value pair
+  def each_pair(&proc)
+    enum = getMapNames
+    while enum.has_more_elements
+      key = enum.next_element
+      proc.call key, getObject(key)
+    end
+  end
+
+  # Does map include specified key
+  def include?(key)
+    # Ensure a Ruby true is returned
+    item_exists key == true
+  end
+end

data/lib/jms/javax_jms_message.rb

@@ -0,0 +1,264 @@
+################################################################################
+#  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.
+################################################################################
+
+# Extend JMS Message Interface with Ruby methods
+#
+# A Message is the item that can be put on a queue, or obtained from a queue.
+# 
+# A Message consists of 3 major parts:
+#   - Header
+#     Accessible as attributes of the Message class
+#   - Properties
+#     Accessible via [] and []= methods
+#   - Data
+#     The actual data portion of the message
+#     See the specific message types for details on how to access the data
+#     portion of the message
+#
+# For further help on javax.jms.Message
+#   http://download.oracle.com/javaee/6/api/index.html?javax/jms/Message.html
+#
+# Interface javax.jms.Message
+module javax.jms::Message
+
+  # Methods directly exposed from the Java class:
+  
+  # call-seq:
+  #   acknowledge
+  #
+  # Acknowledges all consumed messages of the session of this consumed message
+  #
+
+  # call-seq:
+  #   clear_body
+  #
+  #  Clears out the message body
+  #
+
+  # call-seq:
+  #   clear_properties
+  #
+  #  Clears out the properties of this message
+  #
+  
+  # Header Fields - Attributes of the message
+  
+  # Return the JMS Delivery Mode as a symbol
+  #   :peristent
+  #   :non_peristent
+  #   other: Value from javax.jms.DeliveryMode
+  def jms_delivery_mode
+    case getJMSDeliveryMode
+    when javax.jms.DeliveryMode::PERSISTENT
+      :peristent
+    when javax.jms.DeliveryMode::NON_PERSISTENT
+      :non_peristent
+    else
+      getJMSDeliveryMode
+    end
+  end
+  
+  # Set the JMS Delivery Mode
+  # Valid values for mode
+  #   :peristent
+  #   :non_peristent
+  #   other: Any constant from javax.jms.DeliveryMode
+  def jms_delivery_mode=(mode)
+    val = case mode
+    when :peristent
+      javax.jms.DeliveryMode::PERSISTENT
+    when :non_peristent
+      javax.jms.DeliveryMode::NON_PERSISTENT
+    else
+      mode
+    end
+    self.setJMSDeliveryMode(val)
+  end
+  
+  # Is the message persistent?
+  def persistent?
+    getJMSDeliveryMode == javax.jms.DeliveryMode::PERSISTENT
+  end
+  
+  # Returns the Message correlation ID as a String
+  # The resulting string may contain nulls
+  def jms_correlation_id
+    String.from_java_bytes(getJMSCorrelationIDAsBytes) if getJMSCorrelationIDAsBytes
+  end
+  
+  # Set the Message correlation ID
+  #   correlation_id: String
+  # Also supports embedded nulls within the correlation id
+  def jms_correlation_id=(correlation_id)
+    setJMSCorrelationIDAsBytes(correlation_id.nil? ? nil : correlation_id.to_java_bytes)
+  end
+  
+  # Returns the Message Destination
+  #  Instance of javax.jms.Destination
+  def jms_destination
+    getJMSDestination
+  end
+  
+  # Set the Message Destination
+  #   jms_destination: Must be an instance of javax.jms.Destination
+  def jms_destination=(destination)
+    setJMSDestination(destination)
+  end
+  
+  # Return the message expiration value as an Integer
+  def jms_expiration
+    getJMSExpiration
+  end
+  
+  # Set the Message expiration value
+  #   expiration: Integer
+  def jms_expiration=(expiration)
+    setJMSExpiration(expiration)
+  end
+  
+  # Returns the Message ID as a String
+  # The resulting string may contain embedded nulls
+  def jms_message_id
+    getJMSMessageID
+  end
+  
+  # Set the Message correlation ID
+  #   message_id: String
+  # Also supports nulls within the message id
+  def jms_message_id=(message_id)
+    setJMSMessageID(message_id)
+  end
+  
+  # Returns the Message Priority level as an Integer
+  def jms_priority
+    getJMSPriority
+  end
+  
+  # Set the Message priority level
+  #   priority: Integer
+  def jms_priority=(priority)
+    setJMSPriority(priority)
+  end
+  
+  # Indicates whether the Message was redelivered?
+  def jms_redelivered?
+    getJMSRedelivered
+  end
+  
+  # Set whether the Message was redelivered
+  #   bool: Boolean
+  def jms_redelivered=(bool)
+    setJMSPriority(bool)
+  end
+  
+  # Returns the Message reply to Destination
+  #  Instance of javax.jms.Destination
+  def jms_reply_to
+    getJMSReplyTo
+  end
+  
+  # Set the Message reply to Destination
+  #   reply_to: Must be an instance of javax.jms.Destination
+  def jms_reply_to=(reply_to)
+    setJMSReplyTo(reply_to)
+  end
+  
+  # Returns the Message timestamp as Java Timestamp Integer
+  #TODO Return Ruby Time object? 
+  def jms_timestamp
+    getJMSTimestamp
+  end
+  
+  # Set the Message reply to Destination
+  #   timestamp: Must be an Java Timestamp Integer
+  #TODO Support Ruby Time
+  def jms_timestamp=(timestamp)
+    setJMSTimestamp(timestamp)
+  end
+  
+  # Returns the Message type supplied by the client when the message was sent
+  def jms_type
+    getJMSType
+  end
+  
+  # Sets the Message type
+  #   type: String
+  def jms_type=(type)
+    setJMSType(type)
+  end
+  
+  # Return the attributes (header fields) of the message as a Hash
+  def attributes
+    {
+      :jms_correlation_id => jms_correlation_id,
+      :jms_delivery_mode => jms_delivery_mode,
+      :jms_destination => jms_destination,
+      :jms_expiration => jms_expiration,
+      :jms_message_id => jms_message_id,
+      :jms_priority => jms_priority,
+      :jms_redelivered => jms_redelivered?,
+      :jms_reply_to => jms_reply_to,
+      :jms_timestamp => jms_timestamp,
+      :jms_type => jms_type,
+    }
+  end
+
+  # Methods for manipulating the message properties
+
+  # Get the value of a property
+  def [](key)
+    getObjectProperty key.to_s
+  end
+
+  # Set a property
+  def []=(key, value)
+    setObjectProperty(key.to_s, value)
+  end
+
+  # Does message include specified property?
+  def include?(key)
+    # Ensure a Ruby true is returned
+    property_exists key == true
+  end
+
+  # Return Properties as a hash
+  def properties
+    h = {}
+    properties_each_pair {|k,v| h[k]=v}
+    h
+  end
+
+  # Set Properties from an existing hash
+  def properties=(h)
+    clear_properties
+    h.each_pair {|k,v| setObjectProperty(k.to_s, v)}
+    h
+  end
+
+  # Return each name value pair
+  def properties_each_pair(&proc)
+    enum = getPropertyNames
+    while enum.has_more_elements
+      key = enum.next_element
+      proc.call key, getObjectProperty(key)
+    end
+  end
+
+  def inspect
+    "#{self.class.name}: #{data}\nAttributes: #{attributes.inspect}\nProperties: #{properties.inspect}"
+  end
+  
+end

data/lib/jms/javax_jms_message_consumer.rb

@@ -0,0 +1,114 @@
+################################################################################
+#  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.
+################################################################################
+
+module javax.jms::MessageConsumer
+  # Obtain a message from the Destination or Topic
+  # In JMS terms, the message is received from the Destination
+  # :timeout follows the rules for MQSeries:
+  #   -1 : Wait forever
+  #    0 : Return immediately if no message is available
+  #    x : Wait for x milli-seconds for a message to be received from the broker
+  #         Note: Messages may still be on the queue, but the broker has not supplied any messages
+  #                   in the time interval specified
+  #    Default: 0
+  def get(parms={})
+    timeout = parms[:timeout] || 0
+    if timeout == -1
+      self.receive
+    elsif timeout == 0
+      self.receiveNoWait
+    else
+      self.receive(timeout)
+    end
+  end
+
+  # For each message available to be consumed call the Proc supplied
+  # Returns the statistics gathered when :statistics => true, otherwise nil
+  #
+  # Parameters:
+  #   :timeout How to timeout waiting for messages on the Queue or Topic
+  #     -1 : Wait forever
+  #      0 : Return immediately if no message is available
+  #      x : Wait for x milli-seconds for a message to be received from the broker
+  #           Note: Messages may still be on the queue, but the broker 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.
+  #              The statistics can be reset by calling MessageConsumer::each again
+  #              with :statistics => true
+  #
+  #              The statistics gathered are returned when :statistics => true and :async => false
+  def each(parms={}, &proc)
+    raise "Destination::each requires a code block to be executed for each message received" unless proc
+
+    message_count = nil
+    start_time = nil
+
+    if parms[:statistics]
+      message_count = 0
+      start_time = Time.now
+    end
+
+    # Receive messages according to timeout
+    while message = self.get(parms) 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 recieved 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 "MessageConsumer::on_message requires a code block to be executed for each message received" unless proc
+
+    @listener = JMS::MessageListener.new(parms,&proc)
+    self.setMessageListener @listener
+  end
+
+  # Return the current statistics for a running MessageConsumer::on_message
+  def on_message_statistics
+    stats = @listener.statistics if @listener
+    raise "First call MessageConsumer::on_message with :statistics=>true before calling MessageConsumer::statistics()" unless stats
+    stats
+  end
+
+end