jstorimer-deep-test 0.2.0 → 1.0.0

data/lib/deep_test/options.rb

@@ -1,48 +1,43 @@
 module DeepTest
-  Option = Struct.new :name, :default unless defined?(Option)
-
   class Options
     unless defined?(VALID_OPTIONS)
       VALID_OPTIONS = [
-        Option.new(:distributed_hosts, nil),
-        Option.new(:number_of_agents,  nil),
-        Option.new(:metrics_file,      nil),
-        Option.new(:pattern,           nil),
-        Option.new(:server_port,       nil),
-        Option.new(:sync_options,      {}),
-        Option.new(:ui,                "DeepTest::UI::Console"),
-        Option.new(:listener,          "DeepTest::NullListener"),
+        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}
-    attr_accessor :ssh_client_connection_info, :environment_log_level
-
-    def number_of_agents
-      return CpuInfo.new.count unless @number_of_agents
-      @number_of_agents
-    end
 
     def ui=(value)
       @ui = value.to_s
     end
 
-    def listener=(value)
-      @listener = value.to_s
+    def worker_listener=(value)
+      @worker_listener = value.to_s
     end
 
     def self.from_command_line(command_line)
-      return new({}) if command_line.nil? || command_line.empty?
-      Marshal.load Base64.decode64(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] || hash[option.name.to_s] || option.default)
+        send("#{option.name}=", hash[option.name] || option.default)
       end
-      self.environment_log_level = ENV['DEEP_TEST_LOG_LEVEL']
     end
 
     def gathering_metrics?
@@ -50,7 +45,7 @@ module DeepTest
     end
 
     def new_listener_list
-      listeners = listener.split(',').map do |listener|
+      listeners = worker_listener.split(',').map do |listener|
         eval(listener).new
       end
       ListenerList.new(listeners)
@@ -60,15 +55,9 @@ module DeepTest
       (Socket.gethostname == @origin_hostname) ? 'localhost' : @origin_hostname
     end
 
-    def connect_to_central_command
-      address = ssh_client_connection_info ? ssh_client_connection_info.address : "localhost"
-      Telegraph::Wire.connect(address, server_port) do |wire|
-        yield wire
-      end
-    end
-
     # Don't store UI instances in the options instance, which will
-    # need to be dumped over Telegraph since UI instances may not be dumpable.
+    # 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
@@ -76,35 +65,43 @@ module DeepTest
     end
 
     def to_command_line
-      Base64.encode64(Marshal.dump(self)).gsub("\n","")
+      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
+    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('/','_')
-      "#{sync_options[:remote_base_dir] || '/tmp'}/#{relative_mirror_path}"
+      relative_mirror_path = origin_hostname + sync_options[:source].gsub('/','_')
+      "#{base}/#{relative_mirror_path}"
     end
 
-    def new_deployment
-      if distributed_hosts.nil?
-        LocalDeployment.new self
+    def new_workers
+      if distributed_server.nil?
+        LocalWorkers.new self
       else
-        Distributed::RemoteDeployment.new self, new_landing_fleet, LocalDeployment.new(self)
+        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 new_landing_fleet
-      landing_ships = distributed_hosts.map do |host|
-        Distributed::LandingShip.new :address => host
-      end
-      Distributed::LandingFleet.new self, landing_ships
+    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} is not a valid option") unless VALID_OPTIONS.any? {|o| o.name == key.to_sym}
+        raise InvalidOptionError.new(key) unless VALID_OPTIONS.any? {|o| o.name == key.to_sym}
       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

@@ -1,8 +1,7 @@
 require "socket"
-require "base64"
 
+require File.dirname(__FILE__) + "/option"
 require File.dirname(__FILE__) + "/options"
-require File.dirname(__FILE__) + "/cpu_info"
 require File.dirname(__FILE__) + "/test_task"
 require File.dirname(__FILE__) + "/rspec_detector"
 
@@ -10,4 +9,3 @@ 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

