modern_times 0.2.11 → 0.3.0

data/examples/requestor/request.rb

@@ -19,15 +19,15 @@ $sim_count   = (ARGV[3] || 1).to_i
 
 config = YAML.load(ERB.new(File.read(File.join(File.dirname(__FILE__), '..', 'jms.yml'))).result(binding))
 ModernTimes::JMS::Connection.init(config)
-$requestor = ModernTimes::JMSRequestor::Requestor.new(:queue_name => ReverseEchoWorker.default_name, :marshal => :string)
+$publisher = ModernTimes::JMS::Publisher.new(:queue_name => ReverseEchoWorker.default_name, :response =>true, :marshal => :string)
 
 def make_request(ident='')
   puts "#{ident}Making request at #{Time.now.to_f}"
-  handle = $requestor.request("#{ident}#{$echo_string}", $timeout)
+  handle = $publisher.publish("#{ident}#{$echo_string}")
   # Here's where we'd go off and do other work
   sleep $sleep_time
   puts "#{ident}Finished sleeping at #{Time.now.to_f}"
-  response = handle.read_response
+  response = handle.read_response($timeout)
   puts "#{ident}Received at #{Time.now.to_f}: #{response}"
 rescue Exception => e
   puts "#{ident}Exception: #{e.message}\n\t#{e.backtrace.join("\n\t")}"

data/examples/requestor/reverse_echo_worker.rb

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

data/lib/modern_times.rb

@@ -3,11 +3,11 @@ require 'modern_times/remote_exception'
 require 'modern_times/marshal_strategy'
 require 'modern_times/base'
 require 'modern_times/jms'
-require 'modern_times/jms_requestor'
 require 'modern_times/manager_mbean'
 require 'modern_times/manager'
 require 'modern_times/loggable'
 require 'modern_times/railsable'
+require 'modern_times/time_track'
 
 module ModernTimes
   extend ModernTimes::Loggable

data/lib/modern_times/base/supervisor.rb

@@ -47,6 +47,8 @@ module ModernTimes
             (count...curr_count).each { |index| @workers[index].stop }
             (count...curr_count).each { |index| @workers[index].thread.join }
             @workers = @workers[0, count]
+          else
+            return
           end
           manager.save_persist_state
         end

data/lib/modern_times/base/worker.rb

@@ -1,7 +1,8 @@
 module ModernTimes
   module Base
     module Worker
-      attr_accessor :name, :index, :thread
+      attr_reader :name, :options
+      attr_accessor :index, :thread
 
       module ClassMethods
         def default_name
@@ -18,8 +19,9 @@ module ModernTimes
         base.extend(ClassMethods)
       end
 
-      def initialize(opts={})
-        @name = opts[:name] || self.class.default_name
+      def initialize(options={})
+        @name = options[:name] || self.class.default_name
+        @options = options
       end
 
       # One time initialization prior to first thread

data/lib/modern_times/jms.rb

@@ -1,9 +1,11 @@
 require 'modern_times/jms/connection'
 require 'modern_times/jms/consumer'
 require 'modern_times/jms/publisher'
+require 'modern_times/jms/publish_handle'
 require 'modern_times/jms/supervisor_mbean'
 require 'modern_times/jms/supervisor'
 require 'modern_times/jms/worker'
+require 'modern_times/jms/request_worker'
 
 module ModernTimes
   module JMS

data/lib/modern_times/jms/connection.rb

@@ -11,6 +11,9 @@ module ModernTimes
       def init(config)
         @config = config
         @inited = true
+        @log_times = config.delete(:log_times)
+        # Default to true
+        @log_times = true if @log_times.nil?
 
         # Let's not create a session_pool unless we're going to use it
         @session_pool_mutex = Mutex.new
@@ -27,6 +30,10 @@ module ModernTimes
         @inited
       end
 
+      def log_times?
+        @log_times
+      end
+
       # Create a session targeted for a consumer (producers should use the session_pool)
       def create_consumer_session
         connection.create_session(@config || {})

data/lib/modern_times/jms/publish_handle.rb

