modern_times 0.2.11 → 0.3.0

data/lib/modern_times/marshal_strategy/json.rb

@@ -16,6 +16,9 @@ module ModernTimes
         def unmarshal(msg)
           ::JSON::Parser.new(msg).parse
         end
+
+        MarshalStrategy.register(:json => self)
+
       rescue LoadError => e
         def marshal(object)
           raise 'Error: JSON marshaling specified but json gem has not been installed'

data/lib/modern_times/marshal_strategy/ruby.rb

@@ -15,6 +15,9 @@ module ModernTimes
         msg = ::String.from_java_bytes(msg) unless msg.kind_of?(::String)
         ::Marshal.load(msg)
       end
+
+      MarshalStrategy.register(:ruby => self)
+      
     end
   end
 end

data/lib/modern_times/marshal_strategy/string.rb

@@ -14,6 +14,9 @@ module ModernTimes
       def unmarshal(msg)
         msg
       end
+
+      MarshalStrategy.register(:string => self)
+
     end
   end
 end

data/lib/modern_times/marshal_strategy/yaml.rb

@@ -14,6 +14,9 @@ module ModernTimes
       def unmarshal(msg)
         ::YAML.load(msg)
       end
+
+      MarshalStrategy.register(:yaml => self)
+
     end
   end
 end

data/lib/modern_times/railsable.rb

@@ -5,8 +5,8 @@ module ModernTimes
   module Railsable
     def init_rails
       # Allow user to use JMS w/o modifying jms.yml which could be checked in and hose other users
-      env = ENV['MODERN_TIMES_ENV'] || Rails.env
-      if @config = YAML.load(ERB.new(File.read(File.join(Rails.root, "config", "jms.yml"))).result(binding))[env]
+      @env = ENV['MODERN_TIMES_ENV'] || Rails.env
+      if @config = YAML.load(ERB.new(File.read(File.join(Rails.root, "config", "jms.yml"))).result(binding))[@env]
         ModernTimes.logger.info "Messaging Enabled"
         ModernTimes::JMS::Connection.init(@config)
         @is_jms_enabled = true
@@ -46,9 +46,8 @@ module ModernTimes
       else
         Rails.logger.info "Messaging disabled"
         @is_jms_enabled = false
-        ModernTimes::JMS::Publisher.setup_dummy_publishing(rails_workers)
+        ModernTimes::JMS::Publisher.setup_dummy_publishing(rails_workers.map {|klass| klass.new})
         ModernTimes::JMS::Consumer.setup_dummy_receiving
-        ModernTimes::JMSRequestor::Requestor.setup_dummy_requesting(rails_workers)
       end
     end
 
@@ -57,21 +56,15 @@ module ModernTimes
       raise 'init_rails has not been called, modify your config/environment.rb to include this call' if @is_jms_enabled.nil?
       raise 'Messaging is not enabled, modify your config/jms.yml file' unless @is_jms_enabled
       default_config = {
-          :persist_file    => File.join(Rails.root, "log", "modern_times.persist"),
+          :persist_file    => File.join(Rails.root, "log", "modern_times.yml"),
           :worker_file     => File.join(Rails.root, "config", "workers.yml"),
-          :jmx             => Rails.env != 'test',
+          :jmx             => @env != 'test',
           :stop_on_signal  => true,
-          :dummy_host      => Rails.env,
+          :dummy_host      => @env,
           :allowed_workers => rails_workers,
       }
 
-      manager = ModernTimes::Manager.new(default_config.merge(manager_config))
-      manager.stop_on_signal
-      manager.allowed_workers = rails_workers
-      manager.persist_file = manager_config[:persist_file] || File.join(Rails.root, "log", "modern_times.persist")
-      manager.dummy_host = Rails.env
-      manager.worker_file = manager_config[:worker_file] || File.join(Rails.root, "config", "workers.yml")
-      return manager
+      return ModernTimes::Manager.new(default_config.merge(manager_config))
     end
 
     def rails_workers

data/lib/modern_times/time_track.rb

@@ -0,0 +1,84 @@
+require 'benchmark'
+
+module ModernTimes
+  class TimeTrack
+    attr_reader :total_count, :time_count, :max_time, :last_time
+
+    def initialize
+      @mutex = Mutex.new
+      @total_count = 0
+      @last_time   = 0.0
+      reset
+    end
+
+    def reset
+      @mutex.synchronize do
+        @time_count  = 0
+        @min_time    = nil
+        @max_time    = 0.0
+        @total_time  = 0.0
+      end
+    end
+
+    def perform
+      answer = nil
+      @last_time = Benchmark.realtime { answer = yield }
+      @mutex.synchronize do
+        @total_count += 1
+        @time_count  += 1
+        @total_time  += @last_time
+        @min_time = @last_time if !@min_time || @last_time < @min_time
+        @max_time = @last_time if @last_time > @max_time
+      end
+      answer
+    end
+
+    def total_time
+      @mutex.synchronize do
+        [@time_count, @total_time]
+      end
+    end
+
+    def min_time
+      @min_time || 0.0
+    end
+
+    def avg_time
+      @mutex.synchronize do
+        return 0.0 if @time_count == 0
+        @total_time / @time_count
+      end
+    end
+
+    # Return the total time and reset it.  Kind of hackish but allows for tools like
+    # Hyperic to poll these values in an xml attribute setup.
+    def total_time_reset
+      @mutex.synchronize do
+        retval = [@time_count, @total_time]
+        @time_count = 0
+        @total_time = 0.0
+        return retval
+      end
+    end
+
+    def min_time_reset
+      @mutex.synchronize do
+        val = @min_time || 0.0
+        @min_time = nil
+        return val
+      end
+    end
+
+    def max_time_reset
+      @mutex.synchronize do
+        val = @max_time
+        @max_time = 0.0
+        return val
+      end
+    end
+
+    def to_s
+      "sample=#{@time_count} min=#{('%.1f' % (1000*min_time))}ms max=#{('%.1f' % (1000*max_time))}ms avg=#{('%.1f' % (1000*avg_time))}ms"
+    end
+  end
+end

