modern_times 0.3.1 → 0.3.2

data/History.md

@@ -0,0 +1,9 @@
+ModernTimes Changelog
+=====================
+
+0.3.2 (pending)
+-----
+
+ - Bug fixes
+ - Allow response options like time_to_live and persistence in publisher
+

data/README.rdoc

@@ -10,9 +10,6 @@ Still alpha but approaching beta.  API still subject to change.
 
 == Features/Problems:
 
-* jms_test and jms_requestor_test don't exit
-* Railsable needs testing
-* failure_queue needs testing
 * Currently tested only for ActiveMQ
 
 == Install:
@@ -21,8 +18,6 @@ Still alpha but approaching beta.  API still subject to change.
 
 == Rails Usage:
 
-TODO: This section needs updating for JMS
-
 Create config/jms.yml which might look as follows:
 
     development_server: &defaults
@@ -40,13 +35,13 @@ Create config/jms.yml which might look as follows:
       <<: *defaults
       :broker_url: tcp://stage2:61616
       :username: myuser
-      :password: <%=Encryption.try_decrypt "fadsfdasfdsfdasfdsafas" %>
+      :password: mypassword
 
     production:
       <<: *defaults
-      :broker_url: failover://(tcp://msg1:61616,tcp://msg2:61616)?randomize=false&timeout=60000&initialReconnectDelay=100&useExponentialBackOff=true
+      :broker_url: failover://(tcp://msg1:61616,tcp://msg2:61616)?randomize=false&initialReconnectDelay=100&useExponentialBackOff=true&maxCacheSize=524288&trackMessages=true
       :username: myuser
-      :password: <%=Encryption.try_decrypt "afsadsfasdfa/afasdfdasf\n" %>
+      :password: mypassword
 
 In development and test mode, you will notice that there is no configuration defined.  In this case, published messages will cause
 synchronous calls to the Worker's perform method which matches the destination queue or topic.

data/TODO.md

@@ -0,0 +1,10 @@
+TODO
+========
+
+ * jms/consumer.rb - is it needed? is dummy stuff needed?
+ * Better API documentation
+ * jms_test and jms_requestor_test don't exit
+ * Responses aren't non-persistent?  Why are timed out responses ending up in the DLQ?
+ * RequestWorker needs option for failure queue as well as sending exception in response
+ * Batch file handling coming soon
+ * More thorough test coverage, especially the various options, Railsable, etc.

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.3.2

data/examples/simple/.gitignore

@@ -1,2 +1,2 @@
 data
-*.state
+modern_times.yml

data/examples/simple/README

@@ -1,12 +1,13 @@
 # Step 0
 # Follow the directions for configuring jms.yml located in examples/README
+# Perform steps 1-4 in separate terminals
 
 # Step 1
 # Start a JMS Server
 
 # Step 2
 # Start up the manager
-rm -f modern_times.state
+rm -f modern_times.yml
 jruby manager.rb
 
 # Step 3
@@ -18,7 +19,7 @@ jruby manager.rb
 # Enter BazWorker for worker, 3 for count, clear the options field, and click the start_worker button.
 
 # Step 4
-# Publish 10 messages to the BarWorker and 20 to the BazWorker
+# Publish 10 messages to the BarWorker and 5 to the BazWorker
 jruby publish.rb 10 5
 
 # Step 5

data/examples/simple/bar_worker.rb

@@ -1,6 +1,5 @@
 class BarWorker
   include ModernTimes::JMS::Worker
-  marshal :bson
 
   def perform(obj)
     puts "#{self}: Received #{obj.inspect} at #{Time.now}"

data/examples/simple/baz_worker.rb

@@ -1,6 +1,5 @@
 class BazWorker 
   include ModernTimes::JMS::Worker
-  marshal :string
 
   def perform(obj)
     puts "#{self}: Received #{obj} at #{Time.now}"

data/examples/simple/manager.rb

@@ -11,7 +11,7 @@ require 'baz_worker'
 config = YAML.load(ERB.new(File.read(File.join(File.dirname(__FILE__), '..', 'jms.yml'))).result(binding))
 ModernTimes::JMS::Connection.init(config)
 
-manager = ModernTimes::Manager.new(:persist_file => 'modern_times.state')
+manager = ModernTimes::Manager.new(:persist_file => 'modern_times.yml')
 manager.stop_on_signal
 manager.allowed_workers = [BarWorker,BazWorker]
 #manager.add(BarWorker, 2, {})

data/lib/modern_times/base/supervisor.rb

@@ -14,7 +14,6 @@ module ModernTimes
         @worker_options = worker_options
         @workers        = []
         @worker_mutex   = Mutex.new
-        @failure_mutex  = Mutex.new
       end
 
       def worker_count
@@ -70,11 +69,7 @@ module ModernTimes
       end
 
       def join
-        @workers.each { |worker| worker.thread.join }
-      end
-
-      def failure(worker, message)
-        
+        @workers.each { |worker| worker.join }
       end
 
       def mbean_name(domain)

data/lib/modern_times/base/worker.rb

@@ -36,6 +36,10 @@ module ModernTimes
         raise "Need to override stop method in #{self.class.name}"
       end
 
+      def join
+        thread.join
+      end
+
       def status
         raise "Need to override status method in #{self.class.name}"
       end

data/lib/modern_times/jms/publish_handle.rb

@@ -63,7 +63,7 @@ module ModernTimes
       end
 
       def dummy_read_response(timeout, &block)
-        raise "Invalid call to read_response for #{@publisher}, not setup for responding" unless @publisher.response
+        raise "Invalid call to read_response for #{@publisher}, not setup for responding" unless @publisher.response?
         do_read_response(nil, timeout, &block)
       end
 
@@ -183,11 +183,11 @@ module ModernTimes
           message = consumer.receive(100)
         end
         return nil unless message
-        @name = message['worker']
-        if error_yaml = message['exception']
+        @name = message['mt:worker']
+        if error_yaml = message['mt:exception']
           return ModernTimes::RemoteException.from_hash(YAML.load(error_yaml))
         end
