DTR 0.0.1

data/lib/dtr/base.rb

@@ -0,0 +1,281 @@
+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

@@ -0,0 +1,173 @@
+# 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