jperkins-deep_test 1.2.2

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

data/lib/deep_test/extensions/drb_extension.rb

@@ -0,0 +1,34 @@
+module DeepTest
+  class DRbBindAllTCPSocket < DRb::DRbTCPSocket
+    def self.parse_uri(uri)
+      if uri =~ /^drubyall:\/\/(.*?):(\d+)(\?(.*))?$/
+      	host = $1
+      	port = $2.to_i
+      	option = $4
+      	[host, port, option]
+      else
+      	raise(DRb::DRbBadScheme, uri) unless uri =~ /^drubyall:/
+      	raise(DRb::DRbBadURI, 'can\'t parse uri:' + uri)
+    	end
+    end
+
+    # Open a server listening for connections at +uri+ using 
+    # configuration +config+.
+    def self.open_server(uri, config)
+      uri = 'drubyall://:0' unless uri
+      host, port, opt = parse_uri(uri)
+
+      if host.size == 0
+        host = getservername
+      end
+
+      DeepTest.logger.debug("Listening on port #{port}, all addresses.")
+	    soc = TCPServer.open('0.0.0.0', port)  	    
+      port = soc.addr[1] if port == 0
+      uri = "druby://#{host}:#{port}"
+      self.new(uri, soc, config)
+    end
+  end
+end
+
+DRb::DRbProtocol.add_protocol DeepTest::DRbBindAllTCPSocket

data/lib/deep_test/extensions/object_extension.rb

@@ -0,0 +1,40 @@
+require "stringio"
+module DeepTest
+  module ObjectExtension
+    def capture_stdout
+      old_stdout, $stdout = $stdout, StringIO.new
+      yield
+      $stdout.string
+    ensure
+      $stdout = old_stdout if old_stdout
+    end
+
+    def capture_stderr
+      old_stderr, $stderr = $stderr, StringIO.new
+      yield
+      $stderr.string
+    ensure
+      $stderr = old_stderr if old_stderr
+    end
+    
+    def retrying(description = nil, times = 5)
+      i = 0
+      loop do
+        begin
+          return yield
+        rescue => e
+          i += 1
+          print "#{description} received exception #{e}. "
+          if i < times
+            puts "Retrying..."
+            sleep 0.5
+          else
+            puts "Aborting."
+            raise e
+          end
+        end
+      end
+    end
+  end
+end
+Object.send :include, DeepTest::ObjectExtension

data/lib/deep_test/listener_list.rb

@@ -0,0 +1,17 @@
+module DeepTest
+  class ListenerList
+    attr_reader :listeners
+
+    def initialize(listeners)
+      @listeners = listeners
+    end
+
+    NullWorkerListener.instance_methods(false).each do |event|
+      eval <<-end_src
+        def #{event}(*args)
+          @listeners.each {|l| l.#{event}(*args)}
+        end
+      end_src
+    end
+  end
+end

data/lib/deep_test/local_workers.rb

@@ -0,0 +1,55 @@
+module DeepTest
+  class LocalWorkers
+    def initialize(options)
+      @options = options
+      @warlock = Warlock.new
+    end
+
+    def load_files(files)
+      files.each {|f| load f}
+    end
+
+    def server
+      @options.server
+    end
+
+    def start_all
+      each_worker do |worker_num|
+        start_worker(worker_num) do
+          reseed_random_numbers
+          reconnect_to_database
+          worker = DeepTest::Worker.new(worker_num,
+                                        server, 
+                                        @options.new_listener_list)
+          worker.run
+        end
+      end        
+    end
+
+    def stop_all
+      @warlock.stop_all
+    end
+
+    def number_of_workers
+      @options.number_of_workers
+    end
+
+    private
+
+    def reconnect_to_database
+      ActiveRecord::Base.connection.reconnect! if defined?(ActiveRecord::Base)
+    end
+
+    def start_worker(worker_num, &blk)
+      @warlock.start("worker #{worker_num}", &blk)
+    end
+
+    def reseed_random_numbers
+      srand
+    end
+
+    def each_worker
+      number_of_workers.to_i.times { |worker_num| yield worker_num }
+    end
+  end
+end

data/lib/deep_test/logger.rb

@@ -0,0 +1,17 @@
+module DeepTest
+  class Logger < ::Logger
+    def initialize(*args)
+      super
+      self.formatter = proc { |severity, time, progname, msg| "[DeepTest] #{msg}\n" }
+      self.level = configured_log_level
+    end
+
+    def configured_log_level
+      if ENV['DEEP_TEST_LOG_LEVEL']
+        Logger.const_get(ENV['DEEP_TEST_LOG_LEVEL'])
+      else
+        Logger::INFO
+      end
+    end
+  end
+end

data/lib/deep_test/marshallable_exception_wrapper.rb

@@ -0,0 +1,44 @@
+module DeepTest
+  class MarshallableExceptionWrapper
+    attr_reader :classname, :message, :backtrace
+
+    def initialize(exception)
+      @classname = exception.class.name
+      @message = exception.message
+      @backtrace = exception.backtrace
+    end
+
+    def ==(other)
+      classname == other.classname &&
+        message == other.message &&
+      backtrace == other.backtrace
+    end
+
+    def resolve
+      begin
+        klass = eval("::" + classname) 
+        resolved_message = message
+      rescue => e
+        DeepTest.logger.debug("Unable to load exception class: #{classname}: #{e.message}")
+        DeepTest.logger.debug(e.backtrace.join("\n"))
+
+        klass = UnloadableException
+        resolved_message = "#{classname}: #{message}"
+      end
+
+      begin
+        resolved_exception = klass.new resolved_message
+      rescue => e
+        DeepTest.logger.debug("Unable to instantiation exception class: #{classname}: #{e.message}")
+        DeepTest.logger.debug(e.backtrace.join("\n"))
+
+        resolved_exception = UnloadableException.new resolved_message
+      end
+
+      resolved_exception.set_backtrace backtrace
+      resolved_exception
+    end
+  end
+
+  class UnloadableException < StandardError; end
+end

data/lib/deep_test/metrics/gatherer.rb

@@ -0,0 +1,67 @@
+module DeepTest
+  module Metrics
+    class Gatherer
+      def self.setup(options)
+        $metrics_gatherer = new(options)
+
+        at_exit do
+          $metrics_gatherer.write_file
+        end
+      end
+
+      def self.enabled?
+        return false unless $metrics_gatherer
+        $metrics_gatherer.enabled?
+      end
+
+      def self.section(title, &block)
+        $metrics_gatherer.section(title, &block)
+      end
+
+      def initialize(options)
+        @options = options
+        @sections = []
+      end
+
+      def enabled?
+        !@options.metrics_file.nil?
+      end
+
+      def section(title, &block)
+        @sections << Section.new(title, &block) if enabled?
+      end
+
+      def render
+        @sections.map {|s| s.render}.join("\n")
+      end
+      
+      def write_file
+        return unless enabled?
+        File.open(@options.metrics_file, "w") do |io|
+          io << render
+        end
+      end
+
+      class Section
+        def initialize(title, &generate_measurements_block)
+          @title = title
+          @generate_measurements_block = generate_measurements_block
+        end
+
+        def measurement(name, value)
+          @measurements << [name, value]
+        end
+
+        def gather_measurements
+          @measurements = []
+          @generate_measurements_block.call(self)
+        end
+
+        def render
+          gather_measurements
+          "[#{@title}]\n" + @measurements.map {|name, value| "#{name}: #{value}"}.join("\n")
+        end
+      end
+    end
+  end
+end