modern_times 0.2.11 → 0.3.0

data/lib/modern_times/{jms_requestor/worker.rb → jms/request_worker.rb}

@@ -1,88 +1,66 @@
 module ModernTimes
-  module JMSRequestor
+  module JMS
 
     # Base Worker Class for any class that will be processing messages from queues
-    module Worker
-      include ModernTimes::JMS::Worker
-      attr_reader :error_count
+    module RequestWorker
+      include Worker
+      # Dummy requesting needs access to this
+      attr_reader :marshaler
 
       module ClassMethods
-        def create_supervisor(manager, worker_options)
-          Supervisor.new(manager, self, {}, worker_options)
+        # Define the marshaling and time_to_live that will occur on the response
+        def response(options)
+          @response_options = options
+        end
+
+        def response_options
+          # Get the response marshaler, defaulting to the request marshaler
+          @response_options
         end
       end
 
       def self.included(base)
         # The price we pay for including rather than extending
         base.extend(ModernTimes::Base::Worker::ClassMethods)
-        base.extend(ModernTimes::JMS::Worker::ClassMethods)
+        base.extend(Worker::ClassMethods)
         base.extend(ClassMethods)
       end
 
       def initialize(opts={})
         super
-        @time_mutex  = Mutex.new
-        @count       = 0
-        @error_count = 0
-        @min_time    = nil
-        @max_time    = 0.0
-        @total_time  = 0.0
+        response_options = self.class.response_options || {}
+        @marshal_type = (response_options[:marshal] || :ruby).to_s
+        @marshaler    = MarshalStrategy.find(@marshal_type)
+        # Time in msec until the message gets discarded, should be more than the timeout on the requestor side
+        @time_to_live = response_options[:time_to_live] || 10000
       end
 
       def perform(object)
-        start_time = Time.now
         response = request(object)
-        response_time = Time.now - start_time
         session.producer(:destination => message.reply_to) do |producer|
-          reply_message = ModernTimes::JMS.create_message(session, self.class.marshaler, response)
+          producer.time_to_live = @time_to_live
+          reply_message = ModernTimes::JMS.create_message(session, @marshaler, response)
           reply_message.jms_correlation_id = message.jms_message_id
+          reply_message.jms_delivery_mode = ::JMS::DeliveryMode::NON_PERSISTENT
+          reply_message['worker']  = self.name
+          reply_message['marshal'] = @marshal_type
           producer.send(reply_message)
         end
-        @time_mutex.synchronize do
-          @count      += 1
-          @total_time += response_time
-          @min_time    = response_time if !@min_time || response_time < @min_time
-          @max_time    = response_time if response_time > @max_time
-        end
       rescue Exception => e
-        @time_mutex.synchronize do
-          @error_count += 1
-        end
+        ModernTimes.logger.error("Exception: #{e.message}\n\t#{e.backtrace.join("\n\t")}")
         begin
           session.producer(:destination => message.reply_to) do |producer|
+            producer.time_to_live = @time_to_live
             reply_message = ModernTimes::JMS.create_message(session, ModernTimes::MarshalStrategy::String, "Exception: #{e.message}")
             reply_message.jms_correlation_id = message.jms_message_id
-            reply_message['Exception'] = ModernTimes::RemoteException.new(e).to_hash.to_yaml
+            reply_message['worker']    = self.name
+            reply_message['exception'] = ModernTimes::RemoteException.new(e).to_hash.to_yaml
             producer.send(reply_message)
           end
         rescue Exception => e
           ModernTimes.logger.error("Exception in exception reply: #{e.message}\n\t#{e.backtrace.join("\n\t")}")
         end
-      end
-
-      def total_time
-        @time_mutex.synchronize do
-          retval = [@count, @total_time]
-          @count = 0
-          @total_time = 0.0
-          return retval
-        end
-      end
-
-      def min_time
-        @time_mutex.synchronize do
-          val = @min_time
-          @min_time = nil
-          return val
-        end
-      end
-
-      def max_time
-        @time_mutex.synchronize do
-          val = @max_time
-          @max_time = 0.0
-          return val
-        end
+        raise
       end
 
       def request(object)

