jperkins-deep_test 1.2.2

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

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

data/lib/deep_test/options.rb

@@ -0,0 +1,110 @@
+module DeepTest
+  class Options
+    unless defined?(VALID_OPTIONS)
+      VALID_OPTIONS = [
+        Option.new(:distributed_server, Option::String, nil),
+        Option.new(:number_of_workers,  Option::Integer, 2),
+        Option.new(:metrics_file,       Option::String, nil),
+        Option.new(:pattern,            Option::String, nil),
+        Option.new(:server_port,        Option::Integer, 6969),
+        Option.new(:sync_options,       Option::Hash, {}),
+        Option.new(:timeout_in_seconds, Option::Integer, 30),
+        Option.new(:ui,                 Option::String, "DeepTest::UI::Console"),
+        Option.new(:worker_listener,    Option::String, "DeepTest::NullWorkerListener"),
+      ]
+    end
+
+    attr_accessor *VALID_OPTIONS.map {|o| o.name}
+
+    def ui=(value)
+      @ui = value.to_s
+    end
+
+    def worker_listener=(value)
+      @worker_listener = value.to_s
+    end
+
+    def self.from_command_line(command_line)
+      hash = {}
+      VALID_OPTIONS.each do |option|
+        hash[option.name] = option.from_command_line(command_line)
+      end
+      new(hash)
+    end
+
+    def initialize(hash)
+      @origin_hostname = Socket.gethostname
+      check_option_keys(hash)
+      VALID_OPTIONS.each do |option|
+        send("#{option.name}=", hash[option.name] || option.default)
+      end
+    end
+
+    def gathering_metrics?
+      !@metrics_file.nil?
+    end
+
+    def new_listener_list
+      listeners = worker_listener.split(',').map do |listener|
+        eval(listener).new
+      end
+      ListenerList.new(listeners)
+    end
+
+    def origin_hostname
+      (Socket.gethostname == @origin_hostname) ? 'localhost' : @origin_hostname
+    end
+
+    # Don't store UI instances in the options instance, which will
+    # need to be dumped over DRb.  UI instances may not be dumpable
+    # and we don't want to have to start yet another DRb Server
+    #
+    UI_INSTANCES = {} unless defined?(UI_INSTANCES)
+    def ui_instance
+      UI_INSTANCES[self] ||= eval(ui).new(self)
+    end
+
+    def to_command_line
+      command_line = []
+      VALID_OPTIONS.each do |option|
+        value = send(option.name)
+        command_line << option.to_command_line(value)
+      end
+      command_line.compact.join(' ')
+    end
+
+    def mirror_path(base)
+      raise "No source directory specified in sync_options" unless sync_options[:source]
+      relative_mirror_path = origin_hostname + sync_options[:source].gsub('/','_')
+      "#{base}/#{relative_mirror_path}"
+    end
+
+    def new_workers
+      if distributed_server.nil?
+        LocalWorkers.new self
+      else
+        begin
+          server = Distributed::TestServer.connect(self)
+          Distributed::RemoteWorkerClient.new(self, server, LocalWorkers.new(self))
+        rescue => e
+          ui_instance.distributed_failover_to_local("connect", e)
+          LocalWorkers.new self
+        end
+      end
+    end
+
+    def server
+      Server.remote_reference(origin_hostname, server_port)
+    end
+
+    protected
+
+    def check_option_keys(hash)
+      hash.keys.each do |key|
+        raise InvalidOptionError.new(key) unless VALID_OPTIONS.any? {|o| o.name == key.to_sym}
+      end
+    end
+
+    class InvalidOptionError < StandardError; end
+  end
+end

data/lib/deep_test/process_orchestrator.rb

@@ -0,0 +1,49 @@
+module DeepTest
+  class ProcessOrchestrator
+    def self.run(options, workers, runner)
+      new(options, workers, runner).run
+    end
+    
+    def initialize(options, workers, runner)
+      @options = options
+      @runner = runner
+      @workers = workers
+    end
+    
+    def run(exit_when_done = true)
+      passed = false
+
+      begin
+        server = Server.start(@options)
+        @options.new_listener_list.before_starting_workers
+        @workers.start_all
+        begin
+          DeepTest.logger.debug "Loader Starting (#{$$})"
+          passed = @runner.process_work_units
+        ensure
+          shutdown(server)
+        end
+      ensure
+        DeepTest.logger.debug "ProcessOrchestrator: Stopping Server"
+        Server.stop
+      end
+
+      Kernel.exit(passed ? 0 : 1) if exit_when_done
+    end
+
+    def shutdown(server)
+      DeepTest.logger.debug "ProcessOrchestrator: Shutting Down"
+      server.done_with_work
+
+      first_exception = $!
+      begin
+        DeepTest.logger.debug "ProcessOrchestrator: Stopping Workers"
+        @workers.stop_all
+      rescue DRb::DRbConnError
+        # Workers must have already stopped
+      rescue Exception => e
+        raise first_exception || e
+      end
+    end
+  end
+end

data/lib/deep_test/rake_tasks.rb

@@ -0,0 +1,11 @@
+require "socket"
+
+require File.dirname(__FILE__) + "/option"
+require File.dirname(__FILE__) + "/options"
+require File.dirname(__FILE__) + "/test_task"
+require File.dirname(__FILE__) + "/rspec_detector"
+
+DeepTest::RSpecDetector.if_rspec_available do
+  require 'spec/rake/spectask'
+  require File.dirname(__FILE__) + "/spec/extensions/spec_task"
+end

data/lib/deep_test/result_reader.rb

@@ -0,0 +1,36 @@
+module DeepTest
+  class ResultReader
+    def initialize(blackboard)
+      @blackboard = blackboard
+    end
+
+    def read(original_work_units_by_id)
+      work_units_by_id = original_work_units_by_id.dup
+      errors = 0
+
+      begin
+        until errors == work_units_by_id.size
+          Thread.pass
+          result = @blackboard.take_result
+          next if result.nil?
+
+          if Worker::Error === result
+            puts result
+            errors += 1
+          else
+            if result.respond_to?(:output) && (output = result.output)
+              print output
+            end
+
+            work_unit = work_units_by_id.delete(result.identifier)
+            yield [work_unit, result]
+          end
+        end
+      rescue Server::ResultOverdueError
+        DeepTest.logger.error("Results are overdue from server, ending run")
+      end
+
+      work_units_by_id
+    end
+  end
+end