deep_test 1.1.4 → 1.2.0

data/lib/deep_test/options.rb

@@ -1,33 +1,25 @@
 module DeepTest
   class Options
-    class Option
-      attr_reader :name, :default
-
-      def initialize(name, conversion, default)
-        @name, @conversion, @default = name, conversion, default
-      end
-
-      def from_command_line(command_line)
-        command_line =~ /--#{name} (\S+)(\s|$)/
-        $1.send(@conversion) if $1
-      end
-
-      def to_command_line(value)
-        "--#{name} #{value}" if value && value != default
-      end
-    end
-
     unless defined?(VALID_OPTIONS)
       VALID_OPTIONS = [
-        Option.new(:number_of_workers, :to_i, 2),
-        Option.new(:pattern, :to_s, nil),
-        Option.new(:timeout_in_seconds, :to_i, 30),
-        Option.new(:server_port, :to_i, 6969),
-        Option.new(:worker_listener, :to_s, "DeepTest::NullWorkerListener"),
+        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
@@ -41,14 +33,35 @@ module DeepTest
     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 new_worker_listener
-      eval(worker_listener).new
+    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
@@ -60,6 +73,30 @@ module DeepTest
       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)

data/lib/deep_test/process_orchestrator.rb

@@ -1,96 +1,49 @@
 module DeepTest
   class ProcessOrchestrator
-    def self.run(options, runner)
-      new(options, runner).run
+    def self.run(options, workers, runner)
+      new(options, workers, runner).run
     end
     
-    def initialize(options, runner)
+    def initialize(options, workers, runner)
       @options = options
       @runner = runner
+      @workers = workers
     end
     
-    def run
-      stop_zombie_warlocks
-      start_warlock_server
-      start_all_workers
-      start_loader
-      wait_for_loader_to_be_done
-      exit_process        
-    ensure
-      stop_all_warlocks
-    end
-    
-  private
-
-    def exit_process
-      Kernel.exit($?.success? ? 0 : 1)
-    end
-
-    def start_all_workers
-      each_worker do |worker_num|
-        start_worker(worker_num) do
-          reseed_random_numbers
-          reconnect_to_database
-          worker = DeepTest::Worker.new(worker_num,
-                                        RindaBlackboard.new(@options), 
-                                        @options.new_worker_listener)
-          worker.run
-        end
-      end        
-    end
-
-    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 wait_for_loader_to_be_done
-      Process.wait(@loader_pid)
-    end
-
-    def start_warlock_server
-      server_ready = false
-      previous_trap = Signal.trap('USR2') {server_ready = true}
-
-      pid = Process.pid
-      @warlock.start("server") do
-        DeepTest::Server.start(@options) do
-          Process.kill('USR2', pid)
+    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
 
-      Thread.pass until server_ready
-    ensure
-      Signal.trap('USR2', previous_trap)
+      Kernel.exit(passed ? 0 : 1) if exit_when_done
     end
 
-    def stop_all_warlocks
-      @warlock.stop_all if @warlock
-    end
+    def shutdown(server)
+      DeepTest.logger.debug "ProcessOrchestrator: Shutting Down"
+      server.done_with_work
 
-    def each_worker
-      @options.number_of_workers.to_i.times { |worker_num| yield worker_num }
-    end
-
-    def stop_zombie_warlocks
-      @warlock = DeepTest::Warlock.new
-      Signal.trap("HUP") { warlock.stop_all; exit 0 }
-    end
-
-    def start_loader
-      @loader_pid = fork do
-        DeepTest.logger.debug "Loader Starting (#{$$})"
-        passed = @runner.process_work_units
-        exit(passed ? 0 : 1)
+      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,3 +1,6 @@
+require "socket"
+
+require File.dirname(__FILE__) + "/option"
 require File.dirname(__FILE__) + "/options"
 require File.dirname(__FILE__) + "/test_task"
 require File.dirname(__FILE__) + "/rspec_detector"

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

@@ -1,17 +1,24 @@
 module DeepTest
   class RSpecDetector
     def self.if_rspec_available
