deep_test_pre 2.0

data/lib/deep_test/distributed/shell_environment.rb

@@ -0,0 +1,50 @@
+module DeepTest
+  module Distributed
+    class ShellEnvironment
+      def self.like_login
+        login_env = new
+        login_env.include_first '/etc/profile'
+        login_env.include_first '~/.profile', '~/.bash_profile',  '~/.bashrc'
+        login_env
+      end
+
+      def initialize
+        @source_file_lists = []
+      end
+
+      def include_first(*filenames)
+        source_file_lists << SourceFileList.new(filenames)
+      end
+
+      def to_s
+        source_file_lists.join(" && ")
+      end
+
+      def ==(other)
+        source_file_lists == other.source_file_lists
+      end
+
+      attr_reader :source_file_lists
+      protected :source_file_lists
+
+      class SourceFileList
+        def initialize(filenames)
+          @filenames = filenames
+        end
+
+        def to_s
+          "if" + 
+          filenames.map {|f| " [[ -f #{f} ]]; then . #{f}; "}.join("elif") +
+          "fi"
+        end
+
+        def ==(other)
+          filenames == other.filenames
+        end
+
+        attr_reader :filenames
+        protected :filenames
+      end
+    end
+  end
+end

data/lib/deep_test/distributed/ssh_client_connection_info.rb

@@ -0,0 +1,14 @@
+module DeepTest
+  module Distributed
+    class SshClientConnectionInfo
+      attr_reader :address
+
+      def initialize
+        raise "SSH_CLIENT environment variable not set" unless ENV['SSH_CLIENT']
+        ENV['SSH_CLIENT'] =~ /^(.+) \d+ \d+$/
+        raise "Unable to extract address from SSH_CLIENT (#{ENV['SSH_CLIENT']})" unless $1
+        @address = $1
+      end
+    end
+  end
+end

data/lib/deep_test/extensions/object_extension.rb

@@ -0,0 +1,40 @@
+require "stringio"
+module DeepTest
+  module ObjectExtension
+    def capture_stdout
+      old_stdout, $stdout = $stdout, StringIO.new
+      yield
+      $stdout.string
+    ensure
+      $stdout = old_stdout if old_stdout
+    end
+
+    def capture_stderr
+      old_stderr, $stderr = $stderr, StringIO.new
+      yield
+      $stderr.string
+    ensure
+      $stderr = old_stderr if old_stderr
+    end
+    
+    def retrying(description = nil, times = 5)
+      i = 0
+      loop do
+        begin
+          return yield
+        rescue => e
+          i += 1
+          print "#{description} received exception #{e}. "
+          if i < times
+            puts "Retrying..."
+            sleep 0.5
+          else
+            puts "Aborting."
+            raise e
+          end
+        end
+      end
+    end
+  end
+end
+Object.send :include, DeepTest::ObjectExtension

data/lib/deep_test/failure_message.rb

@@ -0,0 +1,19 @@
+module DeepTest
+  module FailureMessage
+    def self.show(title, message, width = 70)
+      lines = [" #{title} ".center(width, '*')]
+      message.each do |line|
+        lines << "* #{line.strip}".ljust(width - 1) + "*"
+      end
+      lines <<  "*" * width
+      string = lines.join("\n")
+      begin
+        puts string
+      rescue
+        IO.new(2) do |err|
+          err.puts string
+        end
+      end
+    end
+  end
+end

data/lib/deep_test/lib_root.rb

@@ -0,0 +1,4 @@
+module DeepTest
+  LIB_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '/..')) unless defined?(DeepTest::LIB_ROOT)
+end
+

data/lib/deep_test/listener_list.rb

