micron 0.5.0

data/lib/micron/runner/liveness_checker/pong.rb

@@ -0,0 +1,36 @@
+module Micron
+  class Runner
+    class LivenessChecker
+
+      class Pong
+
+        include Debug
+
+        attr_reader :thread
+
+        def initialize(reader, writer)
+          @thread = Thread.new(reader, writer) { |reader, writer|
+
+            Thread.current[:name] = "ponger"
+            debug "thread started"
+
+            begin
+              writer.sync = true
+              while line = reader.readline
+                debug "got ping request, replying"
+                writer.puts "pong"
+              end
+
+            rescue Exception => ex
+              debug "caught error: #{Micron.dump_ex(ex)}"
+            end
+
+            debug "thread exiting from #{$$}"
+          }
+        end
+
+      end # Pong
+
+    end
+  end
+end

data/lib/micron/runner/method.rb

@@ -0,0 +1,124 @@
+
+require 'hitimes'
+
+module Micron
+  class Runner
+    class Method
+
+      attr_reader :clazz, :name, :durations
+      attr_accessor :passed, :ex, :assertions
+      attr_reader :stdout, :stderr
+
+      def initialize(clazz, name)
+        @passed    = false
+        @durations = {}
+        @assertions = 0
+
+        @clazz     = clazz
+        @name      = name
+      end
+
+      def run
+        out, err = Micron.capture_io {
+          run_test()
+        }
+        @stdout = out
+        @stderr = err
+        nil
+      end
+
+      # Execute the actual test
+      def run_test
+        t = nil
+
+        begin
+          t = clazz.create
+          if t.respond_to? :micron_method= then
+            t.micron_method = self # minitest compat shim
+          end
+
+          time(:setup)   { setup(t) }
+
+          time(:runtime) { t.send(name) }
+          self.passed = true
+
+        rescue *PASSTHROUGH_EXCEPTIONS
+          raise
+
+        rescue Exception => e
+          self.passed = false
+          self.ex     = ExceptionInfo.new(e)
+
+        ensure
+          self.assertions += t._assertions if not t.nil?
+          time(:teardown) {
+            teardown(t) if not t.nil?
+          }
+        end
+      end
+
+      def passed?
+        passed
+      end
+
+      def skipped?
+        ex.kind_of?(Skip)
+      end
+
+      def failed?
+        !passed
+      end
+
+      def status
+        if skipped? then
+          "skip"
+        elsif passed? then
+          "pass"
+        else
+          "fail"
+        end
+      end
+
+      # Get the total duration of this method's run (setup + runtime + teardown)
+      def total_duration
+        n = 0.0
+        @durations.values.each{ |d| n += d }
+        n
+      end
+
+
+      private
+
+      # Time the given block of code and enter it into the log
+      def time(name, &block)
+        @durations[name] = Hitimes::Interval.measure(&block)
+      end
+
+      # Call setup methods
+      def setup(t)
+        t.before_setup
+        t.setup
+        t.after_setup
+      end
+
+      # Call teardown methods
+      def teardown(t)
+        %w{before_teardown teardown after_teardown}.each do |hook|
+          begin
+            t.send(hook)
+          rescue *PASSTHROUGH_EXCEPTIONS
+            raise
+          rescue Exception => e
+            self.passed = false
+            if self.ex.nil? then
+              self.ex = e
+            else
+              self.ex = [ self.ex, ExceptionInfo.new(e) ].flatten!
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/micron/runner/parallel_clazz.rb