data/lib/modern_times/jms/supervisor.rb

@@ -10,6 +10,36 @@ module ModernTimes
         workers.map { |w| w.message_count }
       end
 
+      def average_response_time
+        count = 0
+        total = 0.0
+        workers.each do |w|
+          pair = w.time_track.total_time_reset
+          count += pair.first
+          total += pair.last
+        end
+        return 0.0 if count == 0
+        return total / count
+      end
+
+      def min_response_time
+        min_time = nil
+        workers.each do |w|
+          wmin_time = w.time_track.min_time_reset
+          min_time = wmin_time if wmin_time && (!min_time || wmin_time < min_time)
+        end
+        return min_time || 0.0
+      end
+
+      def max_response_time
+        max_time = 0.0
+        workers.each do |w|
+          wmax_time = w.time_track.max_time_reset
+          max_time = wmax_time if wmax_time > max_time
+        end
+        return max_time
+      end
+
       # Make JMS::SupervisorMBean our mbean
       def create_mbean(domain)
         SupervisorMBean.new(mbean_name(domain), mbean_description, self, {})

data/lib/modern_times/jms/supervisor_mbean.rb

@@ -1,11 +1,27 @@
 module ModernTimes
   module JMS
     class SupervisorMBean < ModernTimes::Base::SupervisorMBean
-      r_attribute :message_counts, :list, 'Message counts for the workers', :message_counts
+      r_attribute :message_counts,        :list,  'Message counts for the workers', :message_counts
+      r_attribute :average_response_time, :float, 'Average response time',          :average_response_time
+      r_attribute :min_response_time,     :float, 'Minimum response time',          :min_response_time
+      r_attribute :max_response_time,     :float, 'Maximum response time',          :max_response_time
 
       def message_counts
         java.util.ArrayList.new(supervisor.message_counts)
       end
+
+      def average_response_time
+        supervisor.average_response_time
+      end
+
+      def min_response_time
+        supervisor.min_response_time
+      end
+
+      def max_response_time
+        supervisor.max_response_time
+      end
+
     end
   end
 end

data/lib/modern_times/jms/worker.rb

@@ -34,7 +34,7 @@ module ModernTimes
     module Worker
       include ModernTimes::Base::Worker
 
-      attr_reader :session, :message_count
+      attr_reader :session, :error_count, :time_track
       attr_accessor :message
 
       module ClassMethods
@@ -42,10 +42,6 @@ module ModernTimes
           Supervisor.new(manager, self, {}, worker_options)
         end
 
-        def marshal(option)
-          @marshaler = ModernTimes::MarshalStrategy.find(option)
-        end
-
         def destination_options
           options = dest_options.dup
           # Default the queue name to the Worker name if a destinations hasn't been specified
@@ -64,13 +60,18 @@ module ModernTimes
           dest_options[:queue_name] = name.to_s
         end
 
-        def dest_options
+       def dest_options
           @dest_options ||= {}
         end
 
-        def marshaler
-          # Default to ruby marshaling, but extenders can override as necessary
-          @marshaler ||= ModernTimes::MarshalStrategy::Ruby
+        def failure_queue(name, opts={})
+          @failure_queue_name = name.to_s
+        end
+
+        def failure_queue_name
+          # Don't overwrite if the user set to false, only if it was never set
+          @failure_queue_name = "#{default_name}Failure" if @failure_queue_name.nil?
+          @failure_queue_name
         end
       end
 
@@ -81,15 +82,18 @@ module ModernTimes
 
       def initialize(opts={})
         super
-        @status = 'initialized'
-        @message_count = 0
+        @status        = 'initialized'
+        # Supervisor will ask for counts in a separate thread
+        @time_track    = ModernTimes::TimeTrack.new
+        @error_count   = 0
       end
 