@@ -0,0 +1,219 @@
+require 'timeout'
+require 'yaml'
+
+module ModernTimes
+  module JMS
+    class PublishHandle
+      def initialize(publisher, jms_message_id, start)
+        @publisher         = publisher
+        @jms_message_id    = jms_message_id
+        @start             = start
+        # Dummy hash will store all the responses from the RequestWorker's matching our publishing destination.
+        @dummy_hash        = {}
+      end
+
+      # Waits the given timeout for a response message on the queue.
+      #
+      # If called w/o a block:
+      #   Returns the message
+      #   Returns nil on timeout
+      #   Raises RemoteException on a remote exception
+      #
+      # If called with a block, for instance:
+      #   handle.read_response(timeout) do |response|
+      #     response.on_message 'CharCount' do |hash|
+      #       puts "CharCount returned #{hash.inspect}"
+      #     end
+      #     response.on_message 'Length', 'Reverse' do |val|
+      #       puts "#{response.name} returned #{val}"
+      #     end
+      #     response.on_message 'ExceptionRaiser' do |val|
+      #       puts "#{response.name} didn't raise an exception but returned #{val}"
+      #     end
+      #     response.on_timeout 'Reverse' do
+      #       puts "Reverse has it's own timeout handler"
+      #     end
+      #     response.on_timeout do
+      #       puts "#{response.name} did not respond in time"
+      #     end
+      #     response.on_remote_exception 'ExceptionRaiser' do
+      #       puts "It figures that ExceptionRaiser would raise an exception"
+      #     end
+      #     response.on_remote_exception do |e|
+      #       puts "#{response.name} raised an exception #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+      #     end
+      #   end
+      #
+      # The specified blocks will be called for each response.  For instance, LengthWorker#request
+      # might return 4 and "Length returned 4" would be displayed.  If it failed to respond within the
+      # timeout, then "Length did no respond in time" would be displayed.
+      # For Workers that raise an exception, they will either be handled by their specific handler if it exists or
+      # the default exception handler.  If that doesn't exist either, then the RemoteException will be raised for the
+      # whole read_response call.  Timeouts will also be handled by the default timeout handler unless a specific one
+      # is specified.  All messages must have a specific handler specified because the call won't return until all
+      # specified handlers either return, timeout, or return an exception.
+      #
+      def read_response(timeout, &block)
+        reply_queue = @publisher.reply_queue
+        raise "Invalid call to read_response for #{@publisher}, not setup for responding" unless reply_queue
+        options = { :destination => reply_queue, :selector => "JMSCorrelationID = '#{@jms_message_id}'" }
+        ModernTimes::JMS::Connection.session_pool.consumer(options) do |session, consumer|
+          do_read_response(consumer, timeout, &block)
+        end
+      end
+
+      def dummy_read_response(timeout, &block)
+        raise "Invalid call to read_response for #{@publisher}, not setup for responding" unless @publisher.response
+        do_read_response(nil, timeout, &block)
+      end
+
+      def add_dummy_response(name, object)
+        @dummy_hash[name] = object
+      end
+
+      def self.setup_dummy_handling
+        alias_method :real_read_response, :read_response
+        alias_method :read_response, :dummy_read_response
+        alias_method :real_read_single_response, :read_single_response
+        alias_method :read_single_response, :dummy_read_single_response
+      end
+
+      # For testing
+      def self.clear_dummy_handling
+        alias_method :dummy_read_response, :read_response
+        alias_method :read_response, :real_read_response
+        alias_method :dummy_read_single_response, :read_single_response
+        alias_method :read_single_response, :real_read_single_response
+      end
+      #######
+      private
+      #######
+
+      class WorkerResponse
+        attr_reader :name, :start
+
+        def initialize(start)
+          @start                   = start
+          @message_hash            = {}
+          @timeout_hash            = {}
+          @exception_hash          = {}
+          @default_timeout_block   = nil
+          @default_exception_block = nil
+          @done_array              = []
+        end
+
+        # Msecs since publish
+        def msec_delta
+          (Time.now - @start) * 1000
+        end
+
+        def on_message(*names, &block)
+          raise 'Must explicitly define all message handlers so we know that we\'re done' if names.empty?
+          names.each {|name| @message_hash[name] = block}
+        end
+
+        def on_timeout(*names, &block)
+          if names.empty?
+            @default_timeout_block = block
+          else
+            names.each {|name| @timeout_hash[name] = block}
+          end
+        end
+
+        def on_remote_exception(*names, &block)
+          if names.empty?
+            @default_exception_block = block
+          else
+            names.each {|name| @exception_hash[name] = block}
+          end
+          @remote_exception_block = block
+        end
+
+        def make_message_call(name, obj)
+          # Give the client access to the name
+          @name = name
+          block = @message_hash[name]
+          block.call(obj) if block
+          @done_array << name
+        end
+
+        def done?
+          (@message_hash.keys - @done_array).empty?
+        end
+
+        def make_timeout_calls
+          @timeouts = @message_hash.keys - @done_array
+          @timeouts.each do |name|
+            # Give the client access to the name
+            @name = name
+            block = @timeout_hash[name] || @default_timeout_block
+            block.call if block
+          end
+        end
+
+        def make_exception_call(name, e)
+          @name = name
+          block = @exception_hash[name] || @default_exception_block
+          if block
+            block.call(e)
+            @done_array << name
+          else
+            raise e
+          end
+        end
+      end
+
+      def do_read_response(consumer, timeout, &block)
+        if block_given?
+          return read_multiple_response(consumer, timeout, &block)
+        else
+          response = read_single_response(consumer, timeout)
+          raise response if response.kind_of?(ModernTimes::RemoteException)
+          return response
+        end
+      end
+
+      def read_single_response(consumer, timeout)
+        message = nil
+        leftover_timeout = ((@start + timeout - Time.now) * 1000).to_i
+        if leftover_timeout > 100
+          message = consumer.receive(leftover_timeout)
+        else
+          #message = consumer.receive_no_wait
+          message = consumer.receive(100)
+        end
+        return nil unless message
+        @name = message['worker']
+        if error_yaml = message['exception']
+          return ModernTimes::RemoteException.from_hash(YAML.load(error_yaml))
+        end
+        marshaler = ModernTimes::MarshalStrategy.find(message['marshal'] || :ruby)
+        return marshaler.unmarshal(message.data)
+      end
+
+      def dummy_read_single_response(consumer, timeout)
+        @name = @dummy_hash.keys.first
+        return nil unless @name
+        return @dummy_hash.delete(@name)
+      end
+
+      def read_multiple_response(consumer, timeout, &block)
+        worker_response = WorkerResponse.new(@start)
+        yield worker_response
+
+        until worker_response.done? do
+          response = read_single_response(consumer, timeout)
+          if !response
+            worker_response.make_timeout_calls
+            return
+          end
+          if response.kind_of?(ModernTimes::RemoteException)
+            worker_response.make_exception_call(@name, response)
+          else
+            worker_response.make_message_call(@name, response)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/modern_times/jms/publisher.rb

