paraspec 0.0.1

data/lib/paraspec/master_runner.rb

@@ -0,0 +1,7 @@
+module Paraspec
+  # An RSpec test runner - in a master process.
+  # This runner queues the tests to run instead of running them.
+  # Worker processes then run the tests.
+  class MasterRunner
+  end
+end

data/lib/paraspec/msgpack_client.rb

@@ -0,0 +1,53 @@
+require 'msgpack'
+require 'socket'
+
+module Paraspec
+  class MsgpackClient
+    include MsgpackHelpers
+
+    def initialize(options={})
+      @terminal = options[:terminal]
+
+      connect
+    end
+
+    def request(action, payload=nil)
+      req = {action: action, payload: payload, id: request_id}
+      Paraspec.logger.debug_ipc("CliReq:#{req[:id]} #{req}")
+      pk = packer(@socket)
+      pk.write(req)
+      pk.flush
+      response = unpacker(@socket).unpack
+      Paraspec.logger.debug_ipc("CliRes:#{req[:id]} #{response}")
+      response = IpcHash.new.merge(response)
+      response[:result]
+    end
+
+    def request_id
+      @request_num ||= 0
+      "#{$$}:#{@request_num += 1}"
+    end
+
+    # The socket doesn't stay operational after a fork even if the child
+    # process never uses it. Parent should reconnect after forking
+    # any children
+    def reconnect!
+      @socket.close
+      connect
+    end
+
+    private def connect
+      start_time = Time.now
+      begin
+        @socket = TCPSocket.new('127.0.0.1', MASTER_APP_PORT)
+      rescue Errno::ECONNREFUSED
+        if !@terminal && Time.now - start_time > DrbHelpers::WAIT_TIME
+          raise
+        else
+          sleep 0.1
+          retry
+        end
+      end
+    end
+  end
+end

data/lib/paraspec/msgpack_helpers.rb

@@ -0,0 +1,46 @@
+require 'time'
+
+module Paraspec
+  module MsgpackHelpers
+
+    def packer(io)
+      pk = MessagePack::Packer.new(io)
+      pk.register_type(1, Time) do |time|
+        time.to_s
+      end
+      pk.register_type(2, RSpec::Core::Example::ExecutionResult) do |er|
+        serialized = {}
+        %w(started_at finished_at run_time status).each do |field|
+          serialized[field] = er.send(field)
+        end
+        %w(exception pending_exception).each do |field|
+          serialized[field] = Marshal.dump(er.send(field))
+        end
+        Marshal.dump(serialized)
+      end
+      pk
+    end
+
+    def unpacker(io)
+      uk = MessagePack::Unpacker.new(io)
+      uk.register_type(1) do |serialized|
+        Time.parse(serialized)
+      end
+      uk.register_type(2) do |serialized|
+        serialized = Marshal.load(serialized)
+        er = RSpec::Core::Example::ExecutionResult.new
+        serialized.each do |k, v|
+          if k == 'status'
+            v = v.to_sym
+          end
+          if %w(exception pending_exception).include?(k)
+            v = Marshal.load(v)
+          end
+          er.send("#{k}=", v)
+        end
+        er
+      end
+      uk
+    end
+  end
+end

data/lib/paraspec/msgpack_server.rb

@@ -0,0 +1,58 @@
+require 'benchmark'
+require 'msgpack'
+require 'socket'
+
+module Paraspec
+  class MsgpackServer
+    include MsgpackHelpers
+
+    def initialize(master)
+      @master = master
+    end
+
+    def run
+      @socket = ::TCPServer.new('127.0.0.1', MASTER_APP_PORT)
+      begin
+        while true
+          s = @socket.accept_nonblock
+          run_processing_thread(s)
+        end
+      rescue Errno::EAGAIN
+        unless @master.stop?
+          sleep 0.2
+          retry
+        end
+      end
+    end
+
+    def run_processing_thread(s)
+      Thread.new do
+        u = unpacker(s)
+        u.each do |obj|
+          result = nil
+          time = Benchmark.realtime do
+            action = obj['action'].gsub('-', '_')
+            payload = obj['payload']
+            if payload
+              payload = IpcHash.new.merge(payload)
+              args = [payload]
+            else
+              args = []
+            end
+
+            Paraspec.logger.debug_ipc("SrvReq:#{obj['id']} #{obj}")
+            result = @master.send(action, *args)
+
+            pk = packer(s)
+            resp = {result: result}
+            Paraspec.logger.debug_ipc("SrvRes:#{obj['id']} #{resp}")
+            pk.write(resp)
+            pk.flush
+            s.flush
+          end
+          Paraspec.logger.debug_perf("SrvReq:#{obj['id']} #{obj['action']}: #{result} #{'%.3f msec' % (time*1000)}")
+        end
+      end
+    end
+  end
+end