-        marshaler = ModernTimes::MarshalStrategy.find(message['marshal'] || :ruby)
+        marshaler = ModernTimes::MarshalStrategy.find(message['mt:marshal'] || :ruby)
         return marshaler.unmarshal(message.data)
       end
 

data/lib/modern_times/jms/publisher.rb

@@ -4,23 +4,24 @@ require 'jms'
 module ModernTimes
   module JMS
     class Publisher
-      attr_reader :producer_options, :persistent, :marshaler, :reply_queue, :response
+      attr_reader :producer_options, :persistent, :marshaler, :reply_queue
 
       @@dummy_publishing = false
 
       # Parameters:
       #   One of the following must be specified
-      #     :queue_name         => String: Name of the Queue to publish to
-      #     :topic_name         => String: Name of the Topic to publish to
-      #     :virtual_topic_name => String: Name of the Virtual Topic to publish to
+      #     :queue_name            => String: Name of the Queue to publish to
+      #     :topic_name            => String: Name of the Topic to publish to (In general this should not be used as all worker threads will receive all messages)
+      #     :virtual_topic_name    => String: Name of the Virtual Topic to publish to
       #        (ActiveMQ only, see http://activemq.apache.org/virtual-destinations.html
-      #     :destination        => Explicit javax::Jms::Destination to use
+      #     :destination           => Explicit javax::Jms::Destination to use
       #   Optional:
-      #     :persistent         => true or false (defaults to false)
-      #     :marshal            => Symbol: One of :ruby, :string, :json, :bson, :yaml or any registered types (See ModernTimes::MarshalStrategy), defaults to :ruby
-      #                         => Module: Module that defines marshal and unmarshal method
-      #     :time_to_live       => expiration time in ms for the message
-      #     :response           => if true, a temporary reply queue will be setup for handling responses (defaults to false)
+      #     :time_to_live          => expiration time in ms for the message
+      #     :persistent            => true or false (defaults to false)
+      #     :marshal               => Symbol: One of :ruby, :string, :json, :bson, :yaml or any registered types (See ModernTimes::MarshalStrategy), defaults to :ruby
+      #     :response              => if true, a temporary reply queue will be setup for handling responses (defaults to false unless any other mt_response_* options are set)
+      #     :response_time_to_live => expiration time in ms for the response message(s)
+      #     :response_persistent   => true or false for the response message(s), set to false if you don't want timed out messages ending up in the DLQ (defaults to true unless mt_response_time_to_live is set)
       def initialize(options)
         raise "ModernTimes::JMS::Connection has not been initialized" unless ModernTimes::JMS::Connection.inited? || @@dummy_publishing
         producer_keys = [:queue_name, :topic_name, :virtual_topic_name, :destination]
@@ -33,22 +34,27 @@ module ModernTimes
         virtual_topic_name = @real_producer_options.delete(:virtual_topic_name)
         @real_producer_options[:topic_name] = "VirtualTopic.#{virtual_topic_name}" if virtual_topic_name
 
-        # If we're in dummy mode, this probably won't be defined
-        #@persistent = options[:persistent] ? ::JMS::DeliveryMode::PERSISTENT : ::JMS::DeliveryMode::NON_PERSISTENT
-        @persistent = options[:persistent] ? :persistent : :non_persistent
+        @persistent_sym = options[:persistent] ? :persistent : :non_persistent
         @marshal = options[:marshal] || :ruby
         @marshaler = ModernTimes::MarshalStrategy.find(@marshal)
         @time_to_live = options[:time_to_live]
+        @response_time_to_live_str = options[:response_time_to_live] && options[:response_time_to_live].to_s
+        @response_persistent_str = nil
+        @response_persistent_str = (!!options[:response_persistent]).to_s unless options[:response_persistent].nil?
 
+        @is_response = options[:response] || !@response_time_to_live_str.nil? || !@response_persistent_str.nil?
         @reply_queue = nil
-        @response = options[:response]
-        if !@@dummy_publishing  && @response
+        if !@@dummy_publishing  && @is_response
           ModernTimes::JMS::Connection.session_pool.session do |session|
             @reply_queue = session.create_destination(:queue_name => :temporary)
           end
         end
       end
 
+      def response?
+        @is_response
+      end
+
       # Publish the given object to the address.
       def publish(object, props={})
         start = Time.now
@@ -56,9 +62,11 @@ module ModernTimes
         Connection.session_pool.producer(@real_producer_options) do |session, producer|
           producer.time_to_live = @time_to_live if @time_to_live
           message = ModernTimes::JMS.create_message(session, @marshaler, object)
-          message.jms_delivery_mode_sym = @persistent
-          message.jms_reply_to = @reply_queue if @reply_queue
-          message['marshal'] = @marshal.to_s
+          message.jms_delivery_mode_sym       = @persistent_sym
+          message.jms_reply_to                = @reply_queue if @reply_queue
+          message['mt:marshal']               = @marshal.to_s
+          message['mt:response:time_to_live'] = @response_time_to_live_str if @response_time_to_live_str
+          message['mt:response:persistent']   = @response_persistent_str unless @response_persistent_str.nil?
           props.each do |key, value|
             message.send("#{key}=", value)
           end
@@ -75,7 +83,7 @@ module ModernTimes
         # Model real queue marshaling/unmarshaling
         trans_object = @marshaler.unmarshal(@marshaler.marshal(object))
         @@workers.each do |worker|
-          if ModernTimes::JMS.same_destination?(@producer_options, worker.class.destination_options)
+          if ModernTimes::JMS.same_destination?(@producer_options, worker.destination_options)
             if worker.kind_of?(RequestWorker)
               ModernTimes.logger.debug "Dummy request publishing #{trans_object} to #{worker}"
               m = worker.marshaler

data/lib/modern_times/jms/request_worker.rb

@@ -1,7 +1,7 @@
 module ModernTimes
   module JMS
 
