xli-dtr 0.0.4

data/lib/dtr/test_unit.rb

@@ -0,0 +1,289 @@
+# Copyright (c) 2007-2008 Li Xiao
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'dtr/base'
+require 'dtr/service_provider'
+require 'test/unit/testcase'
+require 'test/unit/util/observable'
+require 'monitor'
+require 'drb'
+require 'timeout'
+
+DTROPTIONS = {} unless defined?(DTROPTIONS)
+DTROPTIONS[:log_file] = 'dtr_master_process.log' unless DTROPTIONS[:log_file]
+
+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
+  
+  def service_provider
+    $dtr_service_provider ||= DTR::ServiceProvider.new
+  end
+
+  module_function :reject, :inject, :service_provider
+  
+  class Counter
+    
+    def initialize
+      extend MonitorMixin
+      @start_count, @finish_count = 0, 0
+      @complete_cond = new_cond
+    end
+
+    def add_start_count
+      synchronize do
+        @start_count += 1
+      end
+    end
+
+    def add_finish_count
+      synchronize do
+        @finish_count += 1
+        @complete_cond.signal
+      end
+    end
+    
+    def to_s
+      synchronize do
+        status
+      end
+    end
+    
+    def wait_until_complete
+      synchronize do
+        @complete_cond.wait_until {complete?}
+      end
+    end
+    
+    private
+    def complete?
+      DTR.info{ "Counter status: #{status}" }
+      @finish_count >= @start_count
+    end
+    
+    def status
+      "finish_count => #{@finish_count}, start_count => #{@start_count}"
+    end
+  end
+  
+  class ThreadSafeTestResult
+    include Test::Unit::Util::Observable
+    include DRbUndumped
+
+    def initialize(rs)
+      extend MonitorMixin
+      @rs = rs
+      @channels = @rs.send(:channels).dup
+      @rs.send(:channels).clear
+    end
+
+    def add_run
+      synchronize do
+        @rs.add_run
+      end  
+      notify_listeners(Test::Unit::TestResult::CHANGED, self)
+    end
+
+    def add_failure(failure)
+      synchronize do
+        @rs.add_failure(failure)
+      end  
+      notify_listeners(Test::Unit::TestResult::FAULT, failure)
+      notify_listeners(Test::Unit::TestResult::CHANGED, self)
+    end
+
+    def add_error(error)
+      synchronize do
+        @rs.add_error(error)
+      end  
+      notify_listeners(Test::Unit::TestResult::FAULT, error)
+      notify_listeners(Test::Unit::TestResult::CHANGED, self)
+    end
+
+    def add_assertion
+      synchronize do
+        @rs.add_assertion
+      end  
+      notify_listeners(Test::Unit::TestResult::CHANGED, self)
+    end
+
+    def to_s
+      synchronize do
+        @rs.to_s
+      end  
+    end
+
+    def passed?
+      synchronize do
+        @rs.passed?
+      end  
+    end
+
+    def failure_count
+      synchronize do
+        @rs.failure_count
+      end  
+    end
+    
+    def error_count
+      synchronize do
+        @rs.error_count
+      end  
+    end
+  end
+
+  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)
+    class << self
+      def counter
+        @counter ||= Counter.new
+      end
+    end
+    
+    RUN_TEST_FINISHED = "::DRbTestRunner::RUN_TEST_FINISHED"
+    DEFAULT_RUN_TEST_TIMEOUT = 60 #seconds
+    
+    def initialize(test, result, &progress_block)
+      @test = test
+      @result = result
+      @progress_block = progress_block
+      
+      DRbTestRunner.counter.add_start_count
+    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
+          Timeout.timeout(ENV['RUN_TEST_TIMEOUT'] || DEFAULT_RUN_TEST_TIMEOUT) do
+            runner.run(@test, @result, &@progress_block)
+          end
+          @progress_block.call(RUN_TEST_FINISHED, @test.name)
+        rescue Timeout::Error => e
+          DTR.info {"Run test timeout(#{ENV['RUN_TEST_TIMEOUT'] || DEFAULT_RUN_TEST_TIMEOUT}), reboot runner"}
+          runner.reboot rescue nil
+          DTR.info {"rerun test: #{@test.name}"}
+          self.run
+        rescue DRb::DRbConnError => e
+          DTR.info {"DRb::DRbConnError(#{e.message}), rerun test: #{@test.name}"}
+          self.run
+        rescue Exception => e
+          DTR.info{ "#{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 = DTR.service_provider.lookup_runner
+      begin
+        DTR.debug {"#{runner.name}.env ==?: #{WorkingEnv.current[:identifier] == runner.identifier}"}
+        return runner if runner.identifier == WorkingEnv.current[:identifier]
+        runner.shutdown
+      rescue DRb::DRbConnError => e
+        DTR.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)
+          DTR.debug {"start of run TestCase(#{name})"}
+          DRbTestRunner.new(self, result, &progress_block).run
+          DTR.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)
+          DTR.info { "start of run suite(#{name}), size: #{size};"}
+          
+          if result.kind_of?(ThreadSafeTestResult)
+            __run__(result, &progress_block)
+          else
+            if defined?(ActiveRecord::Base)
+              ActiveRecord::Base.clear_active_connections! rescue nil
+            end
+            
+            DTR.service_provider.setup_working_env WorkingEnv.refresh
+            
+            puts 'Refreshed dtr working environment, looking for runner service...' unless ENV['DTR_ENV'] == 'test'
+            DTR.info {"Master process started at #{Time.now}"}
+            result = ThreadSafeTestResult.new(result)
+            __run__(result) do |channel, value|
+              DTR.debug { "=> channel: #{channel}, value: #{value}" }
+              progress_block.call(channel, value)
+              if channel == DTR::DRbTestRunner::RUN_TEST_FINISHED
+                DRbTestRunner.counter.add_finish_count
+              end
+            end
+            DRbTestRunner.counter.wait_until_complete
+            DTR.debug { "==> teardown" }
+            DTR.service_provider.teardown_working_env
+          end
+          DTR.info { "end of run suite(#{name}), test result status: #{result}, counter status: #{DRbTestRunner.counter}"}
+        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/test_unit_injection.rb