@@ -0,0 +1,17 @@
+module DeepTest
+  class ListenerList
+    attr_reader :listeners
+
+    def initialize(listeners)
+      @listeners = listeners
+    end
+
+    NullListener.instance_methods(false).each do |event|
+      eval <<-end_src
+        def #{event}(*args)
+          @listeners.each {|l| l.#{event}(*args)}
+        end
+      end_src
+    end
+  end
+end

data/lib/deep_test/local_deployment.rb

@@ -0,0 +1,46 @@
+module DeepTest
+  class LocalDeployment
+    attr_reader :warlock
+
+    def initialize(options, agent_class = DeepTest::Agent)
+      @options = options
+      @agent_class = agent_class
+    end
+
+    def warlock
+      @warlock ||= Warlock.new @options
+    end
+
+    def load_files(files)
+      files.each {|f| load f}
+    end
+
+    def deploy_agents
+      DeepTest.logger.debug { "Deploying #{number_of_agents} #{@agent_class}s" }
+      wait_for_connect_threads = []
+      each_agent do |agent_num|
+        stream_from_child_process, stream_to_parent_process = IO.pipe
+        warlock.start "agent #{agent_num}", @agent_class.new(agent_num, @options, @options.new_listener_list), 
+                      stream_from_child_process, stream_to_parent_process
+        wait_for_connect_threads << Thread.new do
+          stream_to_parent_process.close
+          message = stream_from_child_process.read
+          stream_from_child_process.close
+          raise "Agent was not able to connect: #{message}" unless message == "Connected\n"
+        end
+      end        
+
+      wait_for_connect_threads.each { |t| t.join }
+    end
+
+    def number_of_agents
+      @options.number_of_agents
+    end
+
+    private
+
+    def each_agent
+      number_of_agents.to_i.times { |agent_num| yield agent_num }
+    end
+  end
+end

data/lib/deep_test/logger.rb

@@ -0,0 +1,32 @@
+module DeepTest
+  class Logger < ::Logger
+    def initialize(*args)
+      super
+      hostname = Socket.gethostname
+      self.formatter = proc { |severity, time, progname, msg| "[DeepTest@#{hostname}] #{time.strftime "%F %T"} #{msg}\n" }
+      self.level = configured_log_level
+    end
+
+    def io_stream
+      @logdev.dev
+    end
+
+    def configured_log_level
+      if ENV['DEEP_TEST_LOG_LEVEL']
+        Logger.const_get(ENV['DEEP_TEST_LOG_LEVEL'].upcase)
+      else
+        Logger::INFO
+      end
+    end
+
+    Severity.constants.each do |severity|
+      eval <<-end_src
+        def #{severity.downcase}
+          super
+        rescue Exception => e
+          super "\#{e.class}: \#{e} occurred logging on \#{caller[0]}", &nil
+        end
+      end_src
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module DeepTest
+  class MarshallableExceptionWrapper
+    attr_reader :classname, :message, :backtrace
+
+    def initialize(exception)
+      @classname = exception.class.name
+      @message = exception.message
+      @backtrace = exception.backtrace
+    end
+
+    def ==(other)
+      classname == other.classname &&
+        message == other.message &&
+      backtrace == other.backtrace
+    end
+
+    def resolve
+      begin
+        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") }
+
+        klass = UnloadableException
+        resolved_message = "#{classname}: #{message}"
+      end
+
+      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") }
+
+        resolved_exception = UnloadableException.new resolved_message
+      end
+
+      resolved_exception.set_backtrace backtrace
+      resolved_exception
+    end
+  end
+
+  class UnloadableException < StandardError; end
+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_listener.rb

@@ -0,0 +1,62 @@
+module DeepTest
+  #
+  # Listener that implements no-ops for all callbacks that DeepTest supports.
+  #
+  class NullListener
+    #
+    # 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 agents, it instantiates a listener and
+    # invokes this method.  No other callbacks are made to the listener
+    # instance receiving this message. 
+    #
+    def before_starting_agents
+    end
+
+    #
+    # 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 agent provided.
+    #
+    def starting(agent)
+    end
+
+    #
+    # 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 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(agent, work_unit)
+    end
+
+    #
+    # 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 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(agent, work_unit, result)
+    end
+  end
+end