data/lib/paraspec/process_helpers.rb

@@ -0,0 +1,22 @@
+module Paraspec
+  module ProcessHelpers
+    def kill_child_processes
+      # Only kill if we are in supervisor
+      return unless Process.pid == Process.getpgrp
+
+      child_pids = `pgrep -g #{$$}`
+      if $?.exitstatus != 0
+        warn "Failed to run pgrep (#{$?.exitstatus})"
+      end
+      child_pids = child_pids.strip.split(/\n/).map { |pid| pid.to_i }
+      child_pids.delete_if do |pid|
+        pid == Process.pid
+      end
+      child_pids.each do |pid|
+        begin
+          Process.kill('TERM', pid)
+        end
+      end
+    end
+  end
+end

data/lib/paraspec/rspec_facade.rb

@@ -0,0 +1,38 @@
+require 'forwardable'
+require 'singleton'
+
+module Paraspec
+  class RSpecFacade
+    include Singleton
+
+    class << self
+      extend Forwardable
+      def_delegators :instance, :all_example_groups, :all_examples
+    end
+
+    def all_example_groups
+      @all_example_groups ||= begin
+        groups = [] + RSpec.world.example_groups
+        all_groups = []
+        until groups.empty?
+          new_groups = []
+          groups.each do |group|
+            all_groups << group
+            new_groups += group.children
+          end
+          groups = new_groups
+        end
+        all_groups
+      end
+    end
+
+    def all_examples
+      @all_examples ||= begin
+        filter_manager = RSpec.configuration.filter_manager
+        all_example_groups.map do |group|
+          filter_manager.prune(group.examples)
+        end.flatten
+      end
+    end
+  end
+end

data/lib/paraspec/rspec_patches.rb

@@ -0,0 +1,23 @@
+require 'rspec/core'
+
+class RSpec::Core::Configuration
+  # https://github.com/rspec/rspec-core/commit/e7bb36342b8a3aca2512a0335ea9836780a60605
+  # Will probably add a flag to configuration to load default_path
+  # regardless of $0
+  def command
+    'rspec'
+  end
+end
+
+class RSpec::Core::World
+  # https://github.com/rspec/rspec-core/pull/2552
+  def filter_examples
+    @filtered_examples = Hash.new do |hash, group|
+      hash[group] = filter_manager.prune(group.examples)
+    end
+  end
+end
+
+class RSpec::Core::Reporter
+  attr_reader :non_example_exception_count
+end

data/lib/paraspec/supervisor.rb

@@ -0,0 +1,127 @@
+module Paraspec
+  # Supervisor is the process that spawns all other processes.
+  # Its primary responsibility is to be a "clean slate", specifically
+  # the supervisor should not ever have any of the tests loaded in its
+  # address space.
+  class Supervisor
+    include DrbHelpers
+    include ProcessHelpers
+
+    def initialize(options={})
+      @original_process_title = $0
+      $0 = "#{@original_process_title} [supervisor]"
+      Paraspec.logger.ident = '[s]'
+      @concurrency = options[:concurrency] || 1
+      @terminal = options[:terminal]
+      @options = options
+    end
+
+    def run
+      unless @terminal
+        Process.setpgrp
+      end
+
+      supervisor_pid = $$
+      at_exit do
+        # We fork, therefore this handler will be run in master and
+        # workers as well but it should only run in supervisor.
+        # Guard accordingly
+        if $$ == supervisor_pid
+          # first kill workers, then master
+          ((@worker_pids || []) + [@master_pid]).compact.each do |pid|
+            begin
+              Process.kill('TERM', pid)
+            rescue SystemCallError
+            end
+          end
+          # then kill our process group
+          unless @terminal
+            kill_child_processes
+          end
+        end
+      end
+
+      rd, wr = IO.pipe
+      if @master_pid = fork
+        # parent
+        wr.close
+        @master_pipe = rd
+        run_supervisor
+      else
+        # child - master
+        $0 = "#{@original_process_title} [master]"
+        if @options[:master_is_1]
+          ENV['TEST_ENV_NUMBER'] = '1'
+        end
+        Paraspec.logger.ident = '[m]'
+        rd.close
+        master = Master.new(:supervisor_pipe => wr)
+        master.run
+        exit(0)
+      end
+    end
+
+    def run_supervisor
+      start_time = Time.now
+
+      if master_client.request('non-example-exception-count').to_i == 0
+        master_client.request('suite-started')
+
+        @worker_pipes = []
+        @worker_pids = []
+
+        1.upto(@concurrency) do |i|
+          rd, wr = IO.pipe
+          if worker_pid = fork
+            # parent
+            wr.close
+            @worker_pipes << rd
+            @worker_pids << worker_pid
+          else
+            # child - worker
+            $0 = "#{@original_process_title} [worker-#{i}]"
+            Paraspec.logger.ident = "[w#{i}]"
+            rd.close
+            if RSpec.world.example_groups.count > 0
+              raise 'Example groups loaded too early/spilled across processes'
+            end
+            Worker.new(:number => i, :supervisor_pipe => wr).run
+            exit(0)
+          end
+        end
+
+        Paraspec.logger.debug_state("Waiting for workers")
+        @worker_pids.each_with_index do |pid, i|
+          Paraspec.logger.debug_state("Waiting for worker #{i+1} at #{pid}")
+          wait_for_process(pid)
+        end
+        status = 0
+      else
+        status = 1
+      end
+
+      master_client.reconnect!
+      puts "dumping summary"
+      master_client.request('dump-summary')
+      if status == 0
+        status = master_client.request('status')
+      end
+      Paraspec.logger.debug_state("Asking master to stop")
+      master_client.request('stop')
+      wait_for_process(@master_pid)
+      exit status
+    end
+
+    def wait_for_process(pid)
+      begin
+        Process.wait(pid)
+      rescue Errno::ECHILD
+        # already dead
+      end
+    end
+
+    def ident
+      "[s]"
+    end
+  end
+end

