jstorimer-deep-test 0.2.0 → 1.0.0

data/lib/deep_test/distributed/null_work_unit.rb

@@ -0,0 +1,12 @@
+module DeepTest
+  module Distributed
+    #
+    # Work Unit used to measure throughput of workers.
+    #
+    class NullWorkUnit
+      def run
+        :null_work_unit_result
+      end
+    end
+  end
+end

data/lib/deep_test/distributed/remote_worker_client.rb

@@ -0,0 +1,54 @@
+module DeepTest
+  module Distributed
+    class RemoteWorkerClient
+      def initialize(options, test_server, failover_workers)
+        @failover_workers = failover_workers
+        @options = options
+        @test_server = test_server
+      end
+
+      def load_files(filelist)
+        @options.new_listener_list.before_sync
+
+        t = Thread.new do
+          @test_server.sync(@options)
+          @worker_server = @test_server.spawn_worker_server(@options)
+          @worker_server.load_files filelist
+        end
+
+        filelist.each {|f| load f}
+
+        begin
+          t.join
+        rescue => e
+          # The failover here doesn't invoke load_files on the failover_workers
+          # because they will be LocalWorkers, which fork from the current 
+          # process.  The fact that we depend in this here is damp...
+          #
+          fail_over("load_files", e)
+        end
+      end
+
+      def start_all
+        @worker_server.start_all
+      rescue => e
+        raise if failed_over?
+        fail_over("start_all", e)
+        retry
+      end
+
+      def stop_all
+        @worker_server.stop_all
+      end
+
+      def fail_over(method, exception)
+        @options.ui_instance.distributed_failover_to_local(method, exception)
+        @worker_server = @failover_workers
+      end
+
+      def failed_over?
+        @worker_server == @failover_workers
+      end
+    end
+  end
+end

data/lib/deep_test/distributed/remote_worker_server.rb

@@ -0,0 +1,82 @@
+module DeepTest
+  module Distributed
+    class RemoteWorkerServer
+      include DRb::DRbUndumped
+
+      MERCY_KILLING_GRACE_PERIOD = 10 * 60 unless defined?(MERCY_KILLING_GRACE_PERIOD)
+
+      def initialize(base_path, workers)
+        @base_path = base_path
+        @workers = workers
+      end
+
+      def launch_mercy_killer(grace_period)
+        Thread.new do
+          sleep grace_period
+          exit(0) unless workers_started?
+        end
+      end
+
+      def load_files(files)
+        Dir.chdir @base_path
+        resolver = FilenameResolver.new(@base_path)
+        files.each do |file|
+          load resolver.resolve(file)
+        end
+      end
+
+      def start_all
+        @workers_started = true
+        @workers.start_all
+      end
+
+      def stop_all
+        Thread.new do
+          @workers.stop_all
+        end
+      end
+
+      def workers_started?
+        @workers_started
+      end
+
+      def self.warlock
+        @warlock ||= DeepTest::Warlock.new
+      end
+
+      def self.running_server_count
+        @warlock.demon_count if @warlock
+      end
+
+      def self.stop_all
+        @warlock.stop_all if @warlock
+      end
+
+      def self.start(address, base_path, workers, grace_period = MERCY_KILLING_GRACE_PERIOD)
+        innie, outie = IO.pipe
+
+        warlock.start("RemoteWorkerServer") do
+          innie.close
+
+          server = new(base_path, workers)
+
+          DRb.start_service("drubyall://#{address}:0", server)
+          DeepTest.logger.info "RemoteWorkerServer started at #{DRb.uri}"
+
+          outie.write DRb.uri
+          outie.close
+
+          server.launch_mercy_killer(grace_period)
+
+          DRb.thread.join
+        end
+
+        outie.close
+        uri = innie.gets
+        innie.close
+        DRbObject.new_with_uri(uri)
+      end
+
+    end
+  end
+end

data/lib/deep_test/distributed/rsync.rb

@@ -1,48 +1,35 @@
 module DeepTest
   module Distributed
     class RSync
-      def self.push(address, sync_options, destination)
-        sync(:push, address, sync_options, destination)
-      end
-
-      def self.sync(operation, address, sync_options, destination)
-        command = Args.new(address, sync_options).send("#{operation}_command", 
-                                                  destination)
-
-        DeepTest.logger.debug { "rsycing: #{command}" }
+      def self.sync(connection_info, options, destination)
+        command = Args.new(connection_info, options).command(destination)
+        DeepTest.logger.debug("rsycing: #{command}")
         successful = system command
         raise "RSync Failed!!" unless successful
       end
 
       class Args
