DTR 0.0.1 → 0.0.2

data/lib/dtr/env_store.rb

@@ -0,0 +1,58 @@
+require 'dtr/ruby_ext'
+require 'pstore'
+module DTR
+  class EnvStore
+
+    FILE_NAME = '.dtr_env_pstore'
+
+    def self.destroy
+      File.delete(FILE_NAME) if File.exist?(FILE_NAME)
+    end
+
+    def [](key)
+      return nil unless File.exist?(FILE_NAME)
+      
+      repository = PStore.new(FILE_NAME)
+      repository.transaction(true) do
+        repository[key]
+      end
+    end
+
+    def []=(key, value)
+      repository = PStore.new(FILE_NAME)
+      repository.transaction do
+        repository[key] = value
+      end
+    end
+  end
+
+  class WorkingEnv
+  
+    @@current = nil
+    def self.refresh
+      @@current = self.new
+    end
+    
+    def self.current
+      @@current
+    end
+    
+    def initialize
+      @env = {:libs => $LOAD_PATH.dup, :files => $argv_dup.dup, :revision => $repository.revision, :created_at => Time.now.to_s}
+    end
+    
+    def [](key)
+      @env[key]
+    end
+    
+    def ==(another)
+      return false if another.nil?
+      return self[:libs] == another[:libs] && self[:files] == another[:files] && self[:revision] == another[:revision]
+    end
+    
+    def to_s
+      @env.inspect
+    end
+    
+  end
+end

data/lib/dtr/inject.rb

@@ -0,0 +1,155 @@
+require 'test/unit/testcase'
+require 'monitor'
+require 'dtr/runner'
+
+def service_provider
+  $dtr_service_provider ||= DTR::ServiceProvider.new
+end
+
+module DTR
+  def reject
+    return unless Test::Unit::TestSuite.method_defined?(:dtr_injected?)
+    Test::Unit::TestCase.send(:include, Rejection)
+    Test::Unit::TestSuite.send(:include, Rejection)
+  end
+  
+  def inject
+    return if Test::Unit::TestSuite.method_defined?(:dtr_injected?)
+    Test::Unit::TestCase.send(:include, TestCaseInjection)
+    Test::Unit::TestSuite.send(:include, TestSuiteInjection)
+  end
+  
+  module_function :reject, :inject
+  
+  class DRbTestRunner
+    
+    # because some test case will rewrite TestCase#run to ignore some tests, which
+    # makes TestResult#run_count different with TestSuite#size, so we need to count
+    # by ourselves.(for example: ActionController::IntegrationTest)
+    @@run_count = 0
+    
+    RUN_TEST_FINISHED = "::DRbTestRunner::RUN_TEST_FINISHED"
+    
+    def self.done?(run_count)
+      @@run_count == run_count
+    end
+    
+    def self.start
+      @@run_count = 0
+    end
+    
+    def initialize(test, result, &progress_block)
+      @test = test
+      @result = result
+      @progress_block = progress_block
+      
+      @@run_count += 1
+    end
+    
+    def run
+      if runner = lookup_runner
+        run_test_on(runner)
+      else
+        self.run
+      end
+    end
+    
+    def run_test_on(runner)
+      Thread.start do
+        begin
+          runner.run(@test, @result, &@progress_block)
+          @progress_block.call(RUN_TEST_FINISHED, @test.name)
+        rescue DRb::DRbConnError => e
+          logger.debug {"DRb::DRbConnError(#{e.message}), rerun test: #{@test.name}"}
+          self.run
+        rescue Exception => e
+          logger.debug {"#{test.name}, rescue an exception: #{e.message}, add error into result."}
+          @result.add_error(Test::Unit::Error.new(@test.name, e))
+          @result.add_run
+          @progress_block.call(Test::Unit::TestCase::FINISHED, @test.name)
+          @progress_block.call(RUN_TEST_FINISHED, @test.name)
+        end
+      end
+    end
+    
+    def lookup_runner
+      runner = service_provider.lookup_runner
+      begin
+        logger.debug {"#{runner.name}.env ==?: #{WorkingEnv.current == runner.working_env}"}
+        return runner if runner.working_env == WorkingEnv.current
+        runner.shutdown
+      rescue DRb::DRbConnError => e
+        logger.debug {"DRb::DRbConnError(#{e.message})"}
+      end
+      nil
+    end
+  end
+  
+  module TestCaseInjection
+    
+    def self.included(base)
+      base.class_eval do
+        alias_method :__run__, :run
+
+        def run(result, &progress_block)
+          logger.debug {"start of run TestCase(#{name})"}
+          DRbTestRunner.new(self, result, &progress_block).run
+          logger.debug {"end of run TestCase(#{name})"}
+        end
+      end
+    end  
+  end
+
+  module TestSuiteInjection
+    def self.included(base)
+      base.class_eval do
+        def dtr_injected?
+          true
+        end
+
+        alias_method :__run__, :run
+        
+        def run(result, &progress_block)
+          logger.debug { "start of run suite(#{name}), size: #{size};"}
+          
+          if result.respond_to?(:synchronize)
+            __run__(result, &progress_block)
+          else
+            DRbTestRunner.start
+            service_provider.setup_working_env WorkingEnv.refresh
+            
+            @result = result.extend(MonitorMixin)
+            @complete_cond = @result.new_cond
+            __run__(result) do |channel, value|
+              @result.synchronize do
+                logger.debug { "=> channel: #{channel}, value: #{value}" }
+                progress_block.call(channel, value)
+                if channel == DTR::DRbTestRunner::RUN_TEST_FINISHED
+                  @complete_cond.signal
+                end
+              end
+            end
+            logger.debug {"Wait until all tests finished"}
+            @result.synchronize do
+              @complete_cond.wait_until {DRbTestRunner.done?(@result.run_count)}
+            end
+            logger.debug { "==> teardown" }
+            service_provider.teardown_working_env
+          end
+          logger.debug { "end of run suite(#{name}), run_count: #{result.run_count}"}
+        end
+      end
+    end
+  end
+  
+  module Rejection
+    def self.included(base)
+      base.class_eval do
+        remove_method :dtr_injected? if base.method_defined?(:dtr_injected?)
+        remove_method :run
+        alias_method :run, :__run__
+        remove_method :__run__
+      end
+    end
+  end
+end

