DTR 0.0.1 → 0.0.2

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: DTR
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
-date: 2007-09-19 00:00:00 +08:00
+  version: 0.0.2
+date: 2007-10-08 00:00:00 +08:00
 summary: DTR is a distributed test runner to run tests on distributed computers for decreasing build time.
 require_paths: 
 - lib
@@ -30,32 +30,25 @@ authors:
 - Li Xiao
 files: 
 - install.rb
-- bin
 - CHANGES
-- doc
-- html
-- lib
 - LICENSE.TXT
 - Rakefile
 - README
-- show_process_exit_code.bat
-- test
-- testdata
-- tmp
 - TODO
 - bin/dtr
-- lib/dtr/base.rb
-- lib/dtr/command_line.rb
-- lib/dtr/drb_dtr.rb
+- lib/dtr/env_store.rb
+- lib/dtr/inject.rb
+- lib/dtr/inject_without_updating_codebase.rb
+- lib/dtr/inject_with_svn.rb
+- lib/dtr/raketasks.rb
 - lib/dtr/ruby_ext.rb
+- lib/dtr/runner.rb
+- lib/dtr/service_provider.rb
+- lib/dtr/svn.rb
 - lib/dtr.rb
-- test/average_packer_test.rb
-- test/base_test.rb
-- test/original_test_reports_test.rb
-- test/ruby_ext_test.rb
-- test/ruby_runner_test.rb
-- test/scenario_setup_and_run_tests_simply.rb
-- test/server_test.rb
+- test/inject_test.rb
+- test/scenario_tests.rb
+- test/svn_test.rb
 - test/test_helper.rb
 - doc/jamis.rb
 test_files: []

data/lib/dtr/base.rb

