jstorimer-deep-test 1.4.0 → 2.0.0

data/lib/deep_test/main.rb

@@ -0,0 +1,41 @@
+module DeepTest
+  class Main
+    attr_reader :central_command
+
+    def initialize(options, deployment, runner, central_command = nil)
+      @options = options
+      @deployment = deployment
+      @runner = runner
+      @central_command = central_command || CentralCommand.start(options)
+    end
+
+    def load_files(files)
+      @deployment.load_files files
+    end
+    
+    def run(exit_when_done = true)
+      passed = false
+
+      begin
+        @options.new_listener_list.before_starting_agents
+        @deployment.deploy_agents
+        begin
+          DeepTest.logger.debug { "Main: About to process work units (#{$$})" }
+          passed = @runner.process_work_units(central_command)
+        ensure
+          shutdown
+        end
+      ensure
+        DeepTest.logger.debug { "Main: Stopping CentralCommand" }
+        @central_command.stop
+      end
+
+      Kernel.exit(passed ? 0 : 1) if exit_when_done
+    end
+
+    def shutdown
+      DeepTest.logger.debug { "Main: Shutting Down" }
+      @central_command.done_with_work
+    end
+  end
+end

data/lib/deep_test/marshallable_exception_wrapper.rb

@@ -19,8 +19,8 @@ module DeepTest
         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"))
+        DeepTest.logger.debug { "Unable to load exception class: #{classname}: #{e.message}" }
+        DeepTest.logger.debug { e.backtrace.join("\n") }
 
         klass = UnloadableException
         resolved_message = "#{classname}: #{message}"
@@ -29,8 +29,8 @@ module DeepTest
       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"))
+        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

data/lib/deep_test/metrics/data.rb

@@ -0,0 +1,34 @@
+module DeepTest
+  module Metrics
+    class Data
+      def initialize
+        @measurements_by_category = {}
+      end
+
+      def add(measurement)
+        categories = @measurements_by_category[measurement.category] ||= []
+        categories << measurement
+      end
+
+      def summary
+        summary = []
+        summary << "Metrics Data\n"
+        summary << "------------\n"
+
+        @measurements_by_category.keys.sort.map do |category|
+          measurements = @measurements_by_category[category]
+          units = measurements.first.units
+          summary << "#{category}: #{Measurement.average(measurements)} avg / #{Measurement.total(measurements)} total #{units}\n"
+        end
+
+        summary.join
+      end
+
+      def save(file)
+        File.open(file, "w") do |f|
+          f << summary
+        end
+      end
+    end
+  end
+end

data/lib/deep_test/metrics/measurement.rb

@@ -0,0 +1,39 @@
+module DeepTest
+  module Metrics
+    class Measurement
+      attr_reader :category, :value, :units
+
+      def initialize(category, value, units)
+        @category = category
+        @value = value
+        @units = units
+      end
+
+      def self.average(measurements)
+        total(measurements).to_f / measurements.size
+      end
+
+      def self.total(measurements)
+        measurements.inject(0) { |sum, m| sum + m.value }
+      end
+
+      def self.of_time_taken(category)
+        start = Time.now
+        yield
+        Measurement.new category, Time.now - start, "seconds"
+      end
+
+      def self.send_home(category, wire, options)
+        result = nil
+        measurement = of_time_taken(category) { result = yield }
+        if options.gathering_metrics?
+          begin
+            wire.send_message measurement
+          rescue Telegraph::LineDead
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/deep_test/{null_worker_listener.rb → null_listener.rb}

@@ -2,7 +2,7 @@ module DeepTest
   #
   # Listener that implements no-ops for all callbacks that DeepTest supports.
   #
-  class NullWorkerListener
+  class NullListener
     #
     # Before DeepTest synchronizes any code during a distributed run,
     # before_sync is called.  If DeepTest is not running distributed,
@@ -12,51 +12,51 @@ module DeepTest
     end
 
     #
-    # Before DeepTest starts any workers, it instantiates a listener and
+    # Before DeepTest starts any agents, it instantiates a listener and
     # invokes this method.  No other callbacks are made to the listener
     # instance receiving this message. 
     #
-    def before_starting_workers
+    def before_starting_agents
     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
+    # A separate listener instance is created in each agent process and
+    # notified that the agent is starting.  The agent for the process is
+    # provided for the listener to use.  If you are using 3 agents, 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.
+    # the agent provided.
     #
-    def starting(worker)
+    def starting(agent)
     end
 
     #
-    # Each time a worker takes a work unit, it calls this method before
+    # Each time a agent 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
+    # starting callback with the agent 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)
+    def starting_work(agent, work_unit)
     end
 
     #
-    # Each time a worker finishes computing a result for a work unit, 
+    # Each time a agent 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
+    # starting callback with the agent 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)
+    def finished_work(agent, work_unit, result)
     end
   end
 end

data/lib/deep_test/options.rb

@@ -1,23 +1,25 @@
 module DeepTest
+  Option = Struct.new :name, :default unless defined?(Option)
+
   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(: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"),
       ]
     end
 
     attr_accessor *VALID_OPTIONS.map {|o| o.name}