-      def setup
+      def message_count
+        @time_track.total_count
       end
 
       def status
-        @status || "Processing message #{message_count}"
+        @status || "Processing message #{@time_track.total_count}"
       end
 
       def real_destination_options
@@ -101,8 +105,6 @@ module ModernTimes
 
       # Start the event loop for handling messages off the queue
       def start
-        # Grab this to prevent lookup with every message
-        @message_marshaler = self.class.marshaler
         @session = Connection.create_consumer_session
         @consumer = @session.consumer(real_destination_options)
         @session.start
@@ -110,24 +112,23 @@ module ModernTimes
         ModernTimes.logger.debug "#{self}: Starting receive loop"
         @status = nil
         while msg = @consumer.receive
-          sec = Benchmark.realtime do
-            @message_count += 1
+          @time_track.perform do
             on_message(msg)
             msg.acknowledge
           end
-          ModernTimes.logger.info {"#{self}::perform (#{('%.1f' % (sec*1000))}ms)"}
+          ModernTimes.logger.info {"#{self}::on_message (#{('%.1f' % @time_track.last_time)}ms)"} if ModernTimes::JMS::Connection.log_times?
         end
         @status = 'Exited'
         ModernTimes.logger.info "#{self}: Exiting"
-      rescue javax.jms.IllegalStateException => e
-        #if e.cause.code == Java::org.jms.api.core.JMSException::OBJECT_CLOSED
-          # Normal exit
-          @status = 'Exited'
-          ModernTimes.logger.info "#{self}: Exiting due to close"
-        #else
-        #  @status = "Exited with JMS exception #{e.message}"
-        #  ModernTImes.logger.error "#{self} JMSException: #{e.message}\n#{e.backtrace.join("\n")}"
-        #end
+#      rescue javax.jms.IllegalStateException => e
+#        #if e.cause.code == Java::org.jms.api.core.JMSException::OBJECT_CLOSED
+#          # Normal exit
+#          @status = 'Exited'
+#          ModernTimes.logger.info "#{self}: Exiting due to possible close: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+#        #else
+#        #  @status = "Exited with JMS exception #{e.message}"
+#        #  ModernTImes.logger.error "#{self} JMSException: #{e.message}\n#{e.backtrace.join("\n")}"
+#        #end
       rescue Exception => e
         @status = "Exited with exception #{e.message}"
         ModernTimes.logger.error "#{self}: Exception, thread terminating: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
@@ -143,31 +144,33 @@ module ModernTimes
 
       def on_message(message)
         @message = message
-        object = @message_marshaler.unmarshal(message.data)
+        marshaler = ModernTimes::MarshalStrategy.find(message['marshal'] || :ruby)
+        object = marshaler.unmarshal(message.data)
         ModernTimes.logger.debug {"#{self}: Received Object: #{object}"}
         perform(object)
+      rescue Exception => e
+        @error_count += 1
+        on_exception(e)
+      ensure
         ModernTimes.logger.debug {"#{self}: Finished processing message"}
         ModernTimes.logger.flush if ModernTimes.logger.respond_to?(:flush)
-      rescue Exception => e
-        ModernTimes.logger.error "#{self}: Messaging Exception: #{e.inspect}\n#{e.backtrace.inspect}"
-      rescue java.lang.Exception => e
-        ModernTimes.logger.error "#{self}: Java Messaging Exception: #{e.inspect}\n#{e.backtrace.inspect}"
       end
 
       def perform(object)
         raise "#{self}: Need to override perform method in #{self.class.name} in order to act on #{object}"
       end
 
-      def to_s
-        "#{real_destination_options.to_a.join('=>')}:#{index}"
+      def on_exception(e)
+        ModernTimes.logger.error "#{self}: Messaging Exception: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+        if self.class.failure_queue_name
+          session.producer(:queue_name => self.class.failure_queue_name) do |producer|
+            producer.send(message)
+          end
+        end
       end
 
