deep_test 1.1.4 → 1.2.0

data/lib/deep_test/extensions/object_extension.rb

@@ -8,6 +8,14 @@ module DeepTest
     ensure
       $stdout = old_stdout if old_stdout
     end
+
+    def capture_stderr
+      old_stderr, $stderr = $stderr, StringIO.new
+      yield
+      $stderr.string
+    ensure
+      $stderr = old_stderr if old_stderr
+    end
     
     def retrying(description = nil, times = 5)
       i = 0

data/lib/deep_test/listener_list.rb

@@ -0,0 +1,17 @@
+module DeepTest
+  class ListenerList
+    attr_reader :listeners
+
+    def initialize(listeners)
+      @listeners = listeners
+    end
+
+    NullWorkerListener.instance_methods(false).each do |event|
+      eval <<-end_src
+        def #{event}(*args)
+          @listeners.each {|l| l.#{event}(*args)}
+        end
+      end_src
+    end
+  end
+end

data/lib/deep_test/local_workers.rb

@@ -0,0 +1,55 @@
+module DeepTest
+  class LocalWorkers
+    def initialize(options)
+      @options = options
+      @warlock = Warlock.new
+    end
+
+    def load_files(files)
+      files.each {|f| load f}
+    end
+
+    def server
+      @options.server
+    end
+
+    def start_all
+      each_worker do |worker_num|
+        start_worker(worker_num) do
+          reseed_random_numbers
+          reconnect_to_database
+          worker = DeepTest::Worker.new(worker_num,
+                                        server, 
+                                        @options.new_listener_list)
+          worker.run
+        end
+      end        
+    end
+
+    def stop_all
+      @warlock.stop_all
+    end
+
+    def number_of_workers
+      @options.number_of_workers
+    end
+
+    private
+
+    def reconnect_to_database
+      ActiveRecord::Base.connection.reconnect! if defined?(ActiveRecord::Base)
+    end
+
+    def start_worker(worker_num, &blk)
+      @warlock.start("worker #{worker_num}", &blk)
+    end
+
+    def reseed_random_numbers
+      srand
+    end
+
+    def each_worker
+      number_of_workers.to_i.times { |worker_num| yield worker_num }
+    end
+  end
+end

data/lib/deep_test/logger.rb

@@ -2,8 +2,16 @@ module DeepTest
   class Logger < ::Logger
     def initialize(*args)
       super
-      self.formatter = proc { |severity, time, progname, msg| "#{msg}\n" }
-      self.level = Logger::INFO
+      self.formatter = proc { |severity, time, progname, msg| "[DeepTest] #{msg}\n" }
+      self.level = configured_log_level
+    end
+
+    def configured_log_level
+      if ENV['DEEP_TEST_LOG_LEVEL']
+        Logger.const_get(ENV['DEEP_TEST_LOG_LEVEL'])
+      else
+        Logger::INFO
+      end
     end
   end
 end

data/lib/deep_test/marshallable_exception_wrapper.rb

@@ -0,0 +1,44 @@
+module DeepTest
+  class MarshallableExceptionWrapper
+    attr_reader :classname, :message, :backtrace
+
+    def initialize(exception)
+      @classname = exception.class.name
+      @message = exception.message
+      @backtrace = exception.backtrace
+    end
+
+    def ==(other)
+      classname == other.classname &&
+        message == other.message &&
+      backtrace == other.backtrace
+    end
+
+    def resolve
+      begin
+        klass = eval("::" + classname) 
+        resolved_message = message
+      rescue => e
+        DeepTest.logger.debug("Unable to load exception class: #{classname}: #{e.message}")
+        DeepTest.logger.debug(e.backtrace.join("\n"))
+
+        klass = UnloadableException
+        resolved_message = "#{classname}: #{message}"
+      end
+
+      begin
+        resolved_exception = klass.new resolved_message
+      rescue => e
+        DeepTest.logger.debug("Unable to instantiation exception class: #{classname}: #{e.message}")
+        DeepTest.logger.debug(e.backtrace.join("\n"))
+
+        resolved_exception = UnloadableException.new resolved_message
+      end
+
+      resolved_exception.set_backtrace backtrace
+      resolved_exception
+    end
+  end
+
+  class UnloadableException < StandardError; end
+end

data/lib/deep_test/metrics/gatherer.rb

@@ -0,0 +1,67 @@
+module DeepTest
+  module Metrics
+    class Gatherer
+      def self.setup(options)
+        $metrics_gatherer = new(options)
+
+        at_exit do
+          $metrics_gatherer.write_file
+        end
+      end
+
+      def self.enabled?
+        return false unless $metrics_gatherer
+        $metrics_gatherer.enabled?
+      end
+
+      def self.section(title, &block)
+        $metrics_gatherer.section(title, &block)
+      end
+
+      def initialize(options)
+        @options = options
+        @sections = []
+      end
+
+      def enabled?
+        !@options.metrics_file.nil?
+      end
+
+      def section(title, &block)
+        @sections << Section.new(title, &block) if enabled?
+      end
+
+      def render
+        @sections.map {|s| s.render}.join("\n")
+      end
+      
+      def write_file
+        return unless enabled?
+        File.open(@options.metrics_file, "w") do |io|
+          io << render
+        end
+      end
+
+      class Section
+        def initialize(title, &generate_measurements_block)
+          @title = title
+          @generate_measurements_block = generate_measurements_block
+        end
+
+        def measurement(name, value)
+          @measurements << [name, value]
+        end
+
+        def gather_measurements
+          @measurements = []
+          @generate_measurements_block.call(self)
+        end
+
+        def render
+          gather_measurements
+          "[#{@title}]\n" + @measurements.map {|name, value| "#{name}: #{value}"}.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/deep_test/metrics/queue_lock_wait_time_measurement.rb

@@ -0,0 +1,133 @@
+module DeepTest
+  module Metrics
+    module QueueLockWaitTimeMeasurement
+      attr_reader :total_pop_time, :total_push_time
+
+      def self.extended(o)
+        o.instance_eval do
+          alias pop_without_lock_wait_measurement pop
+          alias pop pop_with_lock_wait_measurement
+
+          alias push_without_lock_wait_measurement push
+          alias push push_with_lock_wait_measurement
+        end
+      end
+
+      def pop_with_lock_wait_measurement(no_wait = false)
+        if no_wait
+          return measure(:add_pop_time) do
+            pop_without_lock_wait_measurement(no_wait)
+          end
+        else
+          begin
+            # Measure without waiting to minimize extra time added
+            # above locking time
+            #
+            return measure(:add_pop_time) do
+              pop_without_lock_wait_measurement(true)
+            end
+          rescue ThreadError => e
+            if e.message == "queue empty"
+              # Normally we would have waiting for a condvar signal,
+              # so don't penalize time for locking here again - hence
+              # no measure
+              return pop_without_lock_wait_measurement(false)
+            else
+              raise
+            end
+          end
+        end
+      end
+
+      def push_with_lock_wait_measurement(value)
+        measure(:add_push_time) do
+          push_without_lock_wait_measurement(value)
+        end
+      end
+
+      def measure(accumulator)
+        start_time = Time.now
+        result = yield
+        send(accumulator, Time.now - start_time)
+        result
+      end
+
+      def add_push_time(time)
+        Thread.exclusive do
+          @total_push_time ||= 0
+          @total_push_time += time
+        end
+      end
+
+      def add_pop_time(time)
+        Thread.exclusive do
+          @total_pop_time ||= 0
+          @total_pop_time += time
+        end
+      end
+    end
+  end
+end
+
+
+if $0 == __FILE__
+  require 'thread'
+  require 'timeout'
+
+  thread_count = (ARGV[0] || 10).to_i
+  action_count = (ARGV[1] || 100).to_i
+
+  def test_measurement(thread_count, action_count)
+    q = Queue.new
+    q.extend DeepTest::Metrics::QueueLockWaitTimeMeasurement
+
+    threads = []
+    thread_count.times do
+      threads << Thread.new do
+        action_count.times do |i|
+          show_progress ".", action_count, i
+          q.push 1
+        end
+      end
+    end
+
+    thread_count.times do
+      threads << Thread.new do
+        action_count.times do |i|
+          show_progress "-", action_count, i
+          if rand(2) == 0
+            begin
+              q.pop(true)
+            rescue ThreadError
+            end
+          else
+            begin
+              Timeout.timeout(0.01) do
+                q.pop
+              end
+            rescue Timeout::Error
+              break
+            end
+          end
+        end
+      end
+    end
+
+    threads.each {|t| t.join}
+
+    puts
+    puts "Push Time: #{q.total_push_time}"
+    puts "Pop Time:  #{q.total_pop_time}"
+  end
+
+  def show_progress(s, total, current)
+    if (current % (total / 5)) == 0
+      $stdout.print s
+      $stdout.flush
+    end
+  end
+
+  start_time = Time.now
+  test_measurement(thread_count, action_count)
+  puts "Total Run Time:  #{Time.now - start_time}"
+end

data/lib/deep_test/null_worker_listener.rb

@@ -1,11 +1,61 @@
 module DeepTest
+  #
+  # Listener that implements no-ops for all callbacks that DeepTest supports.
+  #
   class NullWorkerListener
+    #
+    # Before DeepTest synchronizes any code during a distributed run,
+    # before_sync is called.  If DeepTest is not running distributed,
+    # before_sync is never called.
+    # 
+    def before_sync
+    end
+
+    #
+    # Before DeepTest starts any workers, it instantiates a listener and
+    # invokes this method.  No other callbacks are made to the listener
+    # instance receiving this message. 
+    #
+    def before_starting_workers
+    end
+
+    #
+    # A separate listener instance is created in each worker process and
+    # notified that the worker is starting.  The worker for the process is
+    # provided for the listener to use.  If you are using 3 workers, this
+    # method is invoked 3 times on 3 distinct instances.  These instances
+    # will also receive the starting_work and finished_work callbacks for
+    # the worker provided.
+    #
     def starting(worker)
     end
 
+    #
+    # Each time a worker takes a work unit, it calls this method before
+    # doing the work.  In total, this method will be called as many times
+    # as there are work units.  The listener instance that received the
+    # starting callback with the worker provided here is the same instance
+    # that receives this message.
+    #
+    # Because each work processes work units in a serial fashion, the
+    # listener will receive a finished_work message before another
+    # starting_work message.
+    #
     def starting_work(worker, work_unit)
     end
 
+    #
+    # Each time a worker finishes computing a result for a work unit, 
+    # it calls this method before sending that result back to the server.
+    # In total, this method will be called as many times
+    # as there are work units.  The listener instance that received the
+    # starting callback with the worker provided here is the same instance
+    # that receives this message.
+    #
+    # Because each work processes work units in a serial fashion, the
+    # listener will receive a starting_work message before another
+    # finished_work message.
+    #
     def finished_work(worker, work_unit, result)
     end
   end

data/lib/deep_test/option.rb

@@ -0,0 +1,60 @@
+module DeepTest
+  class Option
+    attr_reader :name, :default
+
+    def initialize(name, type, default)
+      @name, @type, @default = name, type, default
+    end
+
+    def from_command_line(command_line)
+      command_line =~ /--#{name} (\S+)(\s|$)/
+      @type.from_string($1) if $1
+    end
+
+    def to_command_line(value)
+      "--#{name} #{@type.to_string(value)}" if value && value != default
+    end
+
+    module Hash
+      def self.to_string(hash)
+        pairs = []
+        hash.each do |key, value|
+          value = value.gsub(/ /,'%20') if (::String === value)
+          pairs << "#{key}:#{value.inspect}"
+        end
+        pairs.join(",")
+      end
+
+      def self.from_string(string)
+        hash = {}
+        string.split(/,/).each do |pair|
+          key, unevaled_value = pair.split(/:/)
+          value = eval(unevaled_value)
+          value = value.gsub(/%20/, " ") if ::String === value
+          hash[key.to_sym] = value
+        end
+        hash
+      end
+    end
+
+    module Integer
+      def self.to_string(i)
+        i.to_s
+      end
+
+      def self.from_string(s)
+        s.to_i
+      end
+    end
+
+    module String
+      def self.to_string(s)
+        s
+      end
+
+      def self.from_string(s)
+        s
+      end
+    end
+  end
+end