-    
+    attr_accessor :ssh_client_connection_info, :environment_log_level
+
     def number_of_agents
-      cpu_count unless @number_of_agents
+      return CpuInfo.new.count unless @number_of_agents
       @number_of_agents
     end
 
@@ -25,24 +27,22 @@ module DeepTest
       @ui = value.to_s
     end
 
-    def worker_listener=(value)
-      @worker_listener = value.to_s
+    def listener=(value)
+      @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)
+      return new({}) if command_line.nil? || command_line.empty?
+      Marshal.load Base64.decode64(command_line)
     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)
+        send("#{option.name}=", hash[option.name] || hash[option.name.to_s] || option.default)
       end
+      self.environment_log_level = ENV['DEEP_TEST_LOG_LEVEL']
     end
 
     def gathering_metrics?
@@ -50,7 +50,7 @@ module DeepTest
     end
 
     def new_listener_list
-      listeners = worker_listener.split(',').map do |listener|
+      listeners = listener.split(',').map do |listener|
         eval(listener).new
       end
       ListenerList.new(listeners)
@@ -60,9 +60,15 @@ 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 DRb.  UI instances may not be dumpable
-    # and we don't want to have to start yet another DRb Server
+    # need to be dumped over Telegraph since UI instances may not be dumpable.
     #
     UI_INSTANCES = {} unless defined?(UI_INSTANCES)
     def ui_instance
@@ -70,56 +76,35 @@ module DeepTest
     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(' ')
+      Base64.encode64(Marshal.dump(self)).gsub("\n","")
     end
 
-    def mirror_path(base)
+    def mirror_path
       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}"
+      relative_mirror_path = @origin_hostname + sync_options[:source].gsub('/','_')
+      "#{sync_options[:remote_base_dir] || '/tmp'}/#{relative_mirror_path}"
     end
 
-    def new_workers
-      if distributed_server.nil?
-        LocalWorkers.new self
+    def new_deployment
+      if distributed_hosts.nil?
+        LocalDeployment.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
+        Distributed::RemoteDeployment.new self, new_landing_fleet, LocalDeployment.new(self)
       end
     end
 
-    def server
-      Server.remote_reference(origin_hostname, server_port)
-    end
-    
-    def cpu_count
-      case RUBY_PLATFORM
-      when /darwin/
-        output = `sysctl -n hw.ncpu`
-        output.strip.to_i
-      when /linux/
-        File.readlines("/proc/cpuinfo").inject(0) do |count, line|
-          next count + 1 if line =~ /processor\s*:\s*\d+/
-          count
-        end
+    def new_landing_fleet
+      landing_ships = distributed_hosts.map do |host|
+        Distributed::LandingShip.new :address => host
       end
+      Distributed::LandingFleet.new self, landing_ships
     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}
+        raise InvalidOptionError.new("#{key} is not a valid option") unless VALID_OPTIONS.any? {|o| o.name == key.to_sym}
       end
     end
 

data/lib/deep_test/proxy_io.rb

@@ -0,0 +1,77 @@
+module DeepTest
+  class ProxyIO < StringIO
+    def initialize(output_module, wire)
+      @output_module = output_module
+      @wire = wire
+      super("")
+    end
+
+    def write(*args)
+      super
+      @wire.send_message @output_module::Output.new(string)
+      self.string = ""
+    end
+
+    def flush
+      @wire.send_message @output_module::Flush.new
+    end
+
+    def self.replace_stdout_stderr!(wire)
+      old_stdout_const, old_stdout_global = STDOUT, $stdout
+      old_stderr_const, old_stderr_global = STDERR, $stderr
+
+      supress_warnings { Object.const_set :STDOUT, ProxyIO.new(Stdout, wire) }
+      $stdout = STDOUT
+
+      supress_warnings { Object.const_set :STDERR, ProxyIO.new(Stderr, wire) }
+      $stderr = STDERR
+
+      DeepTest.logger = nil
+
+      yield
+    ensure
+      $stdout = old_stdout_global
+      supress_warnings { Object.const_set :STDOUT, old_stdout_const }
+
+      $stderr = old_stderr_global
+      supress_warnings { Object.const_set :STDERR, old_stderr_const }
+    end
+
+    def self.supress_warnings
+      old_verbose, $VERBOSE = $VERBOSE, nil
+      yield
+    ensure
+      $VERBOSE = old_verbose
+    end
+
+    class AbstractOutput
+      include CentralCommand::Operation
+      attr_reader :s
+      def initialize(s); @s = s; end
+      def execute; stream.write s; end
+      def ==(other); self.class == other.class && s == other.s; end
+    end
+
+    module Stdout
+      class Output < AbstractOutput
+        def stream; $stdout; end
+      end
+
+      class Flush
+        include CentralCommand::Operation
+        def execute; $stdout.flush; end
+      end
+    end
+
+    module Stderr
+      class Output < AbstractOutput
+        def stream; $stderr; end
+      end
+
+      class Flush
+        include CentralCommand::Operation
+        def execute; $stderr.flush; end
+      end
+    end
+  end
+end