jstorimer-deep-test 1.4.0 → 2.0.0

data/lib/deep_test/distributed/drb_client_connection_info.rb

@@ -1,15 +0,0 @@
-module DeepTest
-  module Distributed
-    class DRbClientConnectionInfo
-      attr_reader :address
-
-      def initialize
-        info = Thread.current['DRb']
-        raise "No DRb client found" unless info && info['client']
-        peeraddr = info['client'].peeraddr
-        DeepTest.logger.debug("DRbClientConnection info: #{peeraddr.inspect}")
-        @address = peeraddr[3]
-      end
-    end
-  end
-end

data/lib/deep_test/distributed/master_test_server.rb

@@ -1,52 +0,0 @@
-module DeepTest
-  module Distributed
-    class MasterTestServer
-      include ERB::Util
-
-      STATUS_PORT = 4020 unless defined?(STATUS_PORT)
-
-      attr_reader :servers
-
-      def initialize(servers)
-        @servers = servers
-      end
-
-      def show_status(req, res)
-        template = File.read(File.dirname(__FILE__) + "/show_status.rhtml")
-        res.body = ERB.new(template).result(binding)
-      end
-
-      def test_server_statuses
-        @servers.map do |s|
-          status = begin
-                     s.status
-                   rescue Exception => e
-                     e
-                   end
-
-          [s.__drburi, status]
-        end
-      end
-
-      def self.start(uri, server_uris)
-        master = start_drb(uri, server_uris)
-        start_http(master)
-        DeepTest.logger.info "MasterTestServer listening at #{DRb.uri}"
-        DRb.thread.join
-      end
-
-      def self.start_drb(uri, server_uris)
-        servers = server_uris.map {|server_uri| DRbObject.new_with_uri server_uri}
-        master = DeepTest::Distributed::MasterTestServer.new(servers)
-        DRb.start_service(uri, master)
-        master
-      end
-
-      def self.start_http(master)
-        s = WEBrick::HTTPServer.new :Port => STATUS_PORT
-        s.mount_proc("/", &master.method(:show_status))
-        Thread.new {s.start}
-      end
-    end
-  end
-end

data/lib/deep_test/distributed/multi_test_server_proxy.rb

@@ -1,44 +0,0 @@
-module DeepTest
-  module Distributed
-    class MultiTestServerProxy
-      def initialize(options, slaves)
-        DeepTest.logger.debug "MultiTestServerProxy#initialize #{slaves.length} slaves"
-        @slave_controller = DispatchController.new(options, slaves)
-      end
-
-      def spawn_worker_server(options)
-        DeepTest.logger.debug "dispatch spawn_worker_server for #{options.origin_hostname}"
-        WorkerServerProxy.new options,
-                              @slave_controller.dispatch(:spawn_worker_server, 
-                                                         options)
-      end
-
-      def sync(options)
-        DeepTest.logger.debug "dispatch sync for #{options.origin_hostname}"
-        @slave_controller.dispatch(:sync, options)
-      end
-
-      class WorkerServerProxy
-        def initialize(options, slaves)
-          DeepTest.logger.debug "WorkerServerProxy#initialize #{slaves.inspect}"
-          @slave_controller = DispatchController.new(options, slaves)
-        end
-
-        def load_files(files)
-          DeepTest.logger.debug "dispatch load_files"
-          @slave_controller.dispatch(:load_files, files)
-        end
-
-        def start_all
-          DeepTest.logger.debug "dispatch start_all"
-          @slave_controller.dispatch(:start_all)
-        end
-
-        def stop_all
-          DeepTest.logger.debug "dispatch stop_all"
-          @slave_controller.dispatch_with_options(:stop_all, :ignore_connection_error => true)
-        end
-      end
-    end
-  end
-end

data/lib/deep_test/distributed/null_work_unit.rb

@@ -1,12 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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/show_status.rhtml

@@ -1,41 +0,0 @@
-<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

@@ -1,78 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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