@@ -4,20 +4,25 @@ require 'jms'
 module ModernTimes
   module JMS
     class Publisher
-      attr_reader :producer_options, :persistent, :marshaler
+      attr_reader :producer_options, :persistent, :marshaler, :reply_queue, :response
+
+      @@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
+      #     :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
       #        (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, or :json
-      #                 => Module: Module that defines marshal and unmarshal method
+      #     :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)
       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]
         @producer_options = options.reject {|k,v| !producer_keys.include?(k)}
         raise "One of #{producer_keys.join(',')} must be given in #{self.class.name}" if @producer_options.empty?
@@ -31,43 +36,67 @@ module ModernTimes
         # 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
-        @marshaler = ModernTimes::MarshalStrategy.find(options[:marshal])
+        @marshal = options[:marshal] || :ruby
+        @marshaler = ModernTimes::MarshalStrategy.find(@marshal)
         @time_to_live = options[:time_to_live]
+
+        @reply_queue = nil
+        @response = options[:response]
+        if !@@dummy_publishing  && @response
+          ModernTimes::JMS::Connection.session_pool.session do |session|
+            @reply_queue = session.create_destination(:queue_name => :temporary)
+          end
+        end
       end
 
       # Publish the given object to the address.
       def publish(object, props={})
+        start = Time.now
         message = nil
         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
           props.each do |key, value|
             message.send("#{key}=", value)
           end
-          # TODO: Is send_with_retry possible?
-          #producer.send_with_retry(message)
           producer.send(message)
         end
-        return message.jms_message_id
+        return PublishHandle.new(self, message.jms_message_id, start)
       end
 
       # For non-configured Rails projects, The above publish method will be overridden to
       # call this publish method instead which calls all the JMS workers that
       # operate on the given address.
       def dummy_publish(object, props={})
-        @@message_id += 1
-        @@worker_instances.each do |worker|
-          if worker.kind_of?(Worker) && ModernTimes::JMS.same_destination?(@producer_options, worker.class.destination_options)
-            ModernTimes.logger.debug "Dummy publishing #{object} to #{worker}"
-            worker.message = OpenStruct.new(:jms_message_id => @@message_id.to_s)
-            worker.perform(object)
+        dummy_handle = PublishHandle.new(self, nil, Time.now)
+        # 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 worker.kind_of?(RequestWorker)
+              ModernTimes.logger.debug "Dummy request publishing #{trans_object} to #{worker}"
+              m = worker.marshaler
+              # Model real queue marshaling/unmarshaling
+              begin
+                response_object = m.unmarshal(m.marshal(worker.request(trans_object)))
+                dummy_handle.add_dummy_response(worker.name, response_object)
+              rescue Exception => e
+                dummy_handle.add_dummy_response(worker.name, ModernTimes::RemoteException.new(e))
+              end
+            elsif worker.kind_of?(Worker)
+              ModernTimes.logger.debug "Dummy publishing #{trans_object} to #{worker}"
+              begin
+                worker.perform(trans_object)
+              rescue Exception => e
+                ModernTimes.logger.error("#{worker} Exception: #{e.message}\n\t#{e.backtrace.join("\n\t")}")
+              end
+            end
           end
         end
-        if correlation_id = props[:jms_correlation_id]
-          @@dummy_cache[correlation_id] = object
-        end
-        return @@message_id.to_s
+        return dummy_handle
       end
 
       def to_s
@@ -75,23 +104,20 @@ module ModernTimes
       end
 
       def self.setup_dummy_publishing(workers)
-        require 'ostruct'
-        @@message_id = 0
-        @@dummy_cache = {}
-        @@worker_instances = workers.map {|worker| worker.new}
+        @@dummy_publishing = true
+        @@workers = workers
         alias_method :real_publish, :publish
         alias_method :publish, :dummy_publish
+        PublishHandle.setup_dummy_handling
       end
 
       # For testing
       def self.clear_dummy_publishing
+        @@dummy_publishing = false
         alias_method :dummy_publish, :publish
         alias_method :publish, :real_publish
         #remove_method :real_publish
-      end
-
-      def self.dummy_cache(correlation_id)
-        @@dummy_cache.delete(correlation_id)
+        PublishHandle.clear_dummy_handling
       end
     end
   end