dtr 0.0.3

data/lib/dtr/service_provider.rb

@@ -0,0 +1,160 @@
+# 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 'drb'
+require 'rinda/ring'
+require 'rinda/tuplespace'
+require 'socket'
+
+module DTR
+  def decorate_error_message(msg, source=nil)
+    source ? "#{source} from #{Socket.gethostname}: #{msg}" : "From #{Socket.gethostname}: #{msg}"
+  end
+  
+  module_function :decorate_error_message
+
+  class RunnerRuntimeException < StandardError
+    def initialize(e)
+      super(DTR.decorate_error_message(e.message, e.class.name))
+      set_backtrace(e.backtrace)
+    end
+  end
+
+  class ServiceProvider
+  
+    def self.broadcast_list=(list)
+      EnvStore.new[:broadcast_list] = list
+    end
+    
+    def self.port=(port)
+      EnvStore.new[:port] = port
+    end
+    
+    PORT = 3344
+    BROADCAST_LIST = []
+    
+    def initialize
+      DTR.info "-- Initializing drb service..."
+      env_store = EnvStore.new
+      (env_store[:broadcast_list] || ['localhost']).each do |broadcast|
+        BROADCAST_LIST << broadcast.untaint
+        DTR.info "-- Added broadcast: #{broadcast}"
+      end
+      DTR.info "-- Server port: #{server_port}"
+      DRb.start_service
+    end
+    
+    # start DTR server
+    def start
+      env_store = EnvStore.new
+      DTR.info '-- Booting DTR server...'
+      Rinda::RingServer.new Rinda::TupleSpace.new, server_port
+      DTR.info "-- DTR server started on port #{server_port}"
+      #set safe level to 1 here, now, runner can't set to 1, cause test should can do anything
+      #......
+      $SAFE = 1 unless $DEBUG   # disable eval() and friends
+      # Wait until the user explicitly kills the server.
+      DRb.thread.join
+    end
+    
+    def provide(runner)
+      renewer = Rinda::SimpleRenewer.new
+      tuple = [:name, 'DTR::Runner'.to_sym, runner.freeze, "DTR remote runner #{Process.pid}-#{runner.name}"]
+      lookup_ring.write(tuple, renewer)
+    end
+    
+    def send_message(message)
+      lookup_ring.write [:agent_heartbeat, Socket.gethostname, message, Time.now], 2
+    end
+    
+    def lookup_runner
+      lookup_ring.take([:name, 'DTR::Runner'.to_sym, nil, nil])[2]
+    end
+    
+    def runners
+      lookup_ring.read_all([:name, 'DTR::Runner'.to_sym, nil, nil]).collect {|rt| rt[2]}
+    end
+    
+    def monitor
+      working_env_monitor = lookup_ring.notify(nil, [:working_env, nil])
+      Thread.start do
+        DTR.info("Current work environment: #{working_env.inspect}")
+        working_env_monitor.each { |t| DTR.info t.inspect }
+      end
+      if DTROPTIONS[:log_level] == Logger::DEBUG
+        runner_monitor = lookup_ring.notify(nil, [:name, 'DTR::Runner'.to_sym, nil, nil])
+        Thread.start do
+          runner_monitor.each { |t| DTR.debug t.inspect }
+        end
+      end
+      agent_heartbeat_monitor = lookup_ring.notify("write", [:agent_heartbeat, nil, nil, nil])
+      Thread.start do
+        colors = {}
+        base = 30
+        agent_heartbeat_monitor.each do |t|
+          host, message, time = t[1][1..3]
+          colors[host] = base+=1 unless colors[host]
+          message = "\e[1;31m#{message}\e[0m" if message =~ /-ERROR\]/
+          DTR.info "#{time.strftime("[%I:%M:%S%p]")} \e[1;#{colors[host]};1m#{host}\e[0m: #{message}"
+        end
+      end
+      DRb.thread.join
+    end
+    
+    def wait_until_teardown
+      lookup_ring.notify(nil, [:working_env, nil]).pop
+    end
+
+    def working_env
+      lookup_ring.read([:working_env, nil])[1]
+    end
+    
+    def setup_working_env(env)
+      clear_workspace
+      lookup_ring.write [:working_env, env]
+    end
+    
+    def teardown_working_env
+      clear_workspace
+    end
+
+    def start_service
+      DRb.start_service
+    end
+    
+    def stop_service
+      DRb.stop_service
+    end
+    
+    def clear_workspace
+      lookup_ring.read_all([:working_env, nil]).size.times do
+        lookup_ring.take [:working_env, nil] rescue nil
+      end rescue nil
+      runners.size.times do
+        lookup_runner.shutdown rescue nil
+      end
+    end
+
+    private
+    def server_port
+      env_store = EnvStore.new
+      env_store[:port].to_i > 0 ? env_store[:port].to_i : PORT
+    end
+
+    def lookup_ring
+      Rinda::TupleSpaceProxy.new(Rinda::RingFinger.new(BROADCAST_LIST, server_port).lookup_ring_any)
+    end
+  end
+end

data/lib/dtr/test_unit.rb

@@ -0,0 +1,278 @@
+# 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'
+
+DTROPTIONS = {} unless defined?(DTROPTIONS)
+
+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 if complete?
+      end
+    end
+    
+    def to_s
+      synchronize do
+        status
+      end
+    end
+    
+    def wait_until_complete
+      synchronize do
+        @complete_cond.wait_until {complete?} unless complete?
+      end
+    end
+    
+    private
+    def complete?
+      DTR.debug {"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"
+    
+    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
+          runner.run(@test, @result, &@progress_block)
+          @progress_block.call(RUN_TEST_FINISHED, @test.name)
+        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.debug { "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 DTR.silent?
+            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.debug { "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