@@ -1,7 +1,7 @@
 module DeepTest
   class ResultReader
-    def initialize(central_command)
-      @central_command = central_command
+    def initialize(blackboard)
+      @blackboard = blackboard
     end
 
     def read(original_work_units_by_id)
@@ -11,10 +11,10 @@ module DeepTest
       begin
         until errors == work_units_by_id.size
           Thread.pass
-          result = @central_command.take_result
+          result = @blackboard.take_result
           next if result.nil?
 
-          if Agent::Error === result
+          if Worker::Error === result
             puts result
             errors += 1
           else
@@ -26,12 +26,8 @@ module DeepTest
             yield [work_unit, result]
           end
         end
-      rescue CentralCommand::NoAgentsRunningError
-        FailureMessage.show "DeepTest Agents Are Not Running", <<-end_msg
-          DeepTest's test running agents have not contacted the 
-          server to indicate they are still running.
-          Shutting down the test run on the assumption that they have died. 
-        end_msg
+      rescue Server::ResultOverdueError
+        DeepTest.logger.error("Results are overdue from server, ending run")
       end
 
       work_units_by_id

data/lib/deep_test/rspec_detector.rb

@@ -5,7 +5,7 @@ module DeepTest
         require 'spec/version'
         if ::Spec::VERSION::MAJOR == 1 &&
            ::Spec::VERSION::MINOR == 1 &&
-           ::Spec::VERSION::TINY  >= 8
+           ::Spec::VERSION::TINY  == 8
           yield
         else
           require 'spec/rake/spectask'

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

data/lib/deep_test/spec.rb

@@ -1,10 +1,5 @@
 require 'rubygems'
 require 'spec/runner/example_group_runner'
-if ::Spec::VERSION::MAJOR == 1 &&
-   ::Spec::VERSION::MINOR == 1 &&
-   ::Spec::VERSION::TINY  >= 12
-  require 'spec/example/before_and_after_hooks'
-end
 require 'spec/example/example_group_methods'
 require 'spec/rake/spectask'
 
@@ -12,6 +7,7 @@ require File.dirname(__FILE__) + "/spec/extensions/example_group_methods"
 require File.dirname(__FILE__) + "/spec/extensions/example_methods"
 require File.dirname(__FILE__) + "/spec/extensions/spec_task"
 require File.dirname(__FILE__) + "/spec/extensions/options"
+require File.dirname(__FILE__) + "/spec/extensions/reporter"
 require File.dirname(__FILE__) + "/spec/runner"
 require File.dirname(__FILE__) + "/spec/work_unit"
 require File.dirname(__FILE__) + "/spec/work_result"

data/lib/deep_test/spec/extensions/example_methods.rb

@@ -2,13 +2,7 @@ module Spec
   module Example
     module ExampleMethods
       def identifier
-        if ::Spec::VERSION::MAJOR == 1 &&
-           ::Spec::VERSION::MINOR == 1 &&
-           ::Spec::VERSION::TINY  >= 12
-          file, line = eval("caller", @_implementation).first.split(/:/)
-        else
-          file, line = implementation_backtrace.first.split(/:/)
-        end
+        file, line = implementation_backtrace.first.split(/:/)
         Identifier.new(file, line.to_i, self.class.description, description)
       end
 

data/lib/deep_test/spec/extensions/reporter.rb

@@ -0,0 +1,29 @@
+require 'spec/runner/reporter'
+module Spec
+  module Runner
+    class Reporter
+      def example_finished(example, error=nil)
+        @examples << example
+        
+        if error.nil?
+          example_passed(example)
+        elsif Spec::Example::ExamplePendingError === error
+          example_pending(example, error.message)
+        else
+          example_failed(example, error)
+        end
+      end
+
+      def failure(example, error)
+        backtrace_tweaker.tweak_backtrace(error)
+        example_name = "#{example.class.description} #{example.description}"
+        failure = Failure.new(example, error)
+        @failures << failure
+        formatters.each do |f|
+          f.example_failed(example, @failures.length, failure)
+        end
+      end
+      alias_method :example_failed, :failure
+    end
+  end
+end

