jruby-jms 1.1.0-java → 1.2.0-java

data/lib/jms/map_message.rb

@@ -1,20 +1,4 @@
-################################################################################
-#  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
+# Interface javax.jms.MapMessage
 module JMS::MapMessage
   # Since each is defined, add support for: inject, map, include?, and find_all?
   # <=> also allows support for:  min, max, and sort
@@ -23,7 +7,7 @@ module JMS::MapMessage
   # Return Map Message as a hash
   def to_h
     h = {}
-    each_pair {|key, value| h[key] = value}
+    each_pair { |key, value| h[key] = value }
     h
   end
 
@@ -42,20 +26,20 @@ module JMS::MapMessage
   #   nil      => null
   #   Otherwise it calls ::to_s on the supplied data type
   def data=(data)
-    data.each_pair do |key,val|
+    data.each_pair do |key, val|
       case
       when val.class == Fixnum # 1
-        setLong(key.to_s,val)
+        setLong(key.to_s, val)
       when val.class == Float #1.1
-        setDouble(key.to_s,val)
+        setDouble(key.to_s, val)
       when val.class == Bignum # 11111111111111111
-        setLong(key.to_s,val)
+        setLong(key.to_s, val)
       when (val.class == TrueClass) || (val.class == FalseClass)
-        setBoolean(key.to_s,val)
+        setBoolean(key.to_s, val)
       when val.class == NilClass
-        setObject(key.to_s,val)
+        setObject(key.to_s, val)
       else
-        setString(key.to_s,val.to_s)
+        setString(key.to_s, val.to_s)
       end
     end
   end

data/lib/jms/message.rb

@@ -1,19 +1,3 @@
-################################################################################
-#  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.
@@ -54,142 +38,6 @@ module JMS::Message
   #  Clears out the properties of this message
   #
 
-  # For Backward compatibility with JRuby prior to 1.6
-  # JRuby 1.6 now does all this for us. Thank you headius :)
-  unless self.instance_methods.include? :jms_delivery_mode
-
-    # Header Fields - Attributes of the message
-
-    # Returns the JMS Delivery Mode
-    # One of the following will be returned
-    #   JMS::DeliveryMode::PERSISTENT
-    #   JMS::DeliveryMode::NON_PERSISTENT
-    def jms_delivery_mode
-      getJMSDeliveryMode
-    end
-
-    # Set the JMS Delivery Mode
-    # Values can be
-    #   JMS::DeliveryMode::PERSISTENT
-    #   JMS::DeliveryMode::NON_PERSISTENT
-    def jms_delivery_mode=(mode)
-      raise "Sorry, due to incompatibility with JRuby 1.6, please call jms_delivery_mode_sym when using symbols" if mode.is_a? Symbol
-      self.setJMSDeliveryMode(mode)
-    end
-
-    # Is the message persistent?
-    def persistent?
-      getJMSDeliveryMode == 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 JMS::Destination
-    def jms_destination
-      getJMSDestination
-    end
-
-    # Set the Message Destination
-    #   jms_destination: Must be an instance of 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 JMS::Destination
-    def jms_reply_to
-      getJMSReplyTo
-    end
-
-    # Set the Message reply to Destination
-    #   reply_to: Must be an instance of 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 timestamp as Java Timestamp Integer
-    #   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
-  end
-
   # Return the JMS Delivery Mode as a Ruby symbol
   #   :persistent
   #   :non_persistent
@@ -210,30 +58,31 @@ module JMS::Message
   #   :persistent
   #   :non_persistent
   def jms_delivery_mode_sym=(mode)