@@ -0,0 +1,135 @@
+
+require "thwait"
+
+require "micron/runner/process_reaper"
+
+module Micron
+  class Runner
+
+    # Base class for parallel Clazz implementations
+    class ParallelClazz < Clazz
+
+      def run
+        # spawn tests in separate processes
+        tests = []
+        debug "spawning #{methods.size} methods"
+        methods.each do |method|
+          tests << spawn_test(method)
+        end
+
+        # wait for all test methods to return
+        @methods = wait_for_tests(tests)
+
+        # collect results
+        # @methods = collect_results(finished)
+        debug "collected #{@methods.size} methods"
+      end
+
+
+      private
+
+      # Wait for all test processes to complete, rerunning failures if needed
+      #
+      # @param [ForkWorker] tests
+      #
+      # @return [Array<Method>]
+      def wait_for_tests(tests)
+
+        # OUT.puts "waiting for tests"
+
+        results = []
+        watchers = []
+        hang_watchers = []
+
+        test_queue = Queue.new
+        tests.each { |t| test_queue.push(t) }
+
+        meta_watcher = Thread.new {
+          # thread which will make sure we're watching all tests, including
+          # any that get respawned
+          Thread.current[:name] = "meta_watcher"
+
+          while true
+            test = test_queue.pop # blocking
+            debug "creating watcher for #{test.pid}"
+
+            watchers << Thread.new(test) { |test|
+              Thread.current[:name] = "watcher-#{test.pid}"
+              debug "start"
+
+              while true
+                begin
+                  status = test.wait2.to_i
+                  # puts "process #{test.pid} exited with status #{status}"
+
+                  if status == 0 then
+                    method = collect_result(test)
+                    Micron.runner.report(:end_method, method)
+                    results << method
+
+                  elsif status == 6 || status == 4 || status == 9 then
+                    # segfault/coredump due to coverage
+                    # puts "process #{test.pid} returned error"
+                    method = test.context
+                    test_queue << spawn_test(method) # new watcher thread will be spawned
+                    debug "respawned failed test: #{method.clazz.name}##{method.name}"
+
+                  else
+                    debug
+                    debug "== UNKNOWN ERROR! =="
+                    debug "STATUS: #{status}"
+                    if !test.stdout.empty? then
+                      debug "STDOUT:"
+                      debug test.stdout
+                    else
+                      debug "NO STDOUT"
+                    end
+                    if !test.stderr.empty? then
+                      debug "STDERR:"
+                      debug test.stderr
+                    else
+                      debug "NO STDERR"
+                    end
+
+                  end
+
+                rescue Errno::ECHILD
+                  debug "retrying wait2"
+                  next # retry - should get cached status
+
+                rescue Exception => ex
+                  debug "caught: #{Micron.dump_ex(ex)}"
+                end
+
+                break # break loop by default
+              end
+
+
+              debug "exit thread"
+              watchers.delete(Thread.current)
+            }
+
+            # create another thread to make sure the process didn't hang after
+            # throwing an error on stderr
+            hang_watchers << ProcessReaper.create(test)
+          end
+
+          debug "exiting"
+        }
+
+        while !watchers.empty? || !test_queue.empty?
+          watchers.reject!{ |w| !w.alive? } # prune dead threads
+          ThreadsWait.all_waits(*watchers)
+        end
+        debug "all watcher threads finished for #{self.name}"
+        meta_watcher.kill
+        hang_watchers.each{ |t| t.kill }
+
+        return results
+      end
+
+    end
+
+  end
+end
+

data/lib/micron/runner/proc_clazz.rb

@@ -0,0 +1,48 @@
+
+module Micron
+  class Runner
+
+    # A Clazz implementation which will fork/exec before running each test method
+    class ProcClazz < ParallelClazz
+
+      private
+
+      # Spawn a process for the given method
+      #
+      # @param [Method] method
+      # @param [Boolean] dispose_output       If true, throw away stdout/stderr (default: true)
+      #
+      # @return [Hash]
+      def spawn_test(method, dispose_output=true)
+        # fork/exec once per method, synchronously
+        ENV["MICRON_TEST_CLASS"] = method.clazz.name
+        ENV["MICRON_TEST_METHOD"] = method.name.to_s
+
+        ForkWorker.new(method) {
+          exec("bundle exec micron --runmethod")
+        }.run
+      end
+
+      # Because we fork exec, we can't just read the back from a pipe. Instead,
+      # the child process dumps it to a file and we load it from there.
+      #
+      # @param [ForkWorker] test
+      #
+      # @return [Method]
+      def collect_result(test)
+        results = []
+        data_file = File.join(ENV["MICRON_PATH"], "#{test.pid}.data")
+
+        File.open(data_file) do |f|
+          while !f.eof
+            results << Marshal.load(f) # read Method from child via file
+          end
+        end
+        File.delete(data_file)
+
+        return results.first # should always be just one
+      end
+
+    end
+  end
+end

data/lib/micron/runner/process_reaper.rb