-    # Base Worker Class for any class that will be processing messages from queues
+    # Base Worker Class for any class that will be processing requests from queues and replying
     module RequestWorker
       include Worker
       # Dummy requesting needs access to this
@@ -17,6 +17,11 @@ module ModernTimes
           # Get the response marshaler, defaulting to the request marshaler
           @response_options
         end
+
+        # By default, exceptions don't get forwarded to a fail queue (they get returned to the caller)
+        def default_fail_queue_target
+          false
+        end
       end
 
       def self.included(base)
@@ -32,40 +37,66 @@ module ModernTimes
         @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
+        @time_to_live = response_options[:time_to_live]
+        @persistent   = response_options[:persistent]
       end
 
       def perform(object)
         response = request(object)
-        session.producer(:destination => message.reply_to) do |producer|
-          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
+        send_response(@marshal_type, @marshaler, response)
       rescue Exception => e
-        ModernTimes.logger.error("Exception: #{e.message}\n\t#{e.backtrace.join("\n\t")}")
+        on_exception(e)
+      end
+
+      def request(object)
+        raise "#{self}: Need to override request method in #{self.class.name} in order to act on #{object}"
+      end
+
+      #########
+      protected
+      #########
+
+      def on_exception(e)
+        begin
+          stat = send_response(:string, ModernTimes::MarshalStrategy::String, "Exception: #{e.message}") do |reply_message|
+            reply_message['mt:exception'] = ModernTimes::RemoteException.new(e).to_hash.to_yaml
+          end
+        rescue Exception => e
+          ModernTimes.logger.error("Exception in exception reply: #{e.message}")
+          log_backtrace(e)
+        end
+
+        # Send it on to the fail queue if it was explicitly set
+        super
+      end
+
+      # Sending marshaler is redundant but saves a lookup
+      def send_response(marshal_type, marshaler, object)
+        return false unless message.reply_to
         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}")
+            # For time_to_live and jms_deliver_mode, first use the local response_options if they're' set, otherwise
+            # use the value from the message attributes if they're' set
+            time_to_live = @time_to_live || message['mt:response:time_to_live']
+            persistent   = @persistent
+            persistent = (message['mt:response:persistent'] == 'true') if persistent.nil? && message['mt:response:persistent']
+            # If persistent isn't set anywhere, then default to true unless time_to_live has been set
+            persistent = !time_to_live if persistent.nil?
+            producer.time_to_live = time_to_live.to_i if time_to_live
+            reply_message = ModernTimes::JMS.create_message(session, marshaler, object)
             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['exception'] = ModernTimes::RemoteException.new(e).to_hash.to_yaml
+            # The reply is persistent if we explicitly set it or if we don't expire
+            reply_message.jms_delivery_mode_sym = persistent ? :persistent : :non_persistent
+            reply_message['mt:marshal'] = marshal_type.to_s
+            reply_message['mt:worker'] = self.name
+            yield reply_message if block_given?
             producer.send(reply_message)
           end
         rescue Exception => e
-          ModernTimes.logger.error("Exception in exception reply: #{e.message}\n\t#{e.backtrace.join("\n\t")}")
+          ModernTimes.logger.error {"Error attempting to send response: #{e.message}"}
+          log_backtrace(e)
         end
-        raise
-      end
-
-      def request(object)
-        raise "#{self}: Need to override request method in #{self.class.name} in order to act on #{object}"
+        return true
       end
     end
   end

data/lib/modern_times/jms/worker.rb

@@ -5,7 +5,7 @@ module ModernTimes
   
     # Base Worker Class for any class that will be processing messages from topics or queues
     # By default, it will consume messages from a queue with the class name minus the Worker postfix.
-    # For example, the queue call is unneccessary as it will default to a value of 'Foo' anyways:
+    # For example, the queue call is unnecessary as it will default to a value of 'Foo' anyways:
     #  class FooWorker < ModernTimes::JMS::Worker
     #    queue 'Foo'
     #    def perform(obj)
@@ -34,7 +34,7 @@ module ModernTimes
     module Worker
       include ModernTimes::Base::Worker
 
-      attr_reader :session, :error_count, :time_track
+      attr_reader :session, :error_count, :time_track, :destination_options
       attr_accessor :message
 
       module ClassMethods
@@ -42,15 +42,6 @@ module ModernTimes
           Supervisor.new(manager, self, {}, worker_options)
         end
 
-        def destination_options
-          options = dest_options.dup
-          # Default the queue name to the Worker name if a destinations hasn't been specified
-          if options.keys.select {|k| [:virtual_topic_name, :queue_name, :destination].include?(k)}.empty?
-            options[:queue_name] = default_name
-          end
-          return options
-        end
-
         def virtual_topic(name, opts={})
           # ActiveMQ only
           dest_options[:virtual_topic_name] = name.to_s
@@ -60,18 +51,30 @@ module ModernTimes
           dest_options[:queue_name] = name.to_s
         end
 
-       def dest_options
+        def dest_options
           @dest_options ||= {}
         end
 
-        def failure_queue(name, opts={})
-          @failure_queue_name = name.to_s
+        # Set the fail_queue
+        # target =>
+        #   boolean
+        #     true - exceptions in the worker will cause the message to be forwarded to the queue of <default-name>Fail
+        #       For instance, an Exception in FooWorker#perform will forward the message to the queue FooFail
+        #     false - exceptions will not result in the message being forwarded to a fail queue
+        #   string - equivalent to true but the string defines the name of the fail queue
+        def fail_queue(target, opts={})
+          @fail_queue_target = name
         end
 
-        def failure_queue_name
+        def fail_queue_target
           # 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
+          @fail_queue_target
+        end
+
+        # Defines the default value of the fail_queue_target.  For extenders of this class, the default will be true
+        # but extenders can change this (RequestWorker returns exceptions to the caller so it defaults to false).
+        def default_fail_queue_target
+          true
         end
       end
 
@@ -82,10 +85,34 @@ module ModernTimes
 
       def initialize(opts={})
         super
+        @stopped       = false
         @status        = 'initialized'