-      #########
-      protected
-      #########
-
-      # Create session information and allow extenders to initialize anything necessary prior to the event loop
-      def session_init
+      def to_s
+        "#{real_destination_options.to_a.join('=>')}:#{index}"
       end
     end
   end

data/lib/modern_times/manager.rb

@@ -11,11 +11,11 @@ module ModernTimes
       @config = config
       @domain = config[:domain] || ModernTimes::DEFAULT_DOMAIN
       @supervisors = []
+      @dummy_host = config[:dummy_host]
       self.persist_file = config[:persist_file]
       self.worker_file  = config[:worker_file]
       @allowed_workers = config[:allowed_workers]
       stop_on_signal if config[:stop_on_signal]
-      @dummy_host = config[:dummy_host]
       # Unless specifically unconfigured (i.e., Rails.env == test), then enable jmx
       if config[:jmx] != false
         @jmx_server = JMX::MBeanServer.new
@@ -60,6 +60,7 @@ module ModernTimes
     end
 
     def stop
+      return if @stopped
       @stopped = true
       @supervisors.each { |supervisor| supervisor.stop }
     end
@@ -81,8 +82,9 @@ module ModernTimes
     end
 
     def persist_file=(file)
+      return if @persist_file == file
+      @persist_file = nil
       return unless file
-      @persist_file = file
       if File.exist?(file)
         hash = YAML.load_file(file)
         hash.each do |worker_name, worker_hash|
@@ -93,6 +95,7 @@ module ModernTimes
           add(klass, count, options)
         end
       end
+      @persist_file = file
     end
 
     def save_persist_state
@@ -107,6 +110,7 @@ module ModernTimes
       end
       File.open(@persist_file, 'w') do |out|
         YAML.dump(hash, out )
+        YAML.dump(hash, out )
       end
     end
 

data/lib/modern_times/marshal_strategy.rb

@@ -1,9 +1,3 @@
-require 'modern_times/marshal_strategy/bson'
-require 'modern_times/marshal_strategy/json'
-require 'modern_times/marshal_strategy/ruby'
-require 'modern_times/marshal_strategy/string'
-require 'modern_times/marshal_strategy/yaml'
-
 # Defines some default marshaling strategies for use in marshaling/unmarshaling objects
 # written and read via jms.  Implementing classes must define the following methods:
 #
@@ -27,26 +21,23 @@ require 'modern_times/marshal_strategy/yaml'
 
 module ModernTimes
   module MarshalStrategy
-    @options = {
-        :ruby   => Ruby,
-        :string => String,
-        :json   => JSON,
-        :bson   => BSON,
-        :yaml   => YAML,
-    }
+
+    @options = {}
 
     def self.find(marshaler)
       if marshaler.nil?
         return Ruby
-      elsif marshaler.kind_of? Symbol
-        val = @options[marshaler]
+      else
+        val = @options[marshaler.to_sym]
         return val if val
-      elsif valid?(marshaler)
-        return marshaler
       end
       raise "Invalid marshal strategy: #{marshaler}"
     end
 
+    def self.registered?(marshaler)
+      @options.has_key?(marshaler.to_sym)
+    end
+
     # Allow user-defined marshal strategies
     def self.register(hash)
       hash.each do |key, marshaler|
@@ -66,3 +57,9 @@ module ModernTimes
     end
   end
 end
+
+require 'modern_times/marshal_strategy/bson'
+require 'modern_times/marshal_strategy/json'
+require 'modern_times/marshal_strategy/ruby'
+require 'modern_times/marshal_strategy/string'
+require 'modern_times/marshal_strategy/yaml'

data/lib/modern_times/marshal_strategy/bson.rb

@@ -17,6 +17,8 @@ module ModernTimes
           ::BSON.deserialize(msg)
         end
 
+        MarshalStrategy.register(:bson => self)
+
       rescue LoadError => e
         def marshal(object)
           raise 'Error: BSON marshaling specified but bson gem has not been installed'