@@ -0,0 +1,98 @@
+
+module Micron
+  class Runner
+    class ProcessReaper
+
+      extend Debug
+
+      def self.create(test)
+        Thread.new(test) { |test|
+
+          Thread.current[:name] = "reaper-#{test.pid}"
+          debug "started"
+
+          err = 0
+          sel = 0
+          open = false
+          while true
+
+            if test.wait_nonblock then
+              # process exited!
+              break
+            end
+
+            begin
+
+              if err > 10 then # should wait about 3 sec for the proc to exit
+                debug "Unleash the reaper!!"
+                Process.kill(9, test.pid)
+                break
+              end
+
+              if !open then
+                if IO.select([test.err], nil, nil, 1).nil? then
+                  sel += 1
+                  debug "select = #{sel}"
+                  # if sel > 3 then
+                  #   # thread dead??
+                  #   debug "not ready yet?! Unleash the reaper!! #{test.pid}"
+                  #   Process.kill(9, test.pid)
+                  #   break
+                  # end
+                  err += 1 if err > 0
+                  debug "err = #{err}"
+                  Thread.pass
+                  next
+                end
+                debug "opened err io"
+                open = true
+              end
+
+              str = test.err.read_nonblock(1024*16)
+              debug str if !str.nil?
+              if !str.nil? &&
+                (str.include?("malloc: *** error for object") ||
+                 str.include?("Segmentation fault")) then
+
+                debug "looks like we got an error"
+                err = 1
+              end
+
+            rescue EOFError
+              debug "caught EOFError"
+              err = 1
+              # see if it exited
+              if test.wait_nonblock then
+                # exited, we're all good..
+                debug "hang watcher exiting since it looks like process exited also"
+                break
+              end
+
+            rescue Errno::EWOULDBLOCK
+              # debug "would block?!"
+              open = false
+              next
+
+            rescue Exception => ex
+              debug "caught another ex?!"
+              debug Micron.dump_ex(ex, true)
+              err = 1
+
+            end
+
+            if err > 0 then
+              err += 1
+              sleep 0.1
+            end
+
+          end
+
+          reapers.delete(Thread.current)
+          debug "thread exiting"
+        }
+
+      end
+
+    end
+  end
+end

data/lib/micron/runner/shim.rb

@@ -0,0 +1,68 @@
+
+require "tempfile"
+
+module Micron
+  class Runner
+    class Shim
+
+      # Create a temp shim path
+      def self.setup
+
+        ruby_path = `which ruby`.strip
+        shim = <<-EOF
+#!#{ruby_path}
+
+if ENV["BUNDLE_GEMFILE"] then
+  require "bundler"
+  Bundler.setup(:default, :development)
+end
+
+require "easycov"
+
+EasyCov.path = ENV["EASYCOV_PATH"]
+EasyCov.filters << EasyCov::IGNORE_GEMS << EasyCov::IGNORE_STDLIB
+EasyCov.start
+EasyCov.install_exit_hook()
+
+script = ARGV.shift
+$0 = script
+require script
+EOF
+
+        @shim_dir = Dir.mktmpdir("micron-shim-")
+        file = File.join(@shim_dir, "ruby")
+        File.open(file, 'w') do |f|
+          f.write(shim)
+        end
+        File.chmod(0777, file)
+        EasyCov::Filters.stdlib_paths # make sure this gets cached in env
+
+      end # setup
+
+      # Clean up any existing shim dirs. This should be called only when the
+      # master process exists (i.e. Micron::App)
+      def self.cleanup!
+        # return
+        Dir.glob(File.join(Dir.tmpdir, "micron-shim-*")).each do |d|
+          FileUtils.rm_rf(d)
+        end
+      end
+
+      # Wrap the given call with our shim PATH. Any calls to ruby will be
+      # redirected to our script to enable coverage collection.
+      def self.wrap(&block)
+        # enable shim
+        ENV["EASYCOV_PATH"] = EasyCov.path
+        old_path = ENV["PATH"]
+        ENV["PATH"] = "#{@shim_dir}:#{old_path}"
+
+        # call orig method
+        block.call()
+
+        # disable shim
+        ENV["PATH"] = old_path
+      end
+
+    end
+  end
+end