-        # Supervisor will ask for counts in a separate thread
         @time_track    = ModernTimes::TimeTrack.new
         @error_count   = 0
+        @message_mutex = Mutex.new
+
+        @destination_options = self.class.dest_options.dup
+        # Default the queue name to the Worker name if a destinations hasn't been specified
+        if @destination_options.keys.select {|k| [:virtual_topic_name, :queue_name, :destination].include?(k)}.empty?
+          @destination_options[:queue_name] = self.name
+        end
+
+        @real_destination_options = @destination_options.dup
+        virtual_topic_name = @real_destination_options.delete(:virtual_topic_name)
+        @real_destination_options[:queue_name] = "Consumer.#{name}.VirtualTopic.#{virtual_topic_name}" if virtual_topic_name
+
+        target = opts[:fail_queue]
+        target = self.class.fail_queue_target if target.nil?
+        target = self.class.default_fail_queue_target if target.nil?
+        if target == true
+          @fail_queue_name = "#{name}Fail"
+        elsif target == false
+          @fail_queue_name = nil
+        elsif target.kind_of?(String)
+          @fail_queue_name = target
+        else
+          raise "Invalid fail queue: #{target}"
+        end
       end
 
       def message_count
@@ -96,25 +123,20 @@ module ModernTimes
         @status || "Processing message #{@time_track.total_count}"
       end
 
-      def real_destination_options
-        options = self.class.destination_options
-        virtual_topic_name = options.delete(:virtual_topic_name)
-        options[:queue_name] = "Consumer.#{name}.VirtualTopic.#{virtual_topic_name}" if virtual_topic_name
-        return options
-      end
-
       # Start the event loop for handling messages off the queue
       def start
         @session = Connection.create_consumer_session
-        @consumer = @session.consumer(real_destination_options)
+        @consumer = @session.consumer(@real_destination_options)
         @session.start
 
         ModernTimes.logger.debug "#{self}: Starting receive loop"
         @status = nil
-        while msg = @consumer.receive
+        while !@stopped && msg = @consumer.receive
           @time_track.perform do
-            on_message(msg)
-            msg.acknowledge
+            @message_mutex.synchronize do
+              on_message(msg)
+              msg.acknowledge
+            end
           end
           ModernTimes.logger.info {"#{self}::on_message (#{('%.1f' % (@time_track.last_time*1000.0))}ms)"} if ModernTimes::JMS::Connection.log_times?
         end
@@ -132,46 +154,69 @@ module ModernTimes
       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")}"
-      rescue java.lang.Exception => e
-        @status = "Exited with java exception #{e.message}"
-        ModernTimes.logger.error "#{self}: Java exception, thread terminating: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
       end
 
       def stop
-        @consumer.close if @consumer
-        @session.close if @session
+        @stopped = true
+        # Don't clobber the session before a reply
+        @message_mutex.synchronize do
+          @consumer.close if @consumer
+          @session.close if @session
+        end
+      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}"
+      end
+
+      #########
+      protected
+      #########
+
+      def fail_queue_name
+        @fail_queue_name
       end
 
       def on_message(message)
         @message = message
