jstorimer-deep-test 1.4.0 → 2.0.0

data/lib/deep_test/distributed/throughput_statistics.rb

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

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

@@ -1,34 +0,0 @@
-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/local_workers.rb

@@ -1,55 +0,0 @@
-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/metrics/gatherer.rb

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

data/lib/deep_test/metrics/queue_lock_wait_time_measurement.rb

@@ -1,133 +0,0 @@
-module DeepTest
-  module Metrics
-    module QueueLockWaitTimeMeasurement
-      attr_reader :total_pop_time, :total_push_time
-
-      def self.extended(o)
-        o.instance_eval do
-          alias pop_without_lock_wait_measurement pop
-          alias pop pop_with_lock_wait_measurement
-
-          alias push_without_lock_wait_measurement push
-          alias push push_with_lock_wait_measurement
-        end
-      end
-
-      def pop_with_lock_wait_measurement(no_wait = false)
-        if no_wait
-          return measure(:add_pop_time) do
-            pop_without_lock_wait_measurement(no_wait)
-          end
-        else
-          begin
-            # Measure without waiting to minimize extra time added
-            # above locking time
-            #
-            return measure(:add_pop_time) do
-              pop_without_lock_wait_measurement(true)
-            end
-          rescue ThreadError => e
-            if e.message == "queue empty"
-              # Normally we would have waiting for a condvar signal,
-              # so don't penalize time for locking here again - hence
-              # no measure
-              return pop_without_lock_wait_measurement(false)
-            else
-              raise
-            end
-          end
-        end
-      end
-
-      def push_with_lock_wait_measurement(value)
-        measure(:add_push_time) do
-          push_without_lock_wait_measurement(value)
-        end
-      end
-
-      def measure(accumulator)
-        start_time = Time.now
-        result = yield
-        send(accumulator, Time.now - start_time)
-        result
-      end
-
-      def add_push_time(time)
-        Thread.exclusive do
-          @total_push_time ||= 0
-          @total_push_time += time
-        end
-      end
-
-      def add_pop_time(time)
-        Thread.exclusive do
-          @total_pop_time ||= 0
-          @total_pop_time += time
-        end
-      end
-    end
-  end
-end
-
-
-if $0 == __FILE__
-  require 'thread'
-  require 'timeout'
-
-  thread_count = (ARGV[0] || 10).to_i
-  action_count = (ARGV[1] || 100).to_i
-
-  def test_measurement(thread_count, action_count)
-    q = Queue.new
-    q.extend DeepTest::Metrics::QueueLockWaitTimeMeasurement
-
-    threads = []
-    thread_count.times do
-      threads << Thread.new do
-        action_count.times do |i|
-          show_progress ".", action_count, i
-          q.push 1
-        end
-      end
-    end
-
-    thread_count.times do
-      threads << Thread.new do
-        action_count.times do |i|
-          show_progress "-", action_count, i
-          if rand(2) == 0
-            begin
-              q.pop(true)
-            rescue ThreadError
-            end
-          else
-            begin
-              Timeout.timeout(0.01) do
-                q.pop
-              end
-            rescue Timeout::Error
-              break
-            end
-          end
-        end
-      end
-    end
-
-    threads.each {|t| t.join}
-
-    puts
-    puts "Push Time: #{q.total_push_time}"
-    puts "Pop Time:  #{q.total_pop_time}"
-  end
-
-  def show_progress(s, total, current)
-    if (current % (total / 5)) == 0
-      $stdout.print s
-      $stdout.flush
-    end
-  end
-
-  start_time = Time.now
-  test_measurement(thread_count, action_count)
-  puts "Total Run Time:  #{Time.now - start_time}"
-end

data/lib/deep_test/option.rb

@@ -1,60 +0,0 @@
-module DeepTest
-  class Option
-    attr_reader :name, :default
-
-    def initialize(name, type, default)
-      @name, @type, @default = name, type, default
-    end
-
-    def from_command_line(command_line)
-      command_line =~ /--#{name} (\S+)(\s|$)/
-      @type.from_string($1) if $1
-    end
-
-    def to_command_line(value)
-      "--#{name} #{@type.to_string(value)}" if value && value != default
-    end
-
-    module Hash
-      def self.to_string(hash)
-        pairs = []
-        hash.each do |key, value|
-          value = value.gsub(/ /,'%20') if (::String === value)
-          pairs << "#{key}:#{value.inspect}"
-        end
-        pairs.join(",")
-      end
-
-      def self.from_string(string)
-        hash = {}
-        string.split(/,/).each do |pair|
-          key, unevaled_value = pair.split(/:/)
-          value = eval(unevaled_value)
-          value = value.gsub(/%20/, " ") if ::String === value
-          hash[key.to_sym] = value
-        end
-        hash
-      end
-    end
-
-    module Integer
-      def self.to_string(i)
-        i.to_s
-      end
-
-      def self.from_string(s)
-        s.to_i
-      end
-    end
-
-    module String
-      def self.to_string(s)
-        s
-      end
-
-      def self.from_string(s)
-        s
-      end
-    end
-  end
-end

data/lib/deep_test/process_orchestrator.rb

@@ -1,49 +0,0 @@
-module DeepTest
-  class ProcessOrchestrator
-    def self.run(options, workers, runner)
-      new(options, workers, runner).run
-    end
-    
-    def initialize(options, workers, runner)
-      @options = options
-      @runner = runner
-      @workers = workers
-    end
-    
-    def run(exit_when_done = true)
-      passed = false
-
-      begin
-        server = Server.start(@options)
-        @options.new_listener_list.before_starting_workers
-        @workers.start_all
-        begin
-          DeepTest.logger.debug "Loader Starting (#{$$})"
-          passed = @runner.process_work_units
-        ensure
-          shutdown(server)
-        end
-      ensure
-        DeepTest.logger.debug "ProcessOrchestrator: Stopping Server"
-        Server.stop
-      end
-
-      Kernel.exit(passed ? 0 : 1) if exit_when_done
-    end
-
-    def shutdown(server)
-      DeepTest.logger.debug "ProcessOrchestrator: Shutting Down"
-      server.done_with_work
-
-      first_exception = $!
-      begin
-        DeepTest.logger.debug "ProcessOrchestrator: Stopping Workers"
-        @workers.stop_all
-      rescue DRb::DRbConnError
-        # Workers must have already stopped
-      rescue Exception => e
-        raise first_exception || e
-      end
-    end
-  end
-end