jason-o-matic-deep_test 1.2.2.4 → 1.2.2.5

data/lib/deep_test.rb

@@ -88,3 +88,5 @@ require File.dirname(__FILE__) + "/deep_test/test"
 
 require File.dirname(__FILE__) + "/deep_test/ui/console"
 require File.dirname(__FILE__) + "/deep_test/ui/null"
+
+require File.expand_path(File.dirname(__FILE__) + "/deep_test/drbfire.rb")

data/lib/deep_test/distributed/dispatch_controller.rb

@@ -19,7 +19,13 @@ module DeepTest
           Thread.new do
             Thread.current[:receiver] = r
             Timeout.timeout(@options.timeout_in_seconds) do
-              r.send method_name, *args
+              begin
+                DeepTest.logger.debug "Dispatching to #{r.inspect}: #{method_name}(*#{args.inspect})"
+                r.send method_name, *args
+              rescue Exception => ex
+                DeepTest.logger.debug "DISPATCH EXCEPTION from #{r.inspect}: #{ex.message}\n#{ex.backtrace.join("\n")}"
+                raise
+              end
             end
           end
         end
@@ -38,7 +44,7 @@ module DeepTest
             end
           rescue Exception => e
             @receivers.delete t[:receiver]
-            DeepTest.logger.error "Exception while dispatching #{method_name} to #{t[:receiver].__drburi} #{e.message}"
+            DeepTest.logger.error "Exception while dispatching #{method_name} to #{t[:receiver].__drburi} #{e.message}\n#{e.backtrace.join("\n")}"
           end
         end
 

data/lib/deep_test/distributed/multi_test_server_proxy.rb

@@ -1,6 +1,7 @@
 module DeepTest
   module Distributed
     class MultiTestServerProxy
+      
       def initialize(options, slaves)
         DeepTest.logger.debug "MultiTestServerProxy#initialize #{slaves.length} slaves"
         @slave_controller = DispatchController.new(options, slaves)
@@ -27,7 +28,11 @@ module DeepTest
       end
 
       class WorkerServerProxy
+        
+        attr_reader :slaves
+        
         def initialize(options, slaves)
+          @slaves = slaves
           DeepTest.logger.debug "WorkerServerProxy#initialize #{slaves.inspect}"
           @slave_controller = DispatchController.new(options, slaves)
         end

data/lib/deep_test/distributed/remote_worker_client.rb

@@ -13,6 +13,12 @@ module DeepTest
         t = Thread.new do
           @test_server.sync(@options)
           @worker_server = @test_server.spawn_worker_server(@options)
+          
+          @worker_server.slaves.each do |s|
+            DeepTest.logger.debug "Startng the DRb service to connect to: #{s.inspect}"
+            DRb.start_service(s.__drburi, nil, DRbFire::ROLE => DRbFire::CLIENT)
+          end
+          
           @worker_server.load_files filelist
         end
 
@@ -29,7 +35,13 @@ module DeepTest
         end
       end
 
-      def start_all
+      def start_all(drbserver)
+        
+        @worker_server.slaves.each do |s|
+          DeepTest.logger.debug "Remote worker client start_all sending Server reference to RemoteWorkerServer: #{s.inspect}"
+          s.drbserver = drbserver
+        end
+        
         @worker_server.start_all
       rescue => e
         raise if failed_over?

data/lib/deep_test/distributed/remote_worker_server.rb

@@ -5,6 +5,8 @@ module DeepTest
       include DRb::DRbUndumped
 
       MERCY_KILLING_GRACE_PERIOD = 10 * 60 unless defined?(MERCY_KILLING_GRACE_PERIOD)
+      
+      attr_accessor :uri
 
       def initialize(base_path, workers, options)
         @base_path = base_path
@@ -56,7 +58,7 @@ module DeepTest
 
       def start_all
         @workers_started = true
-        @workers.start_all
+        @workers.start_all(self)
       end
 
       def stop_all
@@ -88,10 +90,13 @@ module DeepTest
           innie.close
 
           server = new(base_path, workers, options)
-
-          DRb.start_service("drubyall://#{address}:0", server)
+          
+          # this is half the magic that lets us work through the NAT
+          DRb.start_service("drbfire://#{address}:0", server, DRbFire::ROLE => DRbFire::SERVER, DRbFire::DELEGATE => DRbBindAllTCPSocket)
           DeepTest.logger.info "RemoteWorkerServer started at #{DRb.uri}"
 
+          server.uri = DRb.uri
+          
           outie.write DRb.uri
           outie.close
 
@@ -105,6 +110,21 @@ module DeepTest
         innie.close
         DRbObject.new_with_uri(uri)
       end
+      
+      ######################################################################################
+      # These methods allow us to proxy the Server through the NAT
+      ######################################################################################
+      def drbserver=(drbserver)
+        DeepTest.logger.debug "Setting the Server remote reference to: #{drbserver.inspect}"
+        @drbserver = drbserver
+      end
+      def take_work
+        DeepTest.logger.debug "Remote worker server proxying 'take_work' back to Server"
+        @drbserver.take_work
+      end
+      def write_result(res)
+        @drbserver.write_result res
+      end
 
     end
   end

data/lib/deep_test/distributed/test_server_workers.rb

@@ -11,11 +11,25 @@ module DeepTest
         @test_server_config[:number_of_workers]
       end
 
+      # Here we use DRb to communicate with the RemoteWorkerServer to avoid multiple processes
+      # trying to use the same drbfire connection.  We have the RemoteWorkerServer proxy the
+      # interaction with Server since the RemoteServerWorker can connect back to the Server trough a NAT.
       def server
