jason-o-matic-deep_test 1.2.2.1

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

data/lib/deep_test/metrics/queue_lock_wait_time_measurement.rb

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