jason-o-matic-deep_test 1.2.2.1

data/lib/deep_test/null_worker_listener.rb

@@ -0,0 +1,65 @@
+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
+    
+    def before_remote_load_files
+    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,70 @@
+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
+
+    module Array
+      def self.to_string(a)
+        a.join(File::PATH_SEPARATOR)
+      end
+
+      def self.from_string(a)
+        a.split(File::PATH_SEPARATOR)
+      end
+    end
+  end
+end

data/lib/deep_test/options.rb

@@ -0,0 +1,112 @@
+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"),
+        Option.new(:libs,               Option::Array, []),
+        Option.new(:requires,           Option::Array, []),
+      ]
+    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

data/lib/deep_test/rspec_detector.rb

@@ -0,0 +1,24 @@
+module DeepTest
+  class RSpecDetector
+    def self.if_rspec_available
+      require "rubygems"
+      # requiring 'spec' directly blows up unit-record
+      require "spec/version" 
+      if defined?(::Spec)
+        if ::Spec::VERSION::MAJOR == 1 &&
+           ::Spec::VERSION::MINOR == 1 &&
+           ::Spec::VERSION::TINY  == 8
+          yield
+        else
+          require 'spec/rake/spectask'
+          ::Spec::Rake::SpecTask.class_eval do
+            def deep_test(options)
+              raise "* DeepTest RSpec support requires RSpec 1.1.8"
+            end
+          end
+        end
+      end
+    rescue LoadError, Gem::LoadError
+    end
+  end
+end

data/lib/deep_test/server.rb

@@ -0,0 +1,75 @@
+module DeepTest
+  class Server
+    def self.start(options)
+      server = new(options)
+      DRb.start_service("druby://0.0.0.0:#{options.server_port}", server)
+      DeepTest.logger.info "Started DeepTest service at #{DRb.uri}"
+      server
+    end
+
+    def self.stop
+      DRb.stop_service
+    end
+
+    def self.remote_reference(address, port)
+      DRb.start_service
+      blackboard = DRbObject.new_with_uri("druby://#{address}:#{port}")
+      DeepTest.logger.debug "Connecting to DeepTest server at #{blackboard.__drburi}"
+      blackboard
+    end
+
+    def initialize(options)
+      @options = options
+      @work_queue = Queue.new
+      @result_queue = Queue.new
+
+      if Metrics::Gatherer.enabled?
+        require File.dirname(__FILE__) + "/metrics/queue_lock_wait_time_measurement"
+        @work_queue.extend Metrics::QueueLockWaitTimeMeasurement
+        @result_queue.extend Metrics::QueueLockWaitTimeMeasurement
+        Metrics::Gatherer.section("server queue lock wait times") do |s|
+          s.measurement("work queue total pop wait time", @work_queue.total_pop_time)
+          s.measurement("work queue total push wait time", @work_queue.total_push_time)
+          s.measurement("result queue total pop wait time", @result_queue.total_pop_time)
+          s.measurement("result queue total push wait time", @result_queue.total_push_time)
+        end
+      end
+    end
+
+    def done_with_work
+      @done_with_work = true
+    end
+
+    def take_result
+      Timeout.timeout(@options.timeout_in_seconds, ResultOverdueError) do
+        @result_queue.pop
+      end
+    end
+
+    def take_work
+      raise NoWorkUnitsRemainingError if @done_with_work
+
+      @work_queue.pop(true)
+    rescue ThreadError => e
+      if e.message == "queue empty"
+        raise NoWorkUnitsAvailableError
+      else
+        raise
+      end
+    end
+
+    def write_result(result)
+      @result_queue.push result
+      nil
+    end
+
+    def write_work(work_unit)
+      @work_queue.push work_unit
+      nil
+    end
+
+    class NoWorkUnitsAvailableError < StandardError; end
+    class NoWorkUnitsRemainingError < StandardError; end
+    class ResultOverdueError < StandardError; end
+  end
+end