-        Server.remote_reference(@connection_info.address, @options.server_port)
+        # we're in a new process (one of the workers on the test_server),
+        # so stop the old server from RemoteWorkerServer
+        DRb.stop_service
+        
+        # since RemoteWorkerServer now uses drbfire, we use it here to communicate with it
+        DRb.start_service(@server_proxy.uri, nil, DRbFire::ROLE => DRbFire::CLIENT)
+        
+        DeepTest.logger.debug "LocalWorkers start_all worker starting with with blackboard: #{@server_proxy.uri.inspect} #{@server_proxy.inspect}"
+        
+        # finally, return a remote reference to the RemoteWorkerServer
+        DRbObject.new_with_uri(@server_proxy.uri)
       end
 
-      def start_all
+      def start_all(server_proxy)
+        @server_proxy = server_proxy
         super
         @warlock.exit_when_none_running
       end

data/lib/deep_test/extensions/drb_extension.rb

@@ -15,6 +15,9 @@ module DeepTest
     # Open a server listening for connections at +uri+ using 
     # configuration +config+.
     def self.open_server(uri, config)
+      
+      DeepTest.logger.debug "drubyall open_server with args: #{uri.inspect} #{config.inspect}"
+      
       uri = 'drubyall://:0' unless uri
       host, port, opt = parse_uri(uri)
 
@@ -27,6 +30,12 @@ module DeepTest
       port = soc.addr[1] if port == 0
       uri = "druby://#{host}:#{port}"
       self.new(uri, soc, config)
+      
+    rescue Exception => e
+      unless DRb::DRbBadURI === e or DRb::DRbBadScheme === e
+        DeepTest.logger.debug "drubyall open_server exception: #{e.message}\n#{e.backtrace.join("\n")}"
+      end
+      raise
     end
   end
 end

data/lib/deep_test/local_workers.rb

@@ -1,5 +1,6 @@
 module DeepTest
   class LocalWorkers
+    
     def initialize(options)
       @options = options
       @warlock = Warlock.new
@@ -8,12 +9,12 @@ module DeepTest
     def load_files(files)
       files.each {|f| load f}
     end
-
+    
     def server
       @options.server
     end
 
-    def start_all
+    def start_all(s)
       each_worker do |worker_num|
         start_worker(worker_num) do
           reseed_random_numbers

data/lib/deep_test/process_orchestrator.rb

@@ -16,10 +16,10 @@ module DeepTest
       begin
         server = Server.start(@options)
         @options.new_listener_list.before_starting_workers
-        @workers.start_all
+        @workers.start_all(server)
         begin
           DeepTest.logger.debug "Loader Starting (#{$$})"
-          passed = @runner.process_work_units
+          passed = @runner.process_work_units(server)
         ensure
           shutdown(server)
         end

data/lib/deep_test/server.rb

@@ -1,9 +1,16 @@
 module DeepTest
   class Server
+    include DRbUndumped
+    
     def self.start(options)
       server = new(options)
-      DRb.start_service("druby://0.0.0.0:#{options.server_port}", server)
-      DeepTest.logger.info "Started DeepTest service at #{DRb.uri}"
+      
+      # start_sevice if running locally, otherise we only want to use the RemoteWorkerClient connection
+      if options.distributed_server.nil?
+        DRb.start_service("drbfire://0.0.0.0:#{options.server_port}", server, DRbFire::ROLE => DRbFire::SERVER)
+        DeepTest.logger.info "Started DeepTest service at #{DRb.uri}"
+      end
+      
       server
     end
 
@@ -12,8 +19,8 @@ module DeepTest
     end
 
     def self.remote_reference(address, port)
-      DRb.start_service
-      blackboard = DRbObject.new_with_uri("druby://#{address}:#{port}")
+      DRb.start_service("drbfire://#{address}:#{port}", nil, DRbFire::ROLE => DRbFire::CLIENT)
+      blackboard = DRbObject.new_with_uri("drbfire://#{address}:#{port}")
       DeepTest.logger.debug "Connecting to DeepTest server at #{blackboard.__drburi}"
       blackboard
     end

data/lib/deep_test/test/runner.rb

@@ -12,9 +12,9 @@ module DeepTest
         @options = options
       end
 
-      def process_work_units
+      def process_work_units(server)
         suite = ::Test::Unit::AutoRunner::COLLECTORS[:objectspace].call NO_FILTERS
-        supervised_suite = DeepTest::Test::SupervisedTestSuite.new(suite, @options.server)
+        supervised_suite = DeepTest::Test::SupervisedTestSuite.new(suite, server)
         require 'test/unit/ui/console/testrunner'
         result = ::Test::Unit::UI::Console::TestRunner.run(supervised_suite, ::Test::Unit::UI::NORMAL)
         result.passed?

data/lib/deep_test/worker.rb

@@ -28,9 +28,13 @@ module DeepTest
       end
     rescue Server::NoWorkUnitsRemainingError
       DeepTest.logger.debug("Worker #{number}: no more work to do")
+    rescue Exception => e
+      DeepTest.logger.debug "Worker #{number} EXCEPTION: #{e.message}\n#{e.backtrace.join("\n")}"
+      raise
     end
 
     def next_work_unit
+      DeepTest.logger.debug "Worker #{number} getting next work unit from: #{@blackboard.inspect}"
       @blackboard.take_work
     rescue Server::NoWorkUnitsAvailableError
       sleep 0.02

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jason-o-matic-deep_test
 version: !ruby/object:Gem::Version 
-  version: 1.2.2.4
+  version: 1.2.2.5
 platform: ruby
 authors: 
 - anonymous z, Dan Manges, David Vollbracht