data/test/jms.yml

@@ -1,5 +1,6 @@
 :factory: org.apache.activemq.ActiveMQConnectionFactory
 :broker_url: tcp://localhost:61616
+: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] %>

data/test/jms_failure_test.rb

@@ -0,0 +1,128 @@
+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

data/test/jms_requestor_block_test.rb

@@ -0,0 +1,275 @@
+require 'modern_times'
+require 'shoulda'
+require 'test/unit'
+require 'fileutils'
+require 'erb'
+
+# NOTE: This test requires a running ActiveMQ server
+
+class BaseRequestWorker
+  include ModernTimes::JMS::RequestWorker
+
+  def self.sleep_time=(val)
+    @sleep_time = val
+  end
+
+  def self.sleep_time
+    @sleep_time
+  end
+
+  def self.do_exception=(val)
+    @create_exception = val
+  end
+
+  def self.do_exception
+    @create_exception
+  end
+
+  def request(obj)
+    raise Exception,'my exception' if self.class.do_exception
+    sleep self.class.sleep_time if self.class.sleep_time
+  end
+end
+
+class CharCountWorker < BaseRequestWorker
+  virtual_topic 'test_string'
+  response :marshal => :bson, :time_to_live => 10000
+
+  def request(obj)
+    super
+    hash = Hash.new(0)
+    obj.each_char {|c| hash[c] += 1}
+    hash
+  end
+end
+
+class LengthWorker < BaseRequestWorker
+  virtual_topic 'test_string'
+  response :marshal => :ruby, :time_to_live => 10000
+
+  def request(obj)
+    super
+    obj.length
+  end
+end
+
+class ReverseWorker < BaseRequestWorker
+  virtual_topic 'test_string'
+  response :marshal => :string, :time_to_live => 10000
+
+  def request(obj)
+    super
+    obj.reverse
+  end
+end
+
+class TripleWorker < BaseRequestWorker
+  virtual_topic 'test_string'
+  response :marshal => :string, :time_to_live => 10000
+
+  def request(obj)
+    super
+    obj*3
+  end
+end
+
+class HolderWorker
+  include ModernTimes::JMS::Worker
+  virtual_topic 'test_string'
+
+  def self.my_obj
+    @@my_obj
+  end
+
+  def perform(obj)
+    @@my_obj = obj
+  end
+end
+
+class JMSRequestorBlockTest < Test::Unit::TestCase
+
+  def assert_response(hash, expected_key, expected_val)
+    assert_equal 1, hash.keys.size
+    actual_val = hash[expected_key]
+    assert_equal expected_val, actual_val
+  end
+
+  def assert_exception(hash, expected_key)
+    assert_equal 1, hash.keys.size
+    e = hash[expected_key]
+
+    assert e.kind_of?(ModernTimes::RemoteException)
+  end
+
+  def make_call(publisher, string, timeout)
+    handle = publisher.publish(string)
+    hash_results = {}
+
+    handle.read_response(timeout) do |response|
+      response.on_message 'CharCount' do |val|
+        hash = hash_results[response.name] ||= {}
+        hash[:message] = val
+      end
+      response.on_message 'CharCount2' do |val|
+        hash = hash_results[response.name] ||= {}
+        hash[:message] = val
+      end
+      response.on_message 'Length', 'Length2', 'Reverse', 'Triple' do |val|
+        hash = hash_results[response.name] ||= {}
+        hash[:message] = val
+      end
+      response.on_timeout 'Reverse' do
+        hash = hash_results[response.name] ||= {}
+        hash[:explicit_timeout] = true
+      end
+      response.on_timeout do
+        hash = hash_results[response.name] ||= {}
+        hash[:default_timeout] = true
+      end
+      response.on_remote_exception 'CharCount' do |e|
+        hash = hash_results[response.name] ||= {}
+        hash[:explicit_exception] = e
+      end
+      response.on_remote_exception do |e|
+        hash = hash_results[response.name] ||= {}
+        hash[:default_exception] = e
+      end
+    end
+    puts "results=#{hash_results.inspect}"
+    # 6 request workers
+    assert_equal 6, hash_results.keys.size
+    assert_equal string, HolderWorker.my_obj
+    return hash_results
+  end
+
+  context 'jms request with block' 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 "real publishing" do
+      setup do
+        @manager = ModernTimes::Manager.new
+
+        @manager.add(CharCountWorker, 1)
+        @manager.add(CharCountWorker, 1, :name => 'CharCount2')
+        @manager.add(LengthWorker,    1)
+        @manager.add(LengthWorker,    1, :name => 'Length2')
+        @manager.add(ReverseWorker,   1)
+        @manager.add(TripleWorker,    1)
+        @manager.add(HolderWorker,    1)
+
+        sleep 1
+      end
+
+      teardown do
+        if @manager
+          @manager.stop
+          @manager.join
+        end
+      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')
+
+        CharCountWorker.sleep_time = 3
+        ReverseWorker.sleep_time   = 3
+        hash = make_call(publisher, 'fooboo', 2)
+        assert_response(hash['CharCount'],  :default_timeout,  true)
+        assert_response(hash['CharCount2'], :default_timeout,  true)
+        assert_response(hash['Length'],     :message, 6)
+        assert_response(hash['Length2'],    :message,  6)
+        assert_response(hash['Reverse'],    :explicit_timeout, true)
+        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
+
+        sleep 2
+      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