micron 0.5.0

data/lib/micron/runner/backtrace_filter.rb

@@ -0,0 +1,39 @@
+
+module Micron
+
+  # Default backtrace filter
+  #
+  # This can be swapped out by setting Micron::Runner.backtrace_filter
+  # to a block, proc, lambda, or a class with a #call method.
+  class BacktraceFilter
+
+    def call(bt)
+      return ["No backtrace"] unless bt and !bt.empty?
+
+      new_bt = []
+
+      unless $DEBUG then
+
+        if bt.first =~ %r{^/.*?/lib/micron/test_case/assertions.rb:\d+:in} then
+          # first line is an assertion, pop it off
+          bt.shift
+        end
+
+        bt.each do |line|
+          break if line =~ %r{(bin|lib)/micron}
+          new_bt << line
+        end
+
+        # make sure we didn't remove everything - if we did, the error was in our code
+        new_bt = bt.reject { |line| line =~ %r{(bin|lib)/micron} } if new_bt.empty?
+        new_bt = bt.dup if new_bt.empty?
+      else
+        new_bt = bt.dup
+      end
+
+      new_bt
+    end
+
+  end
+
+end

data/lib/micron/runner/clazz.rb

@@ -0,0 +1,45 @@
+
+module Micron
+  class Runner
+    class Clazz
+
+      include Debug
+
+      attr_reader :name, :methods
+
+      def initialize(clazz, file)
+        @name = clazz.to_s
+        @file = file
+        @methods = test_methods.map { |m| Method.new(self, m) }
+      end
+
+      # Create a new instance of the Class represented by this object
+      def create
+        name_to_const.new
+      end
+
+      def run
+        methods.each do |method|
+          method.run
+          Micron.runner.report(:end_method, method)
+        end
+      end
+
+
+      private
+
+      def test_methods
+        create.public_methods.find_all { |m|
+          m.to_s =~ /^test_/
+        }
+      end
+
+      def name_to_const
+        Module.const_get(name)
+      end
+
+    end
+  end
+end
+
+require "micron/runner/clazz19" if RUBY_VERSION =~ /1.9/

data/lib/micron/runner/clazz19.rb

@@ -0,0 +1,24 @@
+
+module Micron
+  class Runner
+    class Clazz
+
+      private
+
+      # Compat fix for Ruby 1.9.x
+      def name_to_const
+
+        names = name.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        constant = Module
+        names.each do |name|
+          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+        end
+
+        return constant
+      end
+
+    end
+  end
+end

data/lib/micron/runner/debug.rb

@@ -0,0 +1,22 @@
+
+module Micron
+  class Runner
+    module Debug
+
+      def debug(str="")
+
+        return
+
+        name = Thread.current[:name] || ""
+        if !name.empty? then
+          name = "[#{name} #{$$}] "
+        else
+          name = "[#{$$}]"
+        end
+
+        puts "#{name} #{str}"
+      end
+
+    end
+  end
+end

data/lib/micron/runner/exception_info.rb

@@ -0,0 +1,16 @@
+
+module Micron
+  class Runner
+    class ExceptionInfo
+
+      attr_reader :name, :message, :backtrace
+
+      def initialize(ex)
+        @name      = ex.class.to_s
+        @message   = ex.message
+        @backtrace = ex.backtrace
+      end
+
+    end
+  end
+end

data/lib/micron/runner/fork_worker.rb