-        def initialize(address, sync_options)
-          @address = address
-          @sync_options = sync_options
-        end
-
-        def pull_command(destination)
-          command remote_location(@sync_options[:source]), destination
-        end
-
-        def push_command(destination)
-          command @sync_options[:source], remote_location(destination)
+        def initialize(connection_info, options)
+          @connection_info = connection_info
+          @options = options
+          @sync_options = options.sync_options
         end
 
-        def command(source, destination)
+        def command(destination)
           # The '/' after source tells rsync to copy the contents
           # of source to destination, rather than the source directory
           # itself
-          "rsync -az --delete #{@sync_options[:rsync_options]} #{DeepTest::LIB_ROOT} #{source} #{destination}".strip.squeeze(" ")
+          "rsync -az --delete #{@sync_options[:rsync_options]} #{source_location}/ #{destination}".strip.squeeze(" ")
         end
 
-        def remote_location(path)
+        def source_location
           source = ""
           unless @sync_options[:local]
             source << @sync_options[:username] << '@' if @sync_options[:username]
-            source << @address
+            source << @connection_info.address
             source << (@sync_options[:daemon] ? '::' : ':')
           end
-          source << path
+          source << @sync_options[:source]
         end
       end
     end

data/lib/deep_test/distributed/show_status.rhtml

@@ -0,0 +1,41 @@
+<html>
+  <head>
+    <title>DeepTest Test Server Status</title>
+    <style>
+      .ok {
+        background-color: #AAFFAA;
+      }
+
+      .error {
+        background-color: #FFAAAA;
+      }
+
+    </style>
+  </head>
+  <body>
+    <h1>DeepTest Test Server Status</h1>
+    <table>
+      <tr>
+        <th>Mirror Server</th>
+        <th>Bound To</th>
+        <th>Workers / Client</th>
+        <th>Clients</th>
+      </tr>
+      <% test_server_statuses.each do |uri, status|
+           if Exception === status %>
+             <tr class="error">
+               <td><%=h uri %></td>
+               <td colspan="3"><%=h status.message %></td>
+             </tr>
+        <% else %>
+             <tr class="ok">
+               <td><%=h uri %></td>
+               <td><%=h status.binding_uri %></td>
+               <td><%=h status.number_of_workers %></td>
+               <td><%=h status.remote_worker_server_count %></td>
+             </tr>
+       <% end
+         end %>
+    </table>
+  </body>
+</html> 

data/lib/deep_test/distributed/test_server.rb

@@ -0,0 +1,78 @@
+module DeepTest
+  module Distributed
+    class TestServer
+      DEFAULT_CONFIG = {
+        :work_dir => "/tmp",
+        :uri => "drubyall://:4022",
+        :number_of_workers => 2
+      } unless defined?(DEFAULT_CONFIG)
+
+      def initialize(config)
+        @config = config
+      end
+
+      def spawn_worker_server(options)
+        DeepTest.logger.debug("mirror spawn_worker_server for #{options.origin_hostname}")
+        RemoteWorkerServer.start(URI.parse(@config[:uri]).host,
+                                 options.mirror_path(@config[:work_dir]),
+                                 TestServerWorkers.new(options, @config, DRbClientConnectionInfo.new))
+      end
+
+      def status
+        TestServerStatus.new(
+          DRb.uri, 
+          @config[:number_of_workers],
+          RemoteWorkerServer.running_server_count
+        )
+      end
+
+      def sync(options)
+        DeepTest.logger.debug "mirror sync for #{options.origin_hostname}"
+        path = options.mirror_path(@config[:work_dir])
+        DeepTest.logger.debug "Syncing #{options.sync_options[:source]} to #{path}"
+        RSync.sync(DRbClientConnectionInfo.new, options, path)
+      end
+
+      def servers
+        [DRbObject.new_with_uri(DRb.uri)]
+      end
+
+      def self.start(config)
+        server = DeepTest::Distributed::TestServer.new(config)
+        DRb.start_service(config[:uri], server)
+        DeepTest.logger.info "TestServer listening at #{DRb.uri}"
+        DRb.thread.join
+      end
+
+      def self.parse_args(args)
+        options = DeepTest::Distributed::TestServer::DEFAULT_CONFIG.dup
+        OptionParser.new do |opts|
+          opts.banner = "Usage: deep_test test_server [options]"
+
+          opts.on("--work_dir PATH", "Absolute path to keep mirror working copies at") do |v|
+            options[:work_dir] = v
+          end
+
+          opts.on("--uri URI", "DRb URI to bind server to") do |v|
+            options[:uri] = v
+          end
+
+          opts.on("--number_of_workers NUM", "Number of workers to start when running tests") do |v|
+            options[:number_of_workers] = v.to_i
+          end
+
+          opts.on_tail("-h", "--help", "Show this message") do
+            puts opts
+            exit
+          end
+        end.parse(args)
+        options
+      end
+
+      def self.connect(options)
+        servers = DRbObject.new_with_uri(options.distributed_server).servers
+        MultiTestServerProxy.new(options, servers)
+      end
+    end
+  end
+end