-      begin
-        require 'rubygems'
-      rescue LoadError
-      else
-        begin
-          gem 'rspec'
-        rescue Gem::LoadError
-        else
+      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  >= 3
           yield
+        else
+          require 'spec/rake/spectask'
+          ::Spec::Rake::SpecTask.class_eval do
+            def deep_test(options)
+              raise "* DeepTest RSpec support requires RSpec 1.1.3 or greater"
+            end
+          end
         end
       end
+    rescue LoadError, Gem::LoadError
     end
   end
 end

data/lib/deep_test/server.rb

@@ -1,11 +1,75 @@
 module DeepTest
   class Server
     def self.start(options)
-      DRb.start_service
-      Rinda::RingServer.new(Rinda::TupleSpace.new, options.server_port)
+      server = new(options)
+      DRb.start_service("druby://0.0.0.0:#{options.server_port}", server)
       DeepTest.logger.info "Started DeepTest service at #{DRb.uri}"
-      yield if block_given?
-      DRb.thread.join
+      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

@@ -3,6 +3,7 @@ require 'spec/example/example_group_methods'
 require 'spec/rake/spectask'
 
 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"

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

@@ -1,38 +1,64 @@
 module Spec
   module Example
     module ExampleGroupMethods
-      PREPEND_BEFORE = instance_method(:prepend_before) unless defined?(PREPEND_BEFORE)
-      APPEND_BEFORE = instance_method(:append_before) unless defined?(APPEND_BEFORE)
-      PREPEND_AFTER = instance_method(:prepend_after) unless defined?(PREPEND_AFTER)
-      APPEND_AFTER = instance_method(:append_after) unless defined?(APPEND_AFTER)
+      class << self
+        def assign_instance_method_to_constant(proposed_constant)
+          method_sym = proposed_constant.to_s.downcase
+
+          unless const_defined?(proposed_constant)
+            const_set(proposed_constant, instance_method(method_sym))
+          end
+        end
+        
+        private :assign_instance_method_to_constant
+      end
+
+      assign_instance_method_to_constant :PREPEND_BEFORE
+      assign_instance_method_to_constant :APPEND_BEFORE
+      assign_instance_method_to_constant :PREPEND_AFTER
+      assign_instance_method_to_constant :APPEND_AFTER
 
       def prepend_before(*args, &block)
         check_filter_args(args)
-        PREPEND_BEFORE.bind(self).call(*args, &block)
+        call_regular_instance_method :prepend_before, *args, &block
       end
 
       def append_before(*args, &block)
         check_filter_args(args)
-        APPEND_BEFORE.bind(self).call(*args, &block)
+        call_regular_instance_method :append_before, *args, &block
       end
+      
       alias_method :before, :append_before
 
       def prepend_after(*args, &block)
         check_filter_args(args)
-        PREPEND_AFTER.bind(self).call(*args, &block)
+        call_regular_instance_method :prepend_after, *args, &block
       end
 
       def append_after(*args, &block)
         check_filter_args(args)
-        APPEND_AFTER.bind(self).call(*args, &block)
+        call_regular_instance_method :append_after, *args, &block
       end
+      
       alias_method :after, :append_after
 
+    private
+    
+      DeepTestAllBlockWarning = 
+        "Warning: DeepTest will run before(:all) and after(:all) blocks for *every* test that is run.  To remove this warning either convert all before/after blocks to each blocks or set $show_deep_test_all_block_warning to false" unless defined?(DeepTestAllBlockWarning)
+      
+      $show_deep_test_all_block_warning = true
+
       def check_filter_args(args)
-        raise BeforeAfterAllNotSupportedByDeepTestError if args.first == :all
+        if args.first == :all && $show_deep_test_all_block_warning
+          $show_deep_test_all_block_warning = false
+          $stderr.puts DeepTestAllBlockWarning 
+        end
+      end
+    
+      def call_regular_instance_method(sym, *args, &block)
+        ExampleGroupMethods.const_get(sym.to_s.upcase).bind(self).call(*args, &block)
       end
-
-      class BeforeAfterAllNotSupportedByDeepTestError < StandardError; end
     end
   end
 end