data/lib/paraspec/version.rb

@@ -0,0 +1,3 @@
+module Paraspec
+  VERSION = '0.0.1'
+end

data/lib/paraspec/worker.rb

@@ -0,0 +1,70 @@
+module Paraspec
+  # A worker process obtains a test to run from the master, runs the
+  # test and reports the results, as well as any output, back to the master,
+  # then obtains the next test to run and so on.
+  # There can be one or more workers participating in a test run.
+  # A worker generally loads all of the tests but runs a subset of them.
+  class Worker
+    include DrbHelpers
+
+    def initialize(options={})
+      @number = options[:number]
+      ENV['TEST_ENV_NUMBER'] = @number.to_s
+      @supervisor_pipe = options[:supervisor_pipe]
+      if RSpec.world.example_groups.count > 0
+        raise 'Example groups loaded too early/spilled across processes'
+      end
+      @terminal = options[:terminal]
+
+      #RSpec.configuration.load_spec_files
+      # possibly need to signal to supervisor when we are ready to
+      # start running tests - there is a race otherwise I think
+      #puts "#{RSpecFacade.all_example_groups.count} example groups known"
+    end
+
+    def run
+    #puts "worker: #{Process.pid} #{Process.getpgrp}"
+      #@master = drb_connect(MASTER_DRB_URI, timeout: !@terminal)
+
+      runner = WorkerRunner.new(master_client: master_client)
+
+      # fill cache when pruning is not set up
+      RSpecFacade.all_example_groups
+      RSpecFacade.all_examples
+
+      master_example_count = master_client.request('example-count')
+      if master_example_count != RSpecFacade.all_examples.count
+        # Workers and master should have the same examples defined.
+        # If a test suite conditionally defines examples, it needs to
+        # ensure that master and worker use the same settings.
+        # If worker and master sets of examples differ, when the worker
+        # requests an example from master it may receive an example
+        # that it can't run.
+        # We just check the count for now but may take a digest of
+        # defined examples in the future.
+        # A mismatch here usually indicates an issue with the test suite
+        # being run.
+        puts "Worker #{@number} has #{RSpecFacade.all_examples.count} examples, master has #{master_example_count}"
+        #byebug
+        raise "Worker #{@number} has #{RSpecFacade.all_examples.count} examples, master has #{master_example_count}"
+      end
+
+      while true
+        Paraspec.logger.debug_state("Requesting a spec")
+        spec = master_client.request('get-spec')
+        Paraspec.logger.debug_state("Got spec #{spec || 'nil'}")
+        # HTTP transport returns no spec as an empty hash,
+        # msgpack transport returns as nil
+        break if spec.nil? || spec.empty?
+        spec = IpcHash.new.merge(spec)
+        Paraspec.logger.debug_state("Running spec #{spec}")
+        runner.run(spec)
+        Paraspec.logger.debug_state("Finished running spec #{spec}")
+      end
+    end
+
+    def ident
+      "[w#{@number}]"
+    end
+  end
+end