@@ -0,0 +1,185 @@
+
+require "micron/runner/debug"
+require "micron/runner/liveness_checker"
+
+module Micron
+  class Runner
+
+    # Fork Worker
+    #
+    # @example
+    #   fw = Micron::Runner::ForkWorker.new do
+    #     system("ls")
+    #     "sup"
+    #   end
+    #   fw.run.wait
+    #   puts fw.stdout
+    #   puts fw.result # => sup
+    #
+    class ForkWorker
+
+      include Debug
+
+      CHUNK_SIZE = 1024 * 16
+
+      attr_reader :pid, :context, :status
+
+      def initialize(context=nil, capture_stdout=true, capture_stderr=true, &block)
+        @context        = context
+        @capture_stdout = capture_stdout
+        @capture_stderr = capture_stderr
+        @block          = block
+        @done           = false
+      end
+
+      def run(check_liveness=false)
+        @out, @err = IO.pipe, IO.pipe
+        @parent_read, @child_write = IO.pipe
+        @child_write.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+
+        @liveness_checker = LivenessChecker.new if check_liveness
+
+        @pid = fork do
+
+          Thread.current[:name] = "worker"
+          Micron.trap_thread_dump()
+
+          # close unused readers in child
+          @out.first.close
+          @err.first.close
+          @parent_read.close
+
+          # redirect io
+          STDOUT.reopen(@out.last) if @capture_stdout
+          STDERR.reopen(@err.last) if @capture_stderr
+          STDOUT.sync = STDERR.sync = true
+
+          clean_parent_file_descriptors()
+
+          @liveness_checker.pong if check_liveness
+
+          # run
+          debug("calling block")
+          ret = @block.call()
+          debug("block returned")
+
+          # Pass result to parent via pipe
+          Marshal.dump(ret, @child_write)
+          @child_write.flush
+          debug("wrote result to pipe")
+
+          # cleanup
+          @out.last.close
+          @err.last.close
+          @child_write.close
+        end
+
+        # close unused writers in parent
+        @out.last.close
+        @err.last.close
+        @child_write.close
+
+        @liveness_checker.ping(self) if check_liveness
+
+        self
+      end
+
+      # Blocking wait for process to finish
+      #
+      # @return [self]
+      def wait
+        return self if @done
+
+        Process.wait(@pid)
+        @done = true
+        @status = $?
+        @liveness_checker.stop if @liveness_checker
+        self
+      end
+
+      # Blocking wait for process to finish
+      #
+      # @return [Process::Status]
+      def wait2
+        return @status if @done
+
+        pid, @status = Process.wait2(@pid)
+        @done = true
+        @liveness_checker.stop if @liveness_checker
+        return @status
+      end
+
+      # Non-blocking wait for process to finish
+      #
+      # @return [Process::Status] nil if not yet complete
+      def wait_nonblock
+        return @status if @done
+
+        pid, @status = Process.waitpid2(@pid, Process::WNOHANG)
+        if !@status.nil? then
+          @done = true
+          @liveness_checker.stop if @liveness_checker
+        end
+        return @status
+      end
+
+      def result
+        if !@done then
+          wait()
+        end
+        @result = Marshal.load(@parent_read)
+        @parent_read.close
+        @result
+      end
+
+      def stdout
+        return @stdout if !@stdout.nil?
+        @stdout = @out.first.read
+        @out.first.close
+        @stdout ||= ""
+        @stdout
+      end
+
+      def stderr
+        return @stderr if !@stderr.nil?
+        @stderr = @err.first.read
+        @err.first.close
+        @stderr ||= ""
+        @stderr
+      end
+
+      def out
+        @out.first
+      end
+
+      def err
+        @err.first
+      end
+
+
+      private
+
+
+      # Cleanup all FDs inherited from the parent. We don't need them and we
+      # may throw errors if they are left open. 8192 should be high enough.
+      def clean_parent_file_descriptors
+        # Don't clean $stdin, $stdout, $stderr (0-2) or our own pipes
+        keep = [ @child_write.to_i, @out.last.to_i, @err.last.to_i ]
+        keep += @liveness_checker.fds if @liveness_checker
+
+        3.upto(8192) do |n|
+          if !keep.include? n then
+            begin
+              fd = IO.for_fd(n)
+              fd.close if fd
+            rescue
+            end
+          end
+        end
+      end
+
+
+    end
+  end
+end
+

data/lib/micron/runner/forking_clazz.rb

@@ -0,0 +1,40 @@
+
+module Micron
+  class Runner
+
+    # A Clazz implementation which forks before running each test method
+    class ForkingClazz < ParallelClazz
+
+      private
+
+      def spawn_test(method)
+        ForkWorker.new(method) {
+          $0 = "micron: method"
+          # ERR.puts "#{$0} (#{$$})"
+
+          EasyCov.start
+
+          Shim.wrap {
+            method.run
+          }
+
+          method
+        }.run(true)
+      end
+
+      # Collect the result data
+      #
+      # @param [Array] finished       Completed pids & their associated methods
+      #
+      # @return [Array<Method>]
+      def collect_results(finished)
+        finished.map{ |f| collect_result(f) }
+      end
+
+      def collect_result(worker)
+        worker.result
+      end
+
+    end
+  end
+end

data/lib/micron/runner/liveness_checker.rb

@@ -0,0 +1,40 @@
+
+require "micron/runner/liveness_checker/ping"
+require "micron/runner/liveness_checker/pong"
+
+module Micron
+  class Runner
+
+    class LivenessChecker
+
+      include Debug
+
+      def initialize
+        @ping = IO.pipe
+        @pong = IO.pipe
+      end
+
+      def ping(pid)
+        @pinger = Ping.new(@pong.first, @ping.last, pid)
+        @ping.first.close
+        @pong.last.close
+      end
+
+      def pong
+        @ponger = Pong.new(@ping.first, @pong.last)
+        @ping.last.close
+        @pong.first.close
+      end
+
+      def stop
+        @pinger.thread.kill
+      end
+
+      def fds
+        (@ping + @pong).map { |f| f.to_i }
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,65 @@
+
+require "timeout"
+
+module Micron
+  class Runner
+    class LivenessChecker
+
+      class Ping
+
+        include Debug
+
+        attr_reader :thread
+
+        def initialize(reader, writer, worker)
+          @thread = Thread.new(reader, writer, worker) { |reader, writer, worker|
+
+            Thread.current[:name] = "pinger-#{worker.pid}"
+            last_pong = Hitimes::Interval.now
+
+            begin
+              writer.sync = true
+
+              while true
+                begin
+                  writer.puts "ping"
+                  debug "sent ping"
+
+                  reply = Timeout.timeout(0.1) { reader.readline }
+
+                  if "pong\n" == reply then
+                    last_pong = Hitimes::Interval.now
+                    debug "got pong response"
+                  end
+
+                rescue Exception => ex
+                  if worker.wait_nonblock then
+                    # process exited, no need to do anything more
+                    # debug "no pong in #{last_pong.to_f} sec, but process exited"
+                    break
+                  end
+
+                  debug "no pong received: #{Micron.dump_ex(ex)}"
+                  if last_pong.to_f > 5.0 then
+                    debug "no pong in #{last_pong.to_f} sec! Unleash the reaper!!"
+                    Process.kill(9, worker.pid)
+                    break
+                  end
+                end
+
+                sleep 0.1
+              end # while
+
+            rescue => ex
+              debug "caught: #{Micron.dump_ex(ex)}"
+            end
+
+            debug "ping thread exiting"
+          }
+        end
+
+      end # Ping
+
+    end
+  end
+end