data/lib/deep_test/spec/extensions/spec_task.rb

@@ -1,11 +1,10 @@
-require File.dirname(__FILE__) + "/../../lib_root"
-
 module Spec
   module Rake
     class SpecTask
       def deep_test(options)
         deep_test_options = DeepTest::Options.new(options)
-        deep_test_path = File.expand_path(DeepTest::LIB_ROOT + "/deep_test")
+        deep_test_path = File.expand_path(File.dirname(__FILE__) + 
+                                          "/../../../deep_test")
         @deep_test_spec_opts = [
           "--require #{deep_test_path}",
           "--runner 'DeepTest::Spec::Runner:#{deep_test_options.to_command_line}'"

data/lib/deep_test/spec/runner.rb

@@ -1,66 +1,51 @@
 module DeepTest
   module Spec
     class Runner < ::Spec::Runner::ExampleGroupRunner
-      def initialize(options, deep_test_options)
+      def initialize(options, deep_test_options, blackboard = nil)
         super(options)
-        if ::Spec::VERSION::MAJOR == 1 &&
-           ::Spec::VERSION::MINOR == 1 &&
-           ::Spec::VERSION::TINY  >= 12
-          @runner_options = options # added to make work with 1.1.12
-        end
         @deep_test_options = DeepTest::Options.from_command_line(deep_test_options)
+        DeepTest.init(@deep_test_options)
+        @blackboard = blackboard
+        @workers = @deep_test_options.new_workers
       end
 
-      def main
-        @main ||= Main.new @deep_test_options, @deep_test_options.new_deployment, self
-      end
-
-      def central_command
-        # Can't create central_command as default argument to initialize
-        # because Main hasn't been invoked at 
+      def blackboard
+        # Can't create blackboard as default argument to initialize
+        # because ProcessOrchestrator hasn't been invoked at 
         # instantiation time
-        @central_command ||= main.central_command
+        @blackboard ||= @deep_test_options.server
       end
 
       def load_files(files)
-        main.load_files files
+        @workers.load_files files
       end
 
       def run
-        main.run
+        ProcessOrchestrator.run(@deep_test_options, @workers, self)
       end
 
-      def process_work_units(central_command)
+      def process_work_units
         prepare
 
-        examples = (example_groups.map do |g|
-          if ::Spec::VERSION::MAJOR == 1 &&
-             ::Spec::VERSION::MINOR == 1 &&
-             ::Spec::VERSION::TINY  >= 12
-            g.send(:examples_to_run, @runner_options) # added @runner_options to make wiork with 1.1.12
-          else
-            g.send(:examples_to_run)
-          end
-        end).flatten
+        examples = example_groups.map {|g| g.send(:examples_to_run)}.flatten
         examples_by_location = {}
         examples.each do |example|
           raise "duplicate example: #{example.identifier}" if examples_by_location[example.identifier]
           examples_by_location[example.identifier] = example
-          central_command.write_work Spec::WorkUnit.new(example.identifier)
+          blackboard.write_work Spec::WorkUnit.new(example.identifier)
         end
 
         success = true
 
-        missing_examples = ResultReader.new(central_command).read(examples_by_location) do |example, result|
+        missing_exmaples = ResultReader.new(blackboard).read(examples_by_location) do |example, result|
           @options.reporter.example_finished(example, result.error)
           success &= result.success?
         end
 
-        success &= missing_examples.empty?
+        success &= missing_exmaples.empty?
 
-        if missing_examples.any?
-          @options.reporter.example_finished(examples_by_location[missing_examples.keys.first],
-                                             IncompleteTestRunError.new(missing_examples.size))
+        missing_exmaples.each do |identifier, example|
+          @options.reporter.example_finished(example, WorkUnitNeverReceivedError.new)
         end
 
         success