data/lib/deep_test/distributed/test_server_status.rb

@@ -0,0 +1,9 @@
+module DeepTest
+  module Distributed
+    TestServerStatus = Struct.new(
+      :binding_uri,
+      :number_of_workers,
+      :remote_worker_server_count
+    ) unless defined?(TestServerStatus)
+  end
+end

data/lib/deep_test/distributed/test_server_workers.rb

@@ -0,0 +1,24 @@
+module DeepTest
+  module Distributed
+    class TestServerWorkers < LocalWorkers
+      def initialize(options, test_server_config, connection_info)
+        super(options)
+        @test_server_config = test_server_config
+        @connection_info = connection_info
+      end
+      
+      def number_of_workers
+        @test_server_config[:number_of_workers]
+      end
+
+      def server
+        Server.remote_reference(@connection_info.address, @options.server_port)
+      end
+
+      def start_all
+        super
+        @warlock.exit_when_none_running
+      end
+    end
+  end
+end

data/lib/deep_test/distributed/throughput_runner.rb

@@ -0,0 +1,42 @@
+module DeepTest
+  module Distributed
+    class ThroughputRunner
+      def initialize(options, test_count, blackboard = nil, &block)
+        @options = options
+        @test_count = test_count
+        @blackboard = blackboard
+        @progress_block = block
+      end
+
+      def blackboard
+        @blackboard ||= @options.server
+      end
+
+      def statistics
+        ThroughputStatistics.new(@test_count, @start_time, @end_time)
+      end
+
+      def process_work_units
+        @start_time = Time.now
+
+        @test_count.times do
+          blackboard.write_work NullWorkUnit.new
+        end
+ 
+        results_read = 0
+        until results_read == @test_count
+          Thread.pass
+          result = blackboard.take_result
+          if result
+            results_read += 1 
+            @progress_block.call(result) if @progress_block
+          end
+        end
+
+        @end_time = Time.now
+
+        true
+      end
+    end
+  end
+end

data/lib/deep_test/distributed/throughput_statistics.rb

@@ -0,0 +1,26 @@
+module DeepTest
+  module Distributed
+    class ThroughputStatistics
+      attr_reader :test_count, :start_time, :end_time
+
+      def initialize(test_count, start_time, end_time)
+        @test_count, @start_time, @end_time = test_count, start_time, end_time
+      end
+
+      def timespan_in_seconds
+        @end_time.to_f - @start_time.to_f
+      end
+
+      def tests_per_second
+        @test_count / timespan_in_seconds
+      end
+
+      def summary
+        <<-end_summary
+#{test_count} tests run in #{timespan_in_seconds} seconds
+(#{tests_per_second} tests / second)
+        end_summary
+      end
+    end
+  end
+end

data/lib/deep_test/distributed/throughput_worker_client.rb

@@ -0,0 +1,19 @@
+module DeepTest
+  module Distributed
+    class ThroughputWorkerClient
+      def initialize(options, test_server)
+        @options = options
+        @test_server = test_server
+      end
+
+      def start_all
+        @worker_server = @test_server.spawn_worker_server(@options)
+        @worker_server.start_all
+      end
+
+      def stop_all
+        @worker_server.stop_all
+      end
+    end
+  end
+end