-    val = case mode
-    when :persistent
-      JMS::DeliveryMode::PERSISTENT
-    when :non_persistent
-      JMS::DeliveryMode::NON_PERSISTENT
-    else
-      raise "Unknown delivery mode symbol: #{mode}"
-    end
+    val =
+      case mode
+      when :persistent
+        JMS::DeliveryMode::PERSISTENT
+      when :non_persistent
+        JMS::DeliveryMode::NON_PERSISTENT
+      else
+        raise "Unknown delivery mode symbol: #{mode}"
+      end
     self.setJMSDeliveryMode(val)
   end
 
   # Return the attributes (header fields) of the message as a Hash
   def attributes
     {
-      :jms_correlation_id => jms_correlation_id,
-      :jms_delivery_mode_sym => jms_delivery_mode_sym,
-      :jms_destination => jms_destination.nil? ? nil : jms_destination.to_string,
-      :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,
+      jms_correlation_id:    jms_correlation_id,
+      jms_delivery_mode_sym: jms_delivery_mode_sym,
+      jms_destination:       jms_destination.nil? ? nil : jms_destination.to_string,
+      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
 
@@ -258,14 +107,14 @@ module JMS::Message
   # Return Properties as a hash
   def properties
     h = {}
-    properties_each_pair {|k,v| h[k]=v}
+    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.each_pair { |k, v| setObjectProperty(k.to_s, v) }
     h
   end
 
@@ -282,4 +131,4 @@ module JMS::Message
     "#{self.class.name}: #{data}\nAttributes: #{attributes.inspect}\nProperties: #{properties.inspect}"
   end
 
-end
+end

data/lib/jms/message_consumer.rb

@@ -1,19 +1,3 @@
-################################################################################
-#  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.MessageConsumer
 module JMS::MessageConsumer
   # Obtain a message from the Destination or Topic
@@ -36,8 +20,8 @@ module JMS::MessageConsumer
     end
   end
 
-  # For each message available to be consumed call the Proc supplied
-  # Returns the statistics gathered when :statistics => true, otherwise nil
+  # For each message available to be consumed call the supplied block
+  # Returns the statistics gathered when statistics: true, otherwise nil
   #
   # Parameters:
   #   :timeout How to timeout waiting for messages on the Queue or Topic
@@ -52,32 +36,33 @@ module JMS::MessageConsumer
   #      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
+  #              with statistics: true
   #
-  #              The statistics gathered are returned when :statistics => true and :async => false
-  def each(params={}, &proc)
-    raise "Destination::each requires a code block to be executed for each message received" unless proc
+  #              The statistics gathered are returned when statistics: true and async: false
+  def each(params={}, &block)
+    raise(ArgumentError, 'Destination::each requires a code block to be executed for each message received') unless block
 
     message_count = nil
-    start_time = nil
+    start_time    = nil
 
     if params[:statistics]
       message_count = 0
-      start_time = Time.now
+      start_time    = Time.now
     end
 
     # Receive messages according to timeout
     while message = self.get(params) do
-      proc.call(message)
+      block.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 => duration > 0 ? (message_count/duration).to_i : 0,
-        :ms_per_msg => message_count > 0 ? (duration*1000.0)/message_count : 0
+      {
+        messages:            message_count,
+        duration:            duration,
+        messages_per_second: duration > 0 ? (message_count/duration).to_i : 0,
+        ms_per_msg:          message_count > 0 ? (duration*1000.0)/message_count : 0
       }
     end
   end
@@ -96,21 +81,24 @@ module JMS::MessageConsumer
   #              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
+  #              is called again with statistics: true
   #
-  #              The statistics gathered are returned when :statistics => true and :async => false
+  #              The statistics gathered are returned when statistics: true and async: false
   #
   def on_message(params={}, &proc)
-    raise "MessageConsumer::on_message requires a code block to be executed for each message received" unless proc
+    raise(ArgumentError, 'MessageConsumer::on_message requires a code block to be executed for each message received') unless proc
+
+    # Turn on Java class persistence: https://github.com/jruby/jruby/wiki/Persistence
+    self.class.__persistent__ = true
 
-    @listener = JMS::MessageListenerImpl.new(params,&proc)
-    self.setMessageListener @listener
+    @listener = JMS::MessageListenerImpl.new(params, &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
+    raise(ArgumentError, 'First call MessageConsumer::on_message with statistics: true before calling MessageConsumer::statistics()') unless stats
     stats
   end
 

data/lib/jms/message_listener_impl.rb

@@ -1,25 +1,11 @@
-################################################################################
-#  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 JMS
 
   private
+
   # For internal use only by JMS::Connection
   class MessageListenerImpl
     include JMS::MessageListener
+    include SemanticLogger::Loggable
 
     # Parameters:
     #   :statistics Capture statistics on how many messages have been read
@@ -29,15 +15,15 @@ module JMS
     #              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
+    #              is called again with statistics: true
     #
-    #              The statistics gathered are returned when :statistics => true and :async => false
+    #              The statistics gathered are returned when statistics: true and async: false
     def initialize(params={}, &proc)
       @proc = proc
 
       if params[:statistics]
         @message_count = 0
-        @start_time = Time.now
+        @start_time    = Time.now
       end
     end
 
@@ -49,31 +35,29 @@ module JMS
       begin
         if @message_count
           @message_count += 1
-          @last_time = Time.now
+          @last_time     = Time.now
+        end
+        logger.benchmark_debug('Message processed') do
+          @proc.call message
         end
-        @proc.call message
-      rescue SyntaxError, NameError => boom
-        JMS::logger.error "Unhandled Exception processing JMS Message. Doesn't compile: " + boom
-        JMS::logger.error "Ignoring poison message:\n#{message.inspect}"
-        JMS::logger.error boom.backtrace.join("\n")
-      rescue StandardError => bang
-        JMS::logger.error "Unhandled Exception processing JMS Message. Doesn't compile: " + bang
-        JMS::logger.error "Ignoring poison message:\n#{message.inspect}"
-        JMS::logger.error bang.backtrace.join("\n")
-      rescue => exc
-        JMS::logger.error "Unhandled Exception processing JMS Message. Exception occurred:\n#{exc}"
-        JMS::logger.error "Ignoring poison message:\n#{message.inspect}"
-        JMS::logger.error exc.backtrace.join("\n")
+      rescue SyntaxError, NameError => exc
+        logger.error "Ignoring poison message:\n#{message.inspect}", exc
+      rescue StandardError => exc
+        logger.error "Ignoring poison message:\n#{message.inspect}", exc
+      rescue Exception => exc
+        logger.error "Ignoring poison message:\n#{message.inspect}", exc
       end
     end
 
     # Return Statistics gathered for this listener
     def statistics
-      raise "First call MessageConsumer::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}
+      raise(ArgumentError, 'First call MessageConsumer::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