@@ -1,281 +0,0 @@
-require 'yaml'
-require 'dtr/command_line'
-
-module DTR
-  class AveragePacker
-    def pack(test_files, num_packets)
-      raise 'No test files given' if test_files.nil? || test_files.empty?
-      @packets = Array.new(num_packets) {[]}
-      test_files.each_with_index {|tf,i| @packets[i%num_packets] << tf }
-      
-      @packets
-    end
-  end
-
-  class RubyRunner
-    def run(server, client, test_files, signature)
-      test_files.each do |test_file|
-        logger.info { "\tRun #{test_file}..." }
-        unless File.exist?(test_file.untaint)
-          logger.info {"\tSkip test file not exists: #{test_file}"}
-          next
-        end
-        
-        server_reports = server.reports
-        break unless server_reports # if can't get reports, server maybe shutdown
-        
-        if server_reports[test_file]
-          logger.info {"\tSkip test file has report on server: #{test_file}"}
-          next
-        end
-        result = client.execute("ruby #{test_file}")
-        tests, assertions, failures, errors = parse(result[:stdout])
-        report = TestReport.new(test_file, result, tests, assertions, failures, errors)
-        
-        logger.info { report.to_yaml } unless report.succeeded?
-        
-        break unless server.update signature, report
-      end
-    end
-    
-    SUMMARY_REGEX = /^\s*(\d+) tests, (\d+) assertions, (\d+) failures, (\d+) errors$/
-    def parse(stdout)
-      summary = stdout.strip.split("\n").reverse.find do |line|
-        SUMMARY_REGEX =~ line.strip
-      end
-      if SUMMARY_REGEX =~ summary
-        [$1, $2, $3, $4].collect{|str| str.to_i}
-      else
-        logger.info {"\tStdout has no tests summary line: #{stdout}"}
-        [0, 0, 0, 0]
-      end
-    end
-  end
-
-  class Server
-
-    class NoAliveClientsError < StandardError
-    end
-
-    attr_accessor :server_signature, :test_files, :packer, :runner_name, :latest_build_time
-
-    def initialize(test_files=[])
-      @test_files = test_files
-      @packer = AveragePacker.new
-      @runner_name = RubyRunner.name
-      @server_signature = Object.new.to_s
-      @report_signature = nil
-      @raise_on_no_alive_client = DTROPTIONS[:raise_on_no_alive_client]
-    end
-
-    def latest_build_summary
-      raise 'Server never ran!' unless latest_build_time
-      %{Finished in #{format('%.1f', latest_build_time)} seconds.
-
-#{collect_report(:tests)}, #{collect_report(:assertions)}, #{collect_report(:failures)}, #{collect_report(:errors)}}
-    end
-
-    def clients
-      clients_map.values
-    end
-
-    def available_clients
-      alive_clients = self.clients.select{|client| client.server_signature == @server_signature}
-      raise NoAliveClientsError.new if @raise_on_no_alive_client && alive_clients.empty?
-      alive_clients.select{|client| client.idle?}
-    end
-    
-    def succeeded?
-      complete? && !reports.empty? && reports.values.all?{|report| report.succeeded?}
-    end
-
-    def complete?
-      @complete ||= false
-    end
-    
-    def run(opt={})
-      opt = {:wait_for_reports => true, :setup => false}.merge opt
-      run_start(opt)
-      @run_once = false
-      loop do
-        break if complete?
-        run_once unless @run_once
-        @run_once = DTROPTIONS[:packing_once]
-        break if !opt[:wait_for_reports] || complete?
-        sleep(DTROPTIONS[:wait_a_moment]) if DTROPTIONS[:wait_a_moment]
-        break if complete?
-      end
-    ensure
-      @report_signature = nil if opt[:wait_for_reports]
-      self.latest_build_time = Time.now - @build_start_time
-    end
-    
-    def reports
-      @reports ||= {}
-    end
-
-    def client_setup_logs
-      @client_setup_logs ||= {}
-    end
-    
-    def add_client(client)
-      clients_map[client.name] = client
-      client_setup_logs[client.name] = nil
-    end
-
-    def update_setup_log(signature, report)
-      with_valid_signature(signature) do
-        client_setup_logs[report[:client_name]] = report
-        if report[:exit_code] != 0
-          clients_map.delete(report[:client_name])
-        end
-      end
-    end
-
-    def update(signature, report)
-      with_valid_signature(signature) do
-        self.reports[report.test] = report
-        @report_signature = nil if @complete = self.reports.keys.size == @test_files.size
-      end
-    end
-
-    private
-    def run_start(opt)
-      @build_start_time = Time.now
-      if test_files.nil? || test_files.empty?
-        @complete = true
-        return
-      end
-      @report_signature = @build_start_time.to_s
-      @setup_clients = opt[:setup] ? [] : nil
-    end
-    
-    def run_once
-      clients = available_clients
-      
-      logger.debug { "run tests on #{clients.collect{|c|c.name}.join(', ')}"} unless clients.empty?
-      no_report_tests = test_files - reports.keys
-      return if clients.empty? || no_report_tests.empty?
-      
-      packets = packer.pack no_report_tests, clients.size
-      clients.each do |client|
-        if @setup_clients && !@setup_clients.include?(client)
-          @setup_clients << client
-          client.setup(@report_signature)
-        end
-        client.run self.runner_name, packets.pop, @report_signature
-      end
-    end
-
-    def with_valid_signature(signature)
-      if !@report_signature.nil? && signature == @report_signature
-        yield
-        true
-      end
-    end
-
-    def collect_report(type)
-      "#{reports.values.collect{|r| r.send(type)}.inject(0){|r, i| r += i}} #{type}"
-    end
-    
-    def clients_map
-      @clients_map ||= {}
-    end
-  end
-
-  class Client
-  
-    RUNNERS = {RubyRunner.name => RubyRunner.new}
-
-    attr_reader :name
-
-    def initialize(server, name, setup_cmd=DTROPTIONS[:setup])
-      @server = server
-      @name = name
-      @executing_cmd = nil
-      @tmp_dir = DTROPTIONS[:tmp_dir]
-      @setup_cmd = setup_cmd
-    end
-
-    def idle?
-      @executing_cmd.nil?
-    end
-
-    def run(runner_name, test_files, signature)
-      RUNNERS[runner_name].run(@server, self, test_files, signature)
-    end
-
-    def setup(signature)
-      result = execute(@setup_cmd)
-      @server.update_setup_log(signature, result)
-      result
-    end
-
-    def server_signature
-      @server.server_signature
-    end
-
-    def completed_cmds
-      @completed_cmds ||= []
-    end
-
-    def execute(cmd)
-      @executing_cmd = cmd
-      
-      outputs = {:stdout => "#{@tmp_dir}/execution_stdout.log", :stderr => "#{@tmp_dir}/execution_stderr.log"}
-      outputs.values.each do |log_file|
-        File.delete log_file if File.exist? log_file
-      end
-
-      begin
-        CommandLine.execute cmd, outputs
-        exit_code = 0
-      rescue CommandLine::ExecutionError => e
-        exit_code = e.exitstatus
-      end
-
-      outputs.each_key do |key|
-        outputs[key] = File.open(outputs[key], 'r') {|f| f.read}
-      end
-
-      self.completed_cmds << cmd
-      @executing_cmd = nil
-      {:client_name => @name, :stdout => outputs[:stdout], :stderr => outputs[:stderr], :exit_code => exit_code}
-    end
-  end
-
-  class TestReport
-    attr_reader :test, :stdout, :stderr, :exit_code, :client_name, :tests, :assertions, :failures, :errors
-    def initialize(test, execution_result, tests, assertions, failures, errors)
-      @test = test
-      @client_name = execution_result[:client_name]
-      @stdout = execution_result[:stdout]
-      @stderr = execution_result[:stderr]
-      @exit_code = execution_result[:exit_code]
-      @tests = tests
-      @assertions = assertions
-      @failures = failures
-      @errors = errors
-    end
-
-    def succeeded?
-      @failures == 0 && @errors == 0
-    end
-
-    def failed?
-      @failures > 0
-    end
-
-    def error?
-      @errors > 0
-    end
-
-    def ==(another)
-      test == another.test
-    end
-    
-    def successes
-      tests - failures - errors
-    end
-  end
- end

data/lib/dtr/command_line.rb

@@ -1,173 +0,0 @@
-# borrowed (with modifications) from the RSCM project
-require 'rbconfig'
-module Platform
-  def family
-    target_os = Config::CONFIG["target_os"] or raise 'Cannot determine operating system'
-    case target_os
-    when /linux/, /Linux/ then 'linux'
-    when /32/ then 'mswin32'
-    when /darwin/ then 'powerpc-darwin'
-    when /cyg/ then 'cygwin'
-    when /solaris/ then 'solaris'
-    when /freebsd/, /netbsd/ then 'bsd'
-    else raise "Unknown OS: #{target_os}"
-    end
-  end
-  module_function :family
-
-  def user
-    family == "mswin32" ? ENV['USERNAME'] : ENV['USER']
-  end
-  module_function :user
-
-  def prompt(dir=Dir.pwd)
-    prompt = "#{dir.gsub(/\//, File::SEPARATOR)} #{user}$"
-  end
-  module_function :prompt
-
-end
-
-module CommandLine
-  QUOTE_REPLACEMENT = (Platform.family == "mswin32") ? "\"" : "\\\""
-  LESS_THAN_REPLACEMENT = (Platform.family == "mswin32") ? "<" : "\\<"
-  class OptionError < StandardError; end
-  class ExecutionError < StandardError
-    attr_reader :cmd, :dir, :exitstatus, :stderr
-    def initialize(cmd, full_cmd, dir, exitstatus, stderr)
-      @cmd, @full_cmd, @dir, @exitstatus, @stderr = cmd, full_cmd, dir, exitstatus, stderr
-    end
-    def to_s
-      "\ndir : #{@dir}\n" +
-      "command : #{@cmd}\n" +
-      "executed command : #{@full_cmd}\n" +
-      "exitstatus: #{@exitstatus}\n" +
-      "STDERR TAIL START\n#{@stderr}\nSTDERR TAIL END\n"
-    end
-  end
-
-  # Executes +cmd+.
-  # If the +:stdout+ and +:stderr+ options are specified, a line consisting
-  # of a prompt (including +cmd+) will be appended to the respective output streams will be appended
-  # to those files, followed by the output itself. Example:
-  #
-  #   CommandLine.execute("echo hello world", {:stdout => "stdout.log", :stderr => "stderr.log"})
-  #
-  # will result in the following being written to stdout.log:
-  #
-  #   /Users/aslakhellesoy/scm/buildpatterns/repos/damagecontrol/trunk aslakhellesoy$ echo hello world
-  #   hello world
-  #
-  # -and to stderr.log:
-  #   /Users/aslakhellesoy/scm/buildpatterns/repos/damagecontrol/trunk aslakhellesoy$ echo hello world
-  #
-  # If a block is passed, the stdout io will be yielded to it (as with IO.popen). In this case the output
-  # will not be written to the stdout file (even if it's specified):
-  #
-  #   /Users/aslakhellesoy/scm/buildpatterns/repos/damagecontrol/trunk aslakhellesoy$ echo hello world
-  #   [output captured and therefore not logged]
-  #
-  # If the exitstatus of the command is different from the value specified by the +:exitstatus+ option
-  # (which defaults to 0) then an ExecutionError is raised, its message containing the last 400 bytes of stderr
-  # (provided +:stderr+ was specified)
-  #
-  # You can also specify the +:dir+ option, which will cause the command to be executed in that directory
-  # (default is current directory).
-  #
-  # You can also specify a hash of environment variables in +:env+, which will add additional environment variables
-  # to the default environment.
-  #
-  # Finally, you can specify several commands within one by separating them with '&&' (as you would in a shell).
-  # This will result in several lines to be appended to the log (as if you had executed the commands separately).
-  #
-  # See the unit test for more examples.
-  def execute(cmd, options={}, &proc)
-    raise "Can't have newline in cmd" if cmd =~ /\n/
-    options = {
-      :dir => Dir.pwd.untaint,
-      :env => {},
-      :mode => 'r',
-      :exitstatus => 0
-    }.merge(options)
-
-    options[:stdout] = %{"#{File.expand_path(options[:stdout])}"}.untaint if options[:stdout]
-    options[:stderr] = %{"#{File.expand_path(options[:stderr])}"}.untaint if options[:stderr]
-
-
-    if options[:dir].nil?
-      e(cmd, options, &proc)
-    else
-      Dir.chdir(options[:dir]) do
-        e(cmd, options, &proc)
-      end
-    end
-  end
-  module_function :execute
-
-private
-
-  def full_cmd(cmd, options, &proc)
-    commands = cmd.split("&&").collect{|c| c.strip}
-    stdout_opt = options[:stdout] ? ">> #{options[:stdout]}" : ""
-    stderr_opt = options[:stderr] ? "2>> #{options[:stderr]}" : ""
-    capture_info_command = (block_given? && options[:stdout])? "echo [output captured and therefore not logged] >> #{options[:stdout]} && " : ""
-
-    full_cmd = commands.collect do |c|
-      escaped_command = c.gsub(/"/, QUOTE_REPLACEMENT).gsub(/</, LESS_THAN_REPLACEMENT)
-      stdout_prompt_command = options[:stdout] ? "echo #{Platform.prompt} #{escaped_command} >> #{options[:stdout]} && " : ""
-      stderr_prompt_command = options[:stderr] ? "echo #{Platform.prompt} #{escaped_command} >> #{options[:stderr]} && " : ""
-      redirected_command = block_given? ? "#{c} #{stderr_opt}" : "#{c} #{stdout_opt} #{stderr_opt}"
-
-      stdout_prompt_command + capture_info_command + stderr_prompt_command + redirected_command
-    end.join(" && ")
-    full_cmd.untaint
-  end
-  module_function :full_cmd
-
-  def verify_exit_code(cmd, full_cmd, options)
-    if($?.exitstatus != options[:exitstatus])
-      error_message = "#{options[:stderr]} doesn't exist"
-      if options[:stderr] && File.exist?(options[:stderr])
-        File.open(options[:stderr]) do |errio|
-          begin
-            errio.seek(-1200, IO::SEEK_END)
-          rescue Errno::EINVAL
-            # ignore - it just means we didn't have 400 bytes.
-          end
-          error_message = errio.read
-        end
-      end
-      raise ExecutionError.new(cmd, full_cmd, options[:dir] || Dir.pwd, $?.exitstatus, error_message)
-    end
-  end
-  module_function :verify_exit_code
-
-  def e(cmd, options, &proc)
-    full_cmd = full_cmd(cmd, options, &proc)
-
-    options[:env].each{|k,v| ENV[k]=v}
-    begin
-      STDOUT.puts "#{Platform.prompt} #{cmd}" if options[:stdout].nil?
-      IO.popen(full_cmd, options[:mode]) do |io|
-        if(block_given?)
-          proc.call(io)
-        else
-          io.each_line do |line|
-            STDOUT.puts line if options[:stdout].nil?
-          end
-        end
-      end
-    rescue Errno::ENOENT => e
-      unless options[:stderr].nil?
-        File.open(options[:stderr], "a") {|io| io.write(e.message)}
-      else
-        STDERR.puts e.message
-        STDERR.puts e.backtrace.join("\n")
-      end
-      raise ExecutionError.new(cmd, full_cmd, options[:dir] || Dir.pwd.untaint, nil, e.message)
-    ensure
-      verify_exit_code(cmd, full_cmd, options)
-    end
-  end
-  module_function :e
-
-end