data/lib/dtr/inject_with_svn.rb

@@ -0,0 +1,8 @@
+require 'dtr/service_provider'
+require 'dtr/svn'
+require 'dtr/inject'
+
+$repository = DTR::SvnRepository.new
+$argv_dup = ARGV.dup.delete_if{|f| f.include?('dtr/inject_with_svn.rb')}
+
+DTR.inject

data/lib/dtr/inject_without_updating_codebase.rb

@@ -0,0 +1,6 @@
+require 'dtr/service_provider'
+require 'dtr/inject'
+$repository = NullObject.new
+$argv_dup = ARGV.dup.delete_if{|f| f.include?('dtr/inject_without_updating_codebase.rb')}
+
+DTR.inject

data/lib/dtr/raketasks.rb

@@ -0,0 +1,48 @@
+require "rubygems"
+require 'dtr'
+require 'rake/testtask'
+
+module DTR
+  class MPTask < Rake::TestTask
+    attr_accessor :processes
+    
+    def define
+      @libs.unshift DTR.lib_path
+      lib_path = @libs.join(File::PATH_SEPARATOR)
+
+      desc "Run tests" + (@name==:test ? "" : " for #{@name}")
+      task @name do
+        DTR.start_server_daemon_mode
+        start_runners
+        run_code = ''
+        begin
+          RakeFileUtils.verbose(@verbose) do
+            run_code = rake_loader
+            @ruby_opts.unshift( "-I#{lib_path}" )
+            @ruby_opts.unshift( "-w" ) if @warning
+
+            ruby @ruby_opts.join(" ") +
+              " \"#{run_code}\" " +
+              file_list.unshift('dtr/inject_without_updating_codebase.rb').collect { |fn| "\"#{fn}\"" }.join(' ') +
+              " #{option_list}"
+          end
+        ensure
+          DTR.stop_runners_daemon_mode rescue nil
+          DTR.stop_server_daemon_mode rescue nil
+        end
+      end
+      self
+    end
+    
+    def processes
+      @processes ? @processes.to_i : 2
+    end
+    
+    private
+    def start_runners
+      runner_names = []
+      self.processes.to_i.times {|i| runner_names << "runner#{i}"}
+      %x[dtr -r #{runner_names.join(',')} -D]
+    end
+  end
+end

data/lib/dtr/ruby_ext.rb

@@ -1,27 +1,5 @@
-
-class Array
-  DEFAULT_ACL = %w(deny all)
-  def to_acl_list
-    self << "druby://localhost"
-    self << "druby://127.0.0.1"
-    addresses = self.collect do |uri|
-      if /^druby:\/\/([^:]+):?\d*$/ =~ uri
-        $1
-      end
-    end.compact.uniq
-    acl_list = addresses.inject([]) do |result, address|
-      result << 'allow'
-      result << address
-      result
-    end
-  end
-
-  def to_acl
-    ACL.new(DEFAULT_ACL + to_acl_list)
-  end
-end
-
-class NullObj
-  def method_missing(*args)
+class NullObject
+  def method_missing(method, *args, &block)
+    nil
   end
 end

data/lib/dtr/runner.rb

@@ -0,0 +1,174 @@
+require 'test/unit'
+require 'dtr/svn'
+require 'dtr/env_store'
+require 'drb'
+
+unless defined?(logger)
+  require 'logger'
+  def logger
+    return $logger if defined?($logger) && $logger
+    $logger = Logger.new(STDOUT) 
+    $logger.level = $DEBUG ? Logger::DEBUG : Logger::ERROR
+    $logger
+  end
+end
+
+module DTR
+  
+  def service_provider
+    require 'dtr/service_provider'
+    ServiceProvider.new
+  end
+  
+  module_function :service_provider
+
+  class RunnerProtectProcess
+    
+    def self.start(runner_names=["Distributed Test Runner"], setup_cmd=nil)
+      new(runner_names, setup_cmd).launch
+    end
+    
+    def initialize(runner_names, setup_cmd)
+      @runner_names = runner_names.is_a?(Array) ? runner_names : [runner_names.to_s]
+      @setup_cmd = setup_cmd
+      @repository = SvnRepository.new
+      @runner_pids = []
+      @herald = nil
+      @working_env_key = :working_env
+      at_exit {
+        [@herald].concat(@runner_pids).each{ |pid| Process.kill 'TERM', pid rescue nil }
+        puts "Shut down runner protect process."
+        exit!
+      }
+    end
+    
+    def launch
+      puts "=> Runner protect process started at: #{Dir.pwd}"
+      loop do
+        @herald = drb_fork{ Herald.new @working_env_key }
+        Process.wait @herald
+        
+        working_env = EnvStore.new[@working_env_key]
+        interrupt_if_exit_with_error @repository.update_to(working_env[:revision])
+        interrupt_if_exit_with_error @setup_cmd
+
+        @runner_pids = @runner_names.collect { |name| drb_fork {Runner.start name, working_env} }
+        Process.waitall
+
+        @runner_pids = []
+        puts "=> Runner protect process wakes up"
+      end
+    end
+    
+    private
+    def interrupt_if_exit_with_error(cmd)
+      logger.debug { "executing: #{cmd.inspect}" }
+      return if cmd.nil? || cmd.empty?
+      output = %x[#{cmd}]
+      logger.debug { "output: \n#{output}" }
+      raise Interrupt.new(output) if $?.exitstatus != 0
+    end
+    
+    def drb_fork
+      Process.fork do
+        Signal.trap('TERM') {
+          DRb.stop_service
+          exit
+        }
+        yield
+      end
+    end
+  end
+  
+  class Herald
+    
+    def initialize(key)
+      require 'dtr/service_provider'
+      @key = key
+      EnvStore.new[@key] = nil
+      @provider = DTR.service_provider
+      puts "=> Herald starts off..."
+      start_off
+    end
+    
+    def start_off
+      working_env = @provider.working_env
+      logger.debug { "working env: #{working_env.inspect}" }
+      if working_env[:files].empty?
+        $stderr.puts "No test files need to load?(working env: #{working_env.inspect})"
+        sleep(2)
+        start_off
+      else
+        EnvStore.new[@key] = working_env
+        @provider.stop_service
+      end
+    end
+  end
+  
+  class Runner
+    include DRbUndumped
+    
+    def self.start(name, env)
+      puts "=> Initialize working environment..."
+      env[:libs].select{ |lib| !$LOAD_PATH.include?(lib) && File.exists?(lib) }.each do |lib|
+        $LOAD_PATH << lib
+        logger.debug {"appended lib: #{lib}"}
+      end
+      logger.debug {"$LOAD_PATH: #{$LOAD_PATH.inspect}"}
+      
+      require 'dtr/inject'
+      DTR.inject
+      
+      env[:files].each do |f|
+        begin
+          load f unless f =~ /^-/
+          logger.debug {"loaded #{f}"}
+        rescue LoadError => e
+          $stderr.puts "No such file to load -- #{f} (Environment: #{env.inspect})"
+        end
+      end
+
+      @provider = DTR.service_provider
+
+      @provider.provide(self.new(@provider, name, env))
+      puts "=> Runner #{name} provided"
+      DRb.thread.join if DRb.thread
+    end
+    
+    attr_reader :name, :working_env
+    
+    def initialize(provider, name, working_env)
+      Test::Unit.run = true
+      @name = name
+      @provider = provider
+      @working_env = working_env
+    end
+    
+    def run(test, result, &progress_block)
+      print "#{name} is running #{test}..."
+      if test.respond_to?(:__run__)
+        begin
+          test.__run__(result, &progress_block)
+          return true
+        ensure
+          puts "Done"
+          @provider.provide(self)
+        end
+      else
+        msg = "#{test} is not respond_to :__run__!"
+        puts "Error: #{msg}"
+        @provider.stop_service
+        return false
+      end
+    end
+    
+    def shutdown
+      puts "#{self} is shutting down"
+      @provider.stop_service rescue exit!
+    end
+    
+    def to_s
+      "Runner #{@name}"
+    end
+  end
+end