@@ -0,0 +1,19 @@
+# Copyright (c) 2007-2008 Li Xiao
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'dtr/service_provider'
+require 'dtr/test_unit'
+$argv_dup = ARGV.dup.delete_if{|f| f.include?('dtr/test_unit_injection')}
+
+DTR.inject

data/lib/dtr.rb

@@ -0,0 +1,111 @@
+# Copyright (c) 2007-2008 Li Xiao
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+DTRVERSION="0.0.4"
+DTROPTIONS = {} unless defined?(DTROPTIONS)
+
+require 'fileutils'
+
+module DTR
+
+  def start_server
+    require 'dtr/service_provider'
+    ServiceProvider.new.start
+  end
+  
+  def start_runners
+    launch_runners(DTROPTIONS[:names], DTROPTIONS[:setup])
+  end
+  
+  def launch_runners(names, setup=nil)
+    require 'dtr/runner'
+    names = names || "DTR(#{Time.now})"
+    DTR::RunnerAgent.start(names, setup)
+  end
+  
+  def lib_path
+    File.expand_path(File.dirname(__FILE__))
+  end
+  
+  def broadcast_list=(list)
+    require 'dtr/service_provider'
+    ServiceProvider.broadcast_list = list
+  end
+  
+  def port=(port)
+    require 'dtr/service_provider'
+    ServiceProvider.port = port 
+  end
+  
+  def runners
+    require 'dtr/service_provider'
+    ServiceProvider.new.runners
+  end
+  
+  def monitor
+    require 'dtr/service_provider'
+    DTROPTIONS[:log_file] = 'dtr_monitor.log'
+    ServiceProvider.new.monitor
+  end
+  
+  def stop_runners_daemon_mode
+    with_daemon_gem do
+      Daemons.run_proc "dtr_runners", :ARGV => ['stop'] 
+    end
+  end
+  
+  def start_runners_daemon_mode
+    with_daemon_gem do
+      FileUtils.rm_rf('dtr_runners.output')
+      pwd = Dir.pwd
+      Daemons.run_proc "dtr_runners", :ARGV => ['start'], :backtrace => true  do
+        Dir.chdir(pwd) do
+          start_runners
+        end
+      end
+    end
+  end
+  
+  def start_server_daemon_mode
+    with_daemon_gem do
+      Daemons.run_proc "dtr_server", :ARGV => ['start'] do
+        start_server
+      end
+    end
+    sleep(2)
+  end
+  
+  def stop_server_daemon_mode
+    with_daemon_gem do
+      Daemons.run_proc "dtr_server", :ARGV => ['stop']
+    end
+  end
+  
+  def with_daemon_gem
+    require "rubygems"
+    begin
+      require "daemons"
+    rescue LoadError
+      raise "The daemons gem must be installed"
+    end
+    yield
+  end
+  
+  def clean_server
+    require 'dtr/service_provider'
+    ServiceProvider.new.clear_workspace
+  end
+  
+  module_function :start_server, :start_runners, :launch_runners, :lib_path, :broadcast_list=, :runners, :with_daemon_gem, :start_runners_daemon_mode, :stop_runners_daemon_mode, :start_server_daemon_mode, :stop_server_daemon_mode, :monitor, :port=, :clean_server
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: xli-dtr
+version: !ruby/object:Gem::Version 
+  version: 0.0.4
+platform: ruby
+authors: 
+- Li Xiao
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-13 00:00:00 -07:00
+default_executable: dtr
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: daemons
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 1.0.7
+    version: 
+description: 
+email: iam@li-xiao.com
+executables: 
+- dtr
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/dtr/base.rb
+- lib/dtr/raketasks.rb
+- lib/dtr/runner.rb
+- lib/dtr/service_provider.rb
+- lib/dtr/test_unit.rb
+- lib/dtr/test_unit_injection.rb
+- lib/dtr.rb
+- bin/dtr
+- bin
+- CHANGES
+- doc
+- dtr.gemspec
+- install.rb
+- lib
+- LICENSE.TXT
+- Rakefile
+- README
+- TODO
+has_rdoc: false
+homepage: http://github.com/xli/dtr/tree/master
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: dtr
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: DTR is a distributed test runner to run tests on distributed computers for decreasing build time.
+test_files: []
+