-        marshaler = ModernTimes::MarshalStrategy.find(message['marshal'] || :ruby)
+        marshaler = ModernTimes::MarshalStrategy.find(message['mt: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)
       end
 
-      def perform(object)
-        raise "#{self}: Need to override perform method in #{self.class.name} in order to act on #{object}"
+      def increment_error_count
+        @error_count += 1
       end
 
       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|
+        increment_error_count
+        ModernTimes.logger.error "#{self}: Messaging Exception: #{e.message}"
+        log_backtrace(e)
+        if fail_queue_name
+          session.producer(:queue_name => fail_queue_name) do |producer|
+            # TODO: Can't add attribute to read-only message?
+            #message['mt:exception'] = ModernTimes::RemoteException.new(e).to_hash.to_yaml
             producer.send(message)
           end
         end
+      rescue Exception => e
+        ModernTimes.logger.error "#{self}: Exception in exception reply: #{e.message}"
+        log_backtrace(e)
       end
 
-      def to_s
-        "#{real_destination_options.to_a.join('=>')}:#{index}"
+      def log_backtrace(e)
+        ModernTimes.logger.error "\t#{e.backtrace.join("\n\t")}"
       end
     end
   end
-end
+end

data/lib/modern_times/manager.rb

@@ -110,7 +110,6 @@ module ModernTimes
       end
       File.open(@persist_file, 'w') do |out|
         YAML.dump(hash, out )
-        YAML.dump(hash, out )
       end
     end
 

data/test/jms.yml

@@ -3,7 +3,7 @@
 :log_times: false
 :require_jars:
   - <%= Dir.glob("#{ENV['ACTIVEMQ_HOME']}/activemq-all-*.jar")[0] %>
-  #- <%= Dir.glob("#{ENV['ACTIVEMQ_HOME']}/lib/optional/slf4j-log4j*.jar")[0] %>
-  #- <%= Dir.glob("#{ENV['ACTIVEMQ_HOME']}/lib/optional/log4j-*.jar")[0] %>
+  - <%= Dir.glob("#{ENV['ACTIVEMQ_HOME']}/lib/optional/slf4j-log4j*.jar")[0] %>
+  - <%= Dir.glob("#{ENV['ACTIVEMQ_HOME']}/lib/optional/log4j-*.jar")[0] %>
 #:username: myuser
 #:password: mypassword

data/test/jms_fail_test.rb

@@ -0,0 +1,149 @@
+require 'modern_times'
+require 'shoulda'
+require 'test/unit'
+require 'fileutils'
+require 'erb'
+
+# NOTE: This test requires a running ActiveMQ server
+
+class ExceptionWorker
+  include ModernTimes::JMS::Worker
+  def perform(obj)
+    puts "#{name} received #{obj} but raising exception"
+    raise 'foobar'
+  end
+
+  def log_backtrace(e)
+  end
+end
+
+class ExceptionRequestWorker
+  include ModernTimes::JMS::RequestWorker
+
+  def request(obj)
+    puts "#{name} received #{obj} but raising exception"
+    raise 'foobar'
+  end
+
+  def log_backtrace(e)
+  end
+end
+
+# This will read from the queue that ExceptionWorker fails to
+class ExceptionFailWorker
+  include ModernTimes::JMS::Worker
+
+  @@my_hash = {}
+
+  def self.my_obj(name)
+    @@my_hash[name]
+  end
+
+  def perform(obj)
+    puts "#{name} received #{obj}"
+    @@my_hash[name] = obj
+  end
+end
+
+class JMSFailTest < Test::Unit::TestCase
+
+  def assert_fail_queue(queue_name, fail_queue_name, value, is_fail_queue_expected)
+    # Publish to Exception that will throw exception which will put on ExceptionFail queue
+    publisher = ModernTimes::JMS::Publisher.new(:queue_name => queue_name, :marshal => :string)
+    puts "Publishing #{value} to #{queue_name}"
+    publisher.publish(value)
+    sleep 1
+    expected_value = (is_fail_queue_expected ? value : nil)
+    assert_equal expected_value, ExceptionFailWorker.my_obj(fail_queue_name)
+  end
+
+  context 'jms' do
+    setup do
+      config = YAML.load(ERB.new(File.read(File.join(File.dirname(__FILE__), 'jms.yml'))).result(binding))
+      ModernTimes::JMS::Connection.init(config)
+    end
+
+    teardown do
+    end
+
+    context "worker with exception" do
+      setup do
+        @manager = ModernTimes::Manager.new
+
+        # Should receive message on the fail worker when using with default names
+        @manager.add(ExceptionWorker, 1)
+        @manager.add(ExceptionFailWorker, 1)
+
+        # Should receive message on the fail worker when using specified names
+        name = 'ExceptionNameSpecified'
+        @manager.add(ExceptionWorker, 1, :name => name)
+        @manager.add(ExceptionFailWorker, 1, :name => "#{name}Fail")
+
+        # Should receive message on the fail worker when using specified names and fail_queue set true
+        name = 'ExceptionFailQueueTrue'
+        @manager.add(ExceptionWorker, 1, :name => name, :fail_queue => true)
+        @manager.add(ExceptionFailWorker, 1, :name => "#{name}Fail")
+
+        # Should NOT receive message on the fail worker when using specified names and fail_queue set false
+        name = 'ExceptionFailQueueFalse'
+        @manager.add(ExceptionWorker, 1, :name => name, :fail_queue => false)
+        @manager.add(ExceptionFailWorker, 1, :name => "#{name}Fail")
+
+        # Should NOT receive message on the fail worker when using specified names and fail_queue set false
+        name = 'ExceptionFailQueueSpecified'
+        fail_queue = 'MyFailQueue'
+        @manager.add(ExceptionWorker, 1, :name => name, :fail_queue => fail_queue)
+        @manager.add(ExceptionFailWorker, 1, :name => fail_queue)
+
+        # Should NOT receive message on the fail worker
+        name = 'ExceptionRequest'
+        @manager.add(ExceptionRequestWorker, 1)
+        @manager.add(ExceptionFailWorker, 1, :name => "#{name}Fail")
+
+        # Should NOT receive message on the fail worker when using specified names
+        name = 'ExceptionRequestNameSpecified'
+        @manager.add(ExceptionRequestWorker, 1, :name => name)
+        @manager.add(ExceptionFailWorker, 1, :name => "#{name}Fail")
+
+        # Should receive message on the fail worker when using specified names and fail_queue set true
+        name = 'ExceptionRequestFailQueueTrue'
+        @manager.add(ExceptionRequestWorker, 1, :name => name, :fail_queue => true)
+        @manager.add(ExceptionFailWorker, 1, :name => "#{name}Fail")
+
+        # Should NOT receive message on the fail worker when using specified names and fail_queue set false
+        name = 'ExceptionRequestFailQueueFalse'
+        @manager.add(ExceptionRequestWorker, 1, :name => name, :fail_queue => false)
+        @manager.add(ExceptionFailWorker, 1, :name => "#{name}Fail")
+
+        # Should NOT receive message on the fail worker when using specified names and fail_queue set false
+        name = 'ExceptionRequestFailQueueSpecified'
+        fail_queue = 'MyRequestFailQueue'
+        @manager.add(ExceptionRequestWorker, 1, :name => name, :fail_queue => fail_queue)
+        @manager.add(ExceptionFailWorker, 1, :name => fail_queue)
+
+        sleep 1
+      end
+
+      teardown do
+        if @manager
+          @manager.stop
+          @manager.join
+        end
+      end
+
+      should "write fail messages to a fail queue" do
+        assert_fail_queue('Exception',                          'ExceptionFail',                      'value0', true)
+        assert_fail_queue('ExceptionNameSpecified',             'ExceptionNameSpecifiedFail',         'value1', true)
+        assert_fail_queue('ExceptionFailQueueTrue',             'ExceptionFailQueueTrueFail',         'value2', true)
+        assert_fail_queue('ExceptionFailQueueFalse',            'ExceptionFailQueueFalseFail',        'value3', false)
+        assert_fail_queue('ExceptionFailQueueSpecified',        'MyFailQueue',                        'value4', true)
+
+        assert_fail_queue('ExceptionRequest',                   'ExceptionRequestFail',               'value5', false)
+        assert_fail_queue('ExceptionRequestNameSpecified',      'ExceptionRequestNameSpecifiedFail',  'value6', false)
+        assert_fail_queue('ExceptionRequestFailQueueTrue',      'ExceptionRequestFailQueueTrueFail',  'value7', true)
+        assert_fail_queue('ExceptionRequestFailQueueFalse',     'ExceptionRequestFailQueueFalseFail', 'value8', false)
+        assert_fail_queue('ExceptionRequestFailQueueSpecified', 'MyRequestFailQueue',                 'value9', true)
+      end
+    end
+  end
+end

data/test/jms_requestor_block_test.rb

@@ -29,11 +29,14 @@ class BaseRequestWorker
     raise Exception,'my exception' if self.class.do_exception
     sleep self.class.sleep_time if self.class.sleep_time
   end
+
+  def log_backtrace(e)
+  end
 end
 
 class CharCountWorker < BaseRequestWorker
   virtual_topic 'test_string'
-  response :marshal => :bson, :time_to_live => 10000
+  response :marshal => :bson
 
   def request(obj)
     super
@@ -45,7 +48,7 @@ end
 
 class LengthWorker < BaseRequestWorker
   virtual_topic 'test_string'
-  response :marshal => :ruby, :time_to_live => 10000
+  response :marshal => :ruby
 
   def request(obj)
     super
@@ -55,7 +58,7 @@ end
 
 class ReverseWorker < BaseRequestWorker
   virtual_topic 'test_string'
-  response :marshal => :string, :time_to_live => 10000
+  response :marshal => :string
 
   def request(obj)
     super
@@ -65,7 +68,7 @@ end
 
 class TripleWorker < BaseRequestWorker
   virtual_topic 'test_string'
-  response :marshal => :string, :time_to_live => 10000
+  response :marshal => :string
 
   def request(obj)
     super
@@ -175,7 +178,7 @@ class JMSRequestorBlockTest < Test::Unit::TestCase
 
       should "handle replies" do
 
-        publisher = ModernTimes::JMS::Publisher.new(:virtual_topic_name => 'test_string', :response => true, :marshal => :string)
+        publisher = ModernTimes::JMS::Publisher.new(:virtual_topic_name => 'test_string', :response_time_to_live => 10000, :marshal => :string)
         cc_val = {'f' => 1, 'o' => 4, 'b' => 1}
 
         hash = make_call(publisher, 'fooboo', 2)

data/test/jms_requestor_test.rb

@@ -76,7 +76,7 @@ end
 
 class DefaultWorker
   include ModernTimes::JMS::RequestWorker
-  response :marshal => :yaml, :time_to_live => 10000
+  response :marshal => :yaml
 
   def request(obj)
     options[:tester].request(obj)
@@ -85,7 +85,7 @@ end
 
 class SleepWorker
   include ModernTimes::JMS::RequestWorker
-  response :marshal => :string, :time_to_live => 10000
+  response :marshal => :string
 
   def request(i)
     sleep i.to_i
@@ -134,7 +134,7 @@ class JMSRequestorTest < Test::Unit::TestCase
 
           sleep 1
 
-          publisher = ModernTimes::JMS::Publisher.new(:queue_name => 'Default', :marshal => marshal, :response => true)
+          publisher = ModernTimes::JMS::Publisher.new(:queue_name => 'Default', :marshal => marshal, :response_time_to_live => 10000)
           threads = []
           start = Time.now
           (0..9).each do |i|
@@ -161,7 +161,7 @@ class JMSRequestorTest < Test::Unit::TestCase
         @manager = ModernTimes::Manager.new(:domain => @domain)
         @manager.add(SleepWorker, 10)
         sleep 1
-        @publisher = ModernTimes::JMS::Publisher.new(:queue_name => 'Sleep', :marshal => :string, :response => true)
+        @publisher = ModernTimes::JMS::Publisher.new(:queue_name => 'Sleep', :marshal => :string, :response_time_to_live => 10000)
       end
 
       teardown do

data/test/jms_test.rb

@@ -13,8 +13,8 @@ module WorkerHelper
     super
     @tester = opts[:tester]
     @@mutex.synchronize do
-      @@workers[self.class.name] ||= []
-      @@workers[self.class.name] << self
+      @@workers[self.name] ||= []
+      @@workers[self.name] << self
     end
     @hash = Hash.new(0)
   end
@@ -23,8 +23,10 @@ module WorkerHelper
     add_message(@tester.translate(obj))
   end
 
-  def self.workers(worker_klass)
-    @@workers[worker_klass.name]
+  def self.workers(names)
+    workers = []
+    names.each {|name| workers += @@workers[name]}
+    workers
   end
 
   def self.reset_workers
@@ -35,7 +37,7 @@ module WorkerHelper
     @hash[i] += 1
   end
 
-  def message_count
+  def call_count
     puts "hash=#{@hash.inspect}"
     @hash.values.reduce(:+)
   end
@@ -144,17 +146,15 @@ class JMSTest < Test::Unit::TestCase
     end
   end
   
-  def assert_worker(domain, worker_klasses, mbean_names, worker_count, range, min, max, instance_count)
-    puts "Checking #{worker_klasses.inspect}"
-    worker_klasses = [worker_klasses] unless worker_klasses.kind_of?(Array)
-    mbean_names = [mbean_names] unless mbean_names.kind_of?(Array)
-    workers = []
-    worker_klasses.each {|klass| workers.concat(WorkerHelper.workers(klass))}
+  def assert_worker(domain, names, worker_count, range, min, max, instance_count)
+    puts "Checking #{names.inspect}"
+    names = [names] unless names.kind_of?(Array)
+    workers = WorkerHelper.workers(names)
 
     assert_equal worker_count, workers.size
     all_messages = []
     workers.each do |worker|
-      msg_count = worker.message_count
+      msg_count = worker.call_count
       assert msg_count
       assert msg_count >= min, "#{msg_count} is not between #{min} and #{max}"
       assert msg_count <= max, "#{msg_count} is not between #{min} and #{max}"
@@ -167,8 +167,8 @@ class JMSTest < Test::Unit::TestCase
 
     if domain
       total_count = 0
-      mbean_names.each do |mbean_name|
-        bean = @@client[ModernTimes.supervisor_mbean_object_name(domain, mbean_name)]
+      names.each do |name|
+        bean = @@client[ModernTimes.supervisor_mbean_object_name(domain, name)]
         bean.message_counts.each do |msg_count|
           total_count += msg_count
           assert msg_count >= min, "#{msg_count} is not between #{min} and #{max}"
@@ -224,19 +224,21 @@ class JMSTest < Test::Unit::TestCase
           sleep 1
 
           publish(marshal, tester, 100..199, :queue_name => 'Default')
-          publish(marshal, tester, 200..299, :queue_name => 'Dummy_Default')
-          publish(marshal, tester, 300..499, :queue_name => 'MyQueueName')
-          publish(marshal, tester, 500..599, :virtual_topic_name => 'MyTopicName')
+          publish(marshal, tester, 200..299, :queue_name => 'DefaultClone')
+          publish(marshal, tester, 300..399, :queue_name => 'Dummy_Default')
+          publish(marshal, tester, 400..599, :queue_name => 'MyQueueName')
+          publish(marshal, tester, 600..699, :virtual_topic_name => 'MyTopicName')
 
           # Let the workers do their thing
           sleep 5
 
           # DefaultWorker should have 5 instances running with each worker handling between 10-30 messages in the range 100.199
-          assert_worker(@domain, DefaultWorker,                                ['Default', 'DefaultClone'],                                  5, 100..199, 10, 30, 1)
-          assert_worker(@domain, Dummy::DefaultWorker,                         'Dummy_Default',                                              4, 200..299, 15, 35, 1)
-          assert_worker(@domain, [SpecifiedQueueWorker,SpecifiedQueue2Worker], ['SpecifiedQueue', 'SpecifiedQueueClone', 'SpecifiedQueue2'], 7, 300..499, 20, 40, 1)
-          assert_worker(@domain, SpecifiedTopicWorker,                         ['SpecifiedTopic', 'SpecifiedTopicClone'],                    5, 500..599, 30, 60, 2)
-          assert_worker(@domain, SpecifiedTopic2Worker,                        'SpecifiedTopic2',                                            2, 500..599, 35, 65, 1)
+          assert_worker(@domain, 'Default',                                                    3, 100..199, 30, 36, 1)
+          assert_worker(@domain, 'DefaultClone',                                               2, 200..299, 45, 55, 1)
+          assert_worker(@domain, 'Dummy_Default',                                              4, 300..399, 20, 30, 1)
+          assert_worker(@domain, ['SpecifiedQueue', 'SpecifiedQueueClone', 'SpecifiedQueue2'], 7, 400..599, 20, 40, 1)
+          assert_worker(@domain, ['SpecifiedTopic', 'SpecifiedTopicClone'],                    5, 600..699, 30, 60, 2)
+          assert_worker(@domain, 'SpecifiedTopic2',                                            2, 600..699, 35, 65, 1)
         end
       end
     end
@@ -246,10 +248,13 @@ class JMSTest < Test::Unit::TestCase
         WorkerHelper.reset_workers
         workers = [
           DefaultWorker.new(:tester => RubyTest),
+          DefaultWorker.new(:tester => RubyTest, :name => 'DefaultClone'),
           Dummy::DefaultWorker.new(:tester => RubyTest),
           SpecifiedQueueWorker.new(:tester => RubyTest),
+          SpecifiedQueueWorker.new(:tester => RubyTest, :name => 'SpecifiedQueueClone'),
           SpecifiedQueue2Worker.new(:tester => RubyTest),
           SpecifiedTopicWorker.new(:tester => RubyTest),
+          SpecifiedTopicWorker.new(:tester => RubyTest, :name => 'SpecifiedTopicClone'),
           SpecifiedTopic2Worker.new(:tester => RubyTest),
         ]
         ModernTimes::JMS::Publisher.setup_dummy_publishing(workers)
@@ -261,17 +266,21 @@ class JMSTest < Test::Unit::TestCase
 
       should "directly call applicable workers" do
         publish(:ruby, RubyTest, 100..199, :queue_name => 'Default')
-        publish(:ruby, RubyTest, 200..299, :queue_name => 'Dummy_Default')
-        publish(:ruby, RubyTest, 300..499, :queue_name => 'MyQueueName')
-        publish(:ruby, RubyTest, 500..599, :virtual_topic_name => 'MyTopicName')
-
-        # DefaultWorker should have 5 instances running with each worker handling between 10-30 messages in the range 100.199
-        assert_worker(nil, DefaultWorker,         nil, 1, 100..199, 100, 100, 1)
-        assert_worker(nil, Dummy::DefaultWorker,  nil, 1, 200..299, 100, 100, 1)
-        assert_worker(nil, SpecifiedQueueWorker,  nil, 1, 300..499, 200, 200, 1)
-        assert_worker(nil, SpecifiedQueue2Worker, nil, 1, 300..499, 200, 200, 1)
-        assert_worker(nil, SpecifiedTopicWorker,  nil, 1, 500..599, 100, 100, 1)
-        assert_worker(nil, SpecifiedTopic2Worker, nil, 1, 500..599, 100, 100, 1)
+        publish(:ruby, RubyTest, 200..299, :queue_name => 'DefaultClone')
+        publish(:ruby, RubyTest, 300..399, :queue_name => 'Dummy_Default')
+        publish(:ruby, RubyTest, 400..599, :queue_name => 'MyQueueName')
+        publish(:ruby, RubyTest, 600..699, :virtual_topic_name => 'MyTopicName')
+
+        # The single instance of each class will be called so everyone will have all messages.
+        assert_worker(nil, 'Default',             1, 100..199, 100, 100, 1)
+        assert_worker(nil, 'DefaultClone',        1, 200..299, 100, 100, 1)
+        assert_worker(nil, 'Dummy_Default',       1, 300..399, 100, 100, 1)
+        assert_worker(nil, 'SpecifiedQueue',      1, 400..599, 200, 200, 1)
+        assert_worker(nil, 'SpecifiedQueueClone', 1, 400..599, 200, 200, 1)
+        assert_worker(nil, 'SpecifiedQueue2',     1, 400..599, 200, 200, 1)
+        assert_worker(nil, 'SpecifiedTopic',      1, 600..699, 100, 100, 1)
+        assert_worker(nil, 'SpecifiedTopicClone', 1, 600..699, 100, 100, 1)
+        assert_worker(nil, 'SpecifiedTopic2',     1, 600..699, 100, 100, 1)
       end
     end
   end

metadata

@@ -2,7 +2,7 @@
 name: modern_times
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors: 
   - Brad Pardee
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-18 00:00:00 -04:00
+date: 2011-05-31 00:00:00 -04:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -48,9 +48,11 @@ extra_rdoc_files:
   - LICENSE.txt
   - README.rdoc
 files: 
+  - History.md
   - LICENSE.txt
   - README.rdoc
   - Rakefile
+  - TODO.md
   - VERSION
   - examples/README
   - examples/advanced_requestor/README
@@ -105,7 +107,7 @@ files:
   - lib/modern_times/time_track.rb
   - test/base_test.rb
   - test/jms.yml
-  - test/jms_failure_test.rb
+  - test/jms_fail_test.rb
   - test/jms_requestor_block_test.rb
   - test/jms_requestor_test.rb
   - test/jms_test.rb
@@ -157,7 +159,7 @@ test_files:
   - examples/simple/manager.rb
   - examples/simple/publish.rb
   - test/base_test.rb
-  - test/jms_failure_test.rb
+  - test/jms_fail_test.rb
   - test/jms_requestor_block_test.rb
   - test/jms_requestor_test.rb
   - test/jms_test.rb

data/test/jms_failure_test.rb

@@ -1,128 +0,0 @@
-require 'modern_times'
-require 'shoulda'
-require 'test/unit'
-require 'fileutils'
-require 'erb'
-
-# NOTE: This test requires a running ActiveMQ server
-
-class ExceptionWorker
-  include ModernTimes::JMS::Worker
-
-  def perform(obj)
-    puts "ExceptinoWorker received #{obj} but raising exception"
-    raise 'foobar'
-  end
-end
-
-# This will read from the queue that ExceptionWorker fails to
-class ExceptionFailureWorker
-  include ModernTimes::JMS::Worker
-
-  def self.my_obj
-    @@my_obj
-  end
-
-  def perform(obj)
-    puts "ExceptinoFailureWorker received #{obj}"
-    @@my_obj = obj
-  end
-end
-
-class JMSFailureTest < Test::Unit::TestCase
-
-  context 'jms' do
-    setup do
-      config = YAML.load(ERB.new(File.read(File.join(File.dirname(__FILE__), 'jms.yml'))).result(binding))
-      ModernTimes::JMS::Connection.init(config)
-    end
-
-    teardown do
-    end
-
-    context "worker with exception" do
-      setup do
-        @manager = ModernTimes::Manager.new
-
-        @manager.add(ExceptionWorker, 1)
-        @manager.add(ExceptionFailureWorker, 1)
-
-        sleep 1
-      end
-
-      teardown do
-        if @manager
-          @manager.stop
-          @manager.join
-        end
-      end
-
-      should "write failure messages to a queue of <name>Failure" do
-
-        # Publish to Exception that will throw exception which will put on ExceptionFailure queue
-        publisher = ModernTimes::JMS::Publisher.new(:queue_name => 'Exception', :marshal => :string)
-        publisher.publish('zulu')
-        sleep 1
-        assert_equal 'zulu', ExceptionFailureWorker.my_obj
-      end
-    end
-
-#    context "dummy publishing" do
-#      setup do
-#        workers = [
-#            CharCountWorker.new,
-#            CharCountWorker.new(:name => 'CharCount2'),
-#            LengthWorker.new,
-#            LengthWorker.new(:name => 'Length2'),
-#            ReverseWorker.new,
-#            TripleWorker.new,
-#            HolderWorker.new,
-#        ]
-#        ModernTimes::JMS::Publisher.setup_dummy_publishing(workers)
-#      end
-#
-#      teardown do
-#        ModernTimes::JMS::Publisher.clear_dummy_publishing
-#      end
-#
-#      should "handle replies" do
-#
-#        publisher = ModernTimes::JMS::Publisher.new(:virtual_topic_name => 'test_string', :response => true, :marshal => :string)
-#        cc_val = {'f' => 1, 'o' => 4, 'b' => 1}
-#
-#        hash = make_call(publisher, 'fooboo', 2)
-#        assert_response(hash['CharCount'],  :message, cc_val)
-#        assert_response(hash['CharCount2'], :message, cc_val)
-#        assert_response(hash['Length'],     :message, 6)
-#        assert_response(hash['Length2'],    :message,  6)
-#        assert_response(hash['Reverse'],    :message, 'ooboof')
-#        assert_response(hash['Triple'],     :message,  'fooboofooboofooboo')
-#
-#        # Timeouts don't occur when dummy publishing
-#        CharCountWorker.sleep_time = 3
-#        ReverseWorker.sleep_time   = 3
-#        hash = make_call(publisher, 'fooboo', 2)
-#        assert_response(hash['CharCount'],  :message, cc_val)
-#        assert_response(hash['CharCount2'], :message, cc_val)
-#        assert_response(hash['Length'],     :message, 6)
-#        assert_response(hash['Length2'],    :message,  6)
-#        assert_response(hash['Reverse'],    :message, 'ooboof')
-#        assert_response(hash['Triple'],     :message,  'fooboofooboofooboo')
-#        CharCountWorker.sleep_time = nil
-#        ReverseWorker.sleep_time   = nil
-#
-#        CharCountWorker.do_exception = true
-#        TripleWorker.do_exception    = true
-#        hash = make_call(publisher, 'fooboo', 2)
-#        assert_exception(hash['CharCount'],  :explicit_exception)
-#        assert_exception(hash['CharCount2'], :default_exception)
-#        assert_response(hash['Length'],      :message, 6)
-#        assert_response(hash['Length2'],     :message,  6)
-#        assert_response(hash['Reverse'],     :message, 'ooboof')
-#        assert_exception(hash['Triple'],     :default_exception)
-#        CharCountWorker.do_exception = false
-#        TripleWorker.do_exception    = false
-#      end
-#    end
-  end
-end