rspec-conductor 1.0.8 → 1.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91793bc12c3384342322b331ddbc5738dd448b92b18517f3de1a5f27b45b464d
-  data.tar.gz: 5daf14136401f25142f9d0393f8f427fd785245baff4eb6a026823549afa0e34
+  metadata.gz: 9de36557f5b670ac37493d920d186e4dcbcaca0c958d59914448b91aa5e6e488
+  data.tar.gz: 9d2371b5598a12adbc6ac907d80dfc4fbbe5f9c7d1c2b0f75cb17337345f51e4
 SHA512:
-  metadata.gz: 48cc6ad36c65d3686da3a03bd87261c66a00d3d77c1e7156a4504eb6c2e2e1b16b2c6df999163e02aa8f603674fdbe8c081765a0ad3983e426e9f9e40f03be9a
-  data.tar.gz: f93a55a25e1a890d13b29216f2c454ccd8c8d2cb01dda643ff24ba514dbdcfc85331cfed134f3bd9ba9fc87491b79dbf70fab43e5037383425a522dc00af3d7e
+  metadata.gz: cb67874bb0e5f84176ac601588d7931c97d70e3f8f6caff111e7cc1607b15007fcbc17f0053ff2c92f8e438cdad343530c91667de4d99f4fc7b95ac504f868fd
+  data.tar.gz: 4cb10a52cf0a0a6f9948c36287f2b6c5d35183df0ce6370196f9342e67c29ce5332780d8da8172d585be264170958fcbb317d77f03f3c23cb4ff70394b6e4cbe

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [1.0.10] - 2026-03-08
+
+- Add --print-slowest cli param to display the slowest specs in the suite
+
+## [1.0.9] - 2026-03-01
+
+- Handle workers stdout/stderr better. It is no longer necessary to use --verbose to see worker output. Verbose now only controls whether you see the debug output of the workers
+- For the fancy formatter, allocate one line per stdout/stderr. Not ideal, but I'm not sure what layout I'm even looking for here, since allowing to freely put stuff into stdout/stderr breaks the TUI completely
+- Disable echo when running (also breaks the TUI). The side effect of this is that you probably lose ability to tactically use binding.irb in your specs, but you might want to drop into the regular rspec to do that anyway
+- Way better handling of SIGINT / Ctrl-C. Child processes used to just crash when terminated via signal, now they're safely terminating
+- Support double Ctrl-C to force-kill the workers (same as rspec)
+- When there are spec failures, include a rerun command for failed examples (e.g. `rspec spec/some_spec.rb:28 spec/other_spec.rb:42`). It should also be possible to use rspec-conductor for those, but in my personal practice, I prefer rspec because I also want to have some interactive console during the spec run, which is not going to be possible with forked children
+
 ## [1.0.8] - 2026-02-18
 
 - When --postfork-require is provided, use current dir instead of spec/

data/lib/rspec/conductor/cli.rb

@@ -15,6 +15,7 @@ module RSpec
         display_retry_backtraces: false,
         prefork_require: 'config/application.rb',
         postfork_require: :spec_helper,
+        print_slowest_count: nil,
       }.freeze
 
       def self.run(argv)
@@ -97,6 +98,10 @@ module RSpec
             @conductor_options[:display_retry_backtraces] = true
           end
 
+          opts.on("--print-slowest COUNT", Integer, "Print slowest specs with their execution times") do |n|
+            @conductor_options[:print_slowest_count] = n
+          end
+
           opts.on("--verbose", "Enable debug output") do
             @conductor_options[:verbose] = true
           end
@@ -120,6 +125,7 @@ module RSpec
           rspec_args: @rspec_args,
           formatter: @conductor_options[:formatter],
           display_retry_backtraces: @conductor_options[:display_retry_backtraces],
+          print_slowest_count: @conductor_options[:print_slowest_count],
           verbose: @conductor_options[:verbose],
         ).run
       end

data/lib/rspec/conductor/ext/rspec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # RSpec doesn't provide us with a good way to handle before/after suite hooks,
 # doing what we can here
 class RSpec::Core::Configuration

data/lib/rspec/conductor/formatters/base.rb

@@ -2,65 +2,89 @@
 
 module RSpec
   module Conductor
-    class Base
-      include Util::ANSI
+    module Formatters
+      class Base
+        include Util::ANSI
 
-      def initialize(**_kwargs)
-      end
+        def initialize(**_kwargs)
+        end
 
-      def handle_worker_message(_worker_process, _message, _results)
-      end
+        def handle_worker_message(_worker_process, _message, _suite_run)
+        end
 
-      def print_startup_banner(worker_count:, seed:, spec_files_count:)
-        puts "RSpec Conductor starting with #{worker_count} workers (seed: #{seed})"
-        puts "Running #{spec_files_count} spec files\n\n"
-      end
+        def print_startup_banner(worker_count:, seed:, spec_files_count:)
+          puts "RSpec Conductor starting with #{worker_count} workers (seed: #{seed})"
+          puts "Running #{spec_files_count} spec files\n\n"
+        end
 
-      def print_summary(results, seed:)
-        puts "\n\n"
-        puts "Randomized with seed #{seed}"
-        puts "#{colorize("#{results.passed} passed", :green)}, #{colorize("#{results.failed} failed", :red)}, #{colorize("#{results.pending} pending", :yellow)}"
-        puts colorize("Worker crashes: #{results.worker_crashes}", :red) if results.worker_crashes.positive?
+        def print_summary(suite_run, seed:, success:)
+          puts "\n\n"
+          puts "Randomized with seed #{seed}"
+          puts "#{colorize("#{suite_run.examples_passed} passed", :green)}, #{colorize("#{suite_run.examples_failed} failed", :red)}, #{colorize("#{suite_run.examples_pending} pending", :yellow)}"
+          puts colorize("Worker crashes: #{suite_run.worker_crashes}", :red) if suite_run.worker_crashes.positive?
 
-        if results.errors.any?
-          puts "\nFailures:\n\n"
-          results.errors.each_with_index do |error, i|
-            puts "  #{i + 1}) #{error[:description]}"
-            puts colorize("     #{error[:message]}", :red) if error[:message]
-            puts colorize("     #{error[:location]}", :cyan)
-            if error[:backtrace]&.any?
-              puts "     Backtrace:"
-              error[:backtrace].each { |line| puts "       #{line}" }
+          if suite_run.errors.any?
+            puts "\nFailures:\n\n"
+            suite_run.errors.each_with_index do |error, i|
+              puts "  #{i + 1}) #{error[:description]}"
+              puts colorize("     #{error[:message]}", :red) if error[:message]
+              puts colorize("     #{error[:location]}", :cyan)
+              if error[:backtrace]&.any?
+                puts "     Backtrace:"
+                error[:backtrace].each { |line| puts "       #{line}" }
+              end
+              puts
             end
-            puts
+          end
+
+          puts "Specs took: #{suite_run.specs_runtime.round(2)}s"
+          puts "Total runtime: #{suite_run.total_runtime.round(2)}s"
+          puts "Suite: #{success ? colorize("PASSED", :green) : colorize("FAILED", :red)}"
+
+          if suite_run.errors.any?
+            puts ""
+            puts "To rerun failed examples:"
+            puts "  rspec #{suite_run.errors.map { |e| e[:location] }.join(" ")}"
           end
         end
 
-        puts "Specs took: #{results.specs_runtime.round(2)}s"
-        puts "Total runtime: #{results.total_runtime.round(2)}s"
-        puts "Suite: #{results.success? ? colorize("PASSED", :green) : colorize("FAILED", :red)}"
-      end
+        def print_slowest(suite_run, n)
+          puts "\n\n"
+          puts "Slowest #{n} specs:"
+          suite_run.example_stats.sort_by { |e| -e[:run_time] }.take(n).each_with_index do |e, i|
+            puts "%3d. (%8.2fms) %s @ %s" % [i + 1, e[:run_time] * 1000, colorize(e[:description], :dim), colorize(e[:location], :cyan)]
+          end
+        end
 
-      def print_debug(string)
-        $stderr.puts string
-      end
+        def handle_worker_stdout(worker_number, string)
+          puts "[worker #{worker_number}] #{string}"
+        end
 
-      def print_retry_message(message)
-        puts <<~EOM
-          \nRetried: #{message[:description]}
-            #{message[:location]}
-            #{message[:exception_class]}: #{message[:message]}
-            Backtrace:
-          #{message[:backtrace].map { "    #{_1}" }.join("\n")}
-        EOM
-      end
+        def handle_worker_stderr(worker_number, string)
+          $stderr.puts "[worker #{worker_number}] #{string}"
+        end
 
-      def print_shut_down_banner
-        puts "Shutting down..."
-      end
+        def print_debug(string)
+          $stderr.puts string
+        end
 
-      def colorize(string, colors, **kwargs)
-        $stdout.tty? ? super(string, colors, **kwargs) : string
+        def print_retry_message(message)
+          puts <<~EOM
+            \nRetried: #{message[:description]}
+              #{message[:location]}
+              #{message[:exception_class]}: #{message[:message]}
+              Backtrace:
+            #{message[:backtrace].map { "    #{_1}" }.join("\n")}
+          EOM
+        end
+
+        def print_shutdown_banner
+          puts "Shutting down... (press ctrl-c again to force quit)"
+        end
+
+        def colorize(string, colors, **kwargs)
+          $stdout.tty? ? super(string, colors, **kwargs) : string
+        end
       end
     end
   end

data/lib/rspec/conductor/formatters/ci.rb

@@ -14,22 +14,22 @@ module RSpec
           super(**kwargs)
         end
 
-        def handle_worker_message(_worker_process, message, results)
+        def handle_worker_message(_worker_process, message, suite_run)
           public_send(message[:type], message) if respond_to?(message[:type])
-          print_status(results) if @last_printout + @printout_interval < Time.now
+          print_status(suite_run) if @last_printout + @printout_interval < Time.now
         end
 
-        def print_status(results)
+        def print_status(suite_run)
           @last_printout = Time.now
-          pct = results.spec_file_processed_percentage
+          pct = suite_run.spec_file_processed_percentage
 
           puts "-" * tty_width
           puts "Current status [#{Time.now.strftime("%H:%M:%S")}]:"
-          puts "Processed: #{results.spec_files_processed} / #{results.spec_files_total} (#{(pct * 100).floor}%)"
-          puts "#{results.passed} passed, #{results.failed} failed, #{results.pending} pending"
-          if results.errors.any?
+          puts "Processed: #{suite_run.spec_files_processed} / #{suite_run.spec_files_total} (#{(pct * 100).floor}%)"
+          puts "#{suite_run.examples_passed} passed, #{suite_run.examples_failed} failed, #{suite_run.examples_pending} pending"
+          if suite_run.errors.any?
             puts "Failures:\n"
-            results.errors.each_with_index do |error, i|
+            suite_run.errors.each_with_index do |error, i|
               puts "  #{i + 1}) #{error[:description]}"
               puts "     #{error[:location]}"
               puts "     #{error[:message]}" if error[:message]

data/lib/rspec/conductor/formatters/fancy.rb

@@ -11,9 +11,7 @@ module RSpec
         end
 
         def initialize(worker_count:, **kwargs)
-          @worker_processes = {}
           @terminal = Util::Terminal.new
-          @last_rendered_lines = []
           @dots_string = +""
           @last_error = nil
 
@@ -25,13 +23,16 @@ module RSpec
           @dots_line = @terminal.line(truncate: false)
           @terminal.puts
           @last_error_line = @terminal.line(truncate: false)
+          @stdout_line = @terminal.puts nil
+          @stderr_line = @terminal.puts nil
+          @shutdown_line = @terminal.puts nil
 
           super(**kwargs)
         end
 
-        def handle_worker_message(worker_process, message, results)
+        def handle_worker_message(worker_process, message, suite_run)
           public_send(message[:type], worker_process, message) if respond_to?(message[:type])
-          redraw(worker_process, results)
+          redraw(worker_process, suite_run)
         end
 
         def example_passed(_worker_process, _message)
@@ -51,11 +52,23 @@ module RSpec
           dot "*", :yellow
         end
 
+        def handle_worker_stdout(worker_number, string)
+          @stdout_line.update("STDOUT: [worker #{worker_number}]: #{string}")
+        end
+
+        def handle_worker_stderr(worker_number, string)
+          @stderr_line.update("STDERR: [worker #{worker_number}]: #{string}")
+        end
+
+        def print_shutdown_banner
+          @shutdown_line.update("Shutting down... (press ctrl-c again to force quit)")
+        end
+
         private
 
-        def redraw(worker_process, results)
+        def redraw(worker_process, suite_run)
           update_worker_status_line(worker_process)
-          update_results_line(results)
+          update_suite_run_line(suite_run)
           update_errors_line
           @terminal.redraw
           @terminal.scroll_to_bottom
@@ -81,13 +94,13 @@ module RSpec
           @worker_lines[worker_process.number].update(status, redraw: false)
         end
 
-        def update_results_line(results)
-          pct = results.spec_file_processed_percentage
+        def update_suite_run_line(suite_run)
+          pct = suite_run.spec_file_processed_percentage
           bar_width = [tty_width - 20, 20].max
           filled = (pct * bar_width).floor
           empty = bar_width - filled
 
-          percentage = " %3d%% (%d/%d)" % [(pct * 100).floor, results.spec_files_processed, results.spec_files_total]
+          percentage = " %3d%% (%d/%d)" % [(pct * 100).floor, suite_run.spec_files_processed, suite_run.spec_files_total]
           bar = colorize("[", :reset) + colorize("▓", :green) * filled + colorize(" ", :reset) * empty + colorize("]", :reset)
 
           @progress_bar_line.update(bar + percentage, redraw: false)

data/lib/rspec/conductor/formatters/plain.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module RSpec
   module Conductor
     module Formatters
       class Plain < Base
-        def handle_worker_message(_worker_process, message, _results)
+        def handle_worker_message(_worker_process, message, _suite_run)
           public_send(message[:type], message) if respond_to?(message[:type])
         end
 

data/lib/rspec/conductor/rspec_subscriber.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec
   module Conductor
     # Technically this is a **Formatter**, as in RSpec Formatter, but that was too confusing,

data/lib/rspec/conductor/server.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "English"
-require "socket"
-require "json"
-
 module RSpec
   module Conductor
     class Server
@@ -21,6 +17,7 @@ module RSpec
       # @option formatter [String] Use a certain formatter
       # @option verbose [Boolean] Use especially verbose output
       # @option display_retry_backtraces [Boolean] Display backtraces for specs retried via rspec-retry
+      # @option print_slowest_count [Integer] Print slowest specs in the end of the suite
       def initialize(worker_count:, rspec_args:, **opts)
         @worker_count = worker_count
         @worker_number_offset = opts.fetch(:worker_number_offset, 0)
@@ -30,10 +27,11 @@ module RSpec
         @seed = opts[:seed] || (Random.new_seed % MAX_SEED)
         @fail_fast_after = opts[:fail_fast_after]
         @display_retry_backtraces = opts.fetch(:display_retry_backtraces, false)
+        @print_slowest_count = opts.fetch(:print_slowest_count, nil)
         @verbose = opts.fetch(:verbose, false)
 
         @rspec_args = rspec_args
-        @worker_processes = {}
+        @worker_processes = []
         @spec_queue = []
         @formatter_class = case opts[:formatter]
                            when "ci"
@@ -46,10 +44,12 @@ module RSpec
                              (!@verbose && Formatters::Fancy.recommended?) ? Formatters::Fancy : Formatters::Plain
                            end
         @formatter = @formatter_class.new(worker_count: @worker_count)
-        @results = Results.new
+        @suite_run = SuiteRun.new
 
+        $stdout.sync = true
+        $stdin.echo = false if $stdin.tty?
         Dir.chdir(Conductor.root)
-        ENV['PARALLEL_TEST_GROUPS'] = worker_count.to_s # parallel_tests backward-compatibility
+        ENV["PARALLEL_TEST_GROUPS"] = worker_count.to_s # parallel_tests backward-compatibility
       end
 
       def run
@@ -57,53 +57,28 @@ module RSpec
         build_spec_queue
         preload_application
 
-        $stdout.sync = true
         @formatter.print_startup_banner(worker_count: @worker_count, seed: @seed, spec_files_count: @spec_queue.size)
 
         start_workers
         run_event_loop
-        @results.suite_complete
+        wait_for_workers_to_exit
+        @suite_run.suite_complete
 
-        @formatter.print_summary(@results, seed: @seed)
+        @formatter.print_summary(@suite_run, seed: @seed, success: success?)
+        @formatter.print_slowest(@suite_run, @print_slowest_count) if @print_slowest_count
         exit_with_status
       end
 
       private
 
-      def preload_application
-        if !@prefork_require
-          debug "Prefork require not set, skipping..."
-          return
-        end
-
-        preload = File.expand_path(@prefork_require)
-
-        if File.exist?(preload)
-          debug "Preloading #{@prefork_require}..."
-          require preload
-        else
-          debug "#{@prefork_require} not found, skipping..."
-        end
-
-        debug "Application preloaded, autoload paths configured"
-      end
-
       def setup_signal_handlers
         %w[INT TERM].each do |signal|
           Signal.trap(signal) do
-            @worker_processes.any? ? initiate_shutdown : Kernel.exit(1)
+            @worker_processes.any?(&:running?) ? initiate_shutdown : Kernel.exit(1)
           end
         end
       end
 
-      def initiate_shutdown
-        return if @results.shutting_down?
-
-        @results.shut_down
-        @formatter.print_shut_down_banner
-        @worker_processes.each_value { |w| w.socket&.send_message({ type: :shutdown }) }
-      end
-
       def build_spec_queue
         config_options = RSpec::Core::ConfigurationOptions.new(@rspec_args)
         # a bit of a hack, but if they want to require something explicitly, they should use either --prefork-require or --postfork-require,
@@ -118,140 +93,154 @@ module RSpec
         debug "RSpec config: #{config.inspect}"
         debug "Files to run: #{config.files_to_run}"
         @spec_queue = config.files_to_run.shuffle(random: Random.new(@seed))
-        @results.spec_files_total = @spec_queue.size
+        @suite_run.spec_files_total = @spec_queue.size
       end
 
-      def start_workers
-        @worker_count.times do |i|
-          spawn_worker(@worker_number_offset + i + 1)
+      def preload_application
+        if !@prefork_require
+          debug "Prefork require not set, skipping..."
+          return
         end
-      end
-
-      def spawn_worker(worker_number)
-        parent_socket, child_socket = Socket.pair(:UNIX, :STREAM, 0)
 
-        debug "Spawning worker #{worker_number}"
+        preload = File.expand_path(@prefork_require)
 
-        pid = fork do
-          parent_socket.close
-
-          ENV["TEST_ENV_NUMBER"] = if @first_is_1 || worker_number != 1
-                                     worker_number.to_s
-                                   else
-                                     ""
-                                   end
-
-          Worker.new(
-            worker_number: worker_number,
-            socket: Protocol::Socket.new(child_socket),
-            rspec_args: @rspec_args,
-            verbose: @verbose,
-            postfork_require: @postfork_require,
-          ).run
+        if File.exist?(preload)
+          debug "Preloading #{@prefork_require}..."
+          require preload
+        else
+          debug "#{@prefork_require} not found, skipping..."
         end
 
-        child_socket.close
-        debug "Worker #{worker_number} started with pid #{pid}"
+        debug "Application preloaded, autoload paths configured"
+      end
 
-        @worker_processes[pid] = WorkerProcess.new(
-          pid: pid,
-          number: worker_number,
-          status: :running,
-          socket: Protocol::Socket.new(parent_socket),
-          current_spec: nil,
-        )
-        assign_work(@worker_processes[pid])
+      def start_workers
+        @worker_processes = @worker_count.times.map { |i| spawn_worker(@worker_number_offset + i + 1) }
+        @worker_processes.each { |wp| assign_work(wp) }
       end
 
       def run_event_loop
-        until @worker_processes.empty?
-          worker_processes_by_io = @worker_processes.values.to_h { |w| [w.socket.io, w] }
-          readable_ios, = IO.select(worker_processes_by_io.keys, nil, nil, WORKER_POLL_INTERVAL)
-          readable_ios&.each { |io| handle_worker_message(worker_processes_by_io.fetch(io)) }
+        until @worker_processes.select(&:running?).empty?
+          if @shutdown_status == :initiated_graceful
+            @shutdown_status = :shutdown_messages_sent
+            @formatter.print_shutdown_banner
+            @worker_processes.select(&:running?).each do |worker_process|
+              worker_process.send_message({ type: :shutdown })
+              cleanup_worker_process(worker_process)
+            end
+          end
+
+          WorkerProcess.tick_all(@worker_processes)
           reap_workers
         end
       end
 
-      def handle_worker_message(worker_process)
-        message = worker_process.socket.receive_message
-        return unless message
+      def wait_for_workers_to_exit
+        WorkerProcess.wait_all(@worker_processes)
+      end
+
+      def spawn_worker(worker_number)
+        debug "Spawning worker #{worker_number}"
+
+        worker_process = WorkerProcess.spawn(
+          number: worker_number,
+          test_env_number: (@first_is_1 || worker_number != 1) ? worker_number.to_s : "",
+          on_message: ->(worker_process, message) { handle_worker_message(worker_process, message) },
+          on_stdout: ->(string) { @formatter.handle_worker_stdout(worker_number, string) },
+          on_stderr: ->(string) { @formatter.handle_worker_stderr(worker_number, string) },
+          debug_io: @verbose ? $stderr : nil,
+          rspec_args: @rspec_args,
+          postfork_require: @postfork_require,
+        )
+        debug "Worker #{worker_number} started with pid #{worker_process.pid}"
+        worker_process
+      end
 
+      def handle_worker_message(worker_process, message)
         debug "Worker #{worker_process.number}: #{message[:type]}"
 
         case message[:type].to_sym
         when :example_passed
-          @results.example_passed
+          @suite_run.example_passed(message)
         when :example_failed
-          @results.example_failed(message)
+          @suite_run.example_failed(message)
 
-          if @fail_fast_after && @results.failed >= @fail_fast_after
-            debug "Shutting down after #{@results.failed} failures"
+          if @fail_fast_after && @suite_run.examples_failed >= @fail_fast_after
+            debug "Shutting down after #{@suite_run.examples_failed} failures"
             initiate_shutdown
           end
         when :example_pending
-          @results.example_pending
+          @suite_run.example_pending
         when :example_retried
           @formatter.print_retry_message(message) if @display_retry_backtraces
         when :spec_complete
-          @results.spec_file_complete
+          @suite_run.spec_file_complete
           worker_process.current_spec = nil
           assign_work(worker_process)
         when :spec_error
-          @results.spec_file_error(message)
+          @suite_run.spec_file_error(message)
           debug "Spec error details: #{message[:error]}"
           worker_process.current_spec = nil
           assign_work(worker_process)
-        when :spec_interrupted
-          debug "Spec interrupted: #{message[:file]}"
-          worker_process.current_spec = nil
         end
-        @formatter.handle_worker_message(worker_process, message, @results)
+        @formatter.handle_worker_message(worker_process, message, @suite_run)
       end
 
       def assign_work(worker_process)
         spec_file = @spec_queue.shift
 
-        if @results.shutting_down? || !spec_file
+        if shutting_down? || !spec_file
           debug "No more work for worker #{worker_process.number}, sending shutdown"
-          worker_process.socket.send_message({ type: :shutdown })
+          worker_process.send_message({ type: :shutdown })
           cleanup_worker_process(worker_process)
         else
-          @results.spec_file_assigned
+          @suite_run.spec_file_assigned
           worker_process.current_spec = spec_file
           debug "Assigning #{spec_file} to worker #{worker_process.number}"
           message = { type: :worker_assigned_spec, file: spec_file }
-          worker_process.socket.send_message(message)
-          @formatter.handle_worker_message(worker_process, message, @results)
+          worker_process.send_message(message)
+          @formatter.handle_worker_message(worker_process, message, @suite_run)
         end
       end
 
       def cleanup_worker_process(worker_process, status: :shut_down)
-        @worker_processes.delete(worker_process.pid)
-        worker_process.socket.close
-        worker_process.status = status
-        @formatter.handle_worker_message(worker_process, { type: :worker_shut_down }, @results)
-        Process.wait(worker_process.pid)
-      rescue Errno::ECHILD
-        nil
+        worker_process.shut_down(status)
+        @formatter.handle_worker_message(worker_process, { type: :worker_shut_down }, @suite_run)
       end
 
       def reap_workers
-        dead_worker_processes = @worker_processes.each_with_object([]) do |(pid, worker), memo|
-          result = Process.waitpid(pid, Process::WNOHANG)
-          memo << [worker, $CHILD_STATUS] if result
+        dead_worker_processes = @worker_processes.select(&:running?).each_with_object([]) do |worker_process, memo|
+          result, status = Process.waitpid2(worker_process.pid, Process::WNOHANG)
+          memo << [worker_process, status] if result
+        rescue Errno::ECHILD
         end
 
         dead_worker_processes.each do |worker_process, exitstatus|
           cleanup_worker_process(worker_process, status: :terminated)
-          @results.worker_crashed
+          @suite_run.worker_crashed
           debug "Worker #{worker_process.number} exited with status #{exitstatus.exitstatus}, signal #{exitstatus.termsig}"
         end
-      rescue Errno::ECHILD
-        nil
+      end
+
+      def shutting_down?
+        !@shutdown_status.nil?
+      end
+
+      def initiate_shutdown
+        if @shutdown_status.nil?
+          @shutdown_status = :initiated_graceful
+        elsif @shutdown_status != :initiated_forced && @worker_processes.any?(&:running?)
+          @shutdown_status = :initiated_forced
+          Process.kill(:TERM, *@worker_processes.select(&:running?).map(&:pid))
+        end
+      end
+
+      def success?
+        @suite_run.success? && !shutting_down?
       end
 
       def exit_with_status
-        Kernel.exit(@results.success? ? 0 : 1)
+        Kernel.exit(success? ? 0 : 1)
       end
 
       def debug(message)

data/lib/rspec/conductor/{results.rb → suite_run.rb}

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module RSpec
   module Conductor
-    class Results
-      attr_accessor :passed, :failed, :pending, :worker_crashes, :errors, :started_at, :spec_files_total, :spec_files_processed
+    class SuiteRun
+      attr_accessor :examples_passed, :examples_failed, :examples_pending, :worker_crashes, :errors, :started_at, :spec_files_total, :spec_files_processed, :example_stats
 
       def initialize
-        @passed = 0
-        @failed = 0
-        @pending = 0
+        @examples_passed = 0
+        @examples_failed = 0
+        @examples_pending = 0
         @worker_crashes = 0
         @errors = []
         @started_at = Time.now
@@ -14,24 +16,26 @@ module RSpec
         @specs_completed_at = nil
         @spec_files_total = 0
         @spec_files_processed = 0
-        @shutting_down = false
+        @example_stats = []
       end
 
       def success?
-        @failed.zero? && @errors.empty? && @worker_crashes.zero? && !shutting_down?
+        @examples_failed.zero? && @errors.empty? && @worker_crashes.zero? && @spec_files_total == @spec_files_processed
       end
 
-      def example_passed
-        @passed += 1
+      def example_passed(message)
+        @example_stats << message.slice(:location, :run_time, :description)
+        @examples_passed += 1
       end
 
       def example_failed(message)
-        @failed += 1
+        @example_stats << message.slice(:location, :run_time, :description)
+        @examples_failed += 1
         @errors << message
       end
 
       def example_pending
-        @pending += 1
+        @examples_pending += 1
       end
 
       def spec_file_assigned
@@ -56,14 +60,6 @@ module RSpec
         @worker_crashes += 1
       end
 
-      def shut_down
-        @shutting_down = true
-      end
-
-      def shutting_down?
-        @shutting_down
-      end
-
       def suite_complete
         @specs_completed_at ||= Time.now
       end

data/lib/rspec/conductor/util/child_process.rb

@@ -4,6 +4,8 @@ module RSpec
   module Conductor
     module Util
       class ChildProcess
+        POLL_INTERVAL = 0.01
+
         attr_reader :pid, :exit_status
 
         def self.fork(**args, &block)
@@ -12,18 +14,24 @@ module RSpec
 
         def self.wait_all(processes)
           until processes.all?(&:done?)
-            pipe_to_process = processes.each_with_object({}) do |process, memo|
-              process.pipes.reject(&:closed?).each { |pipe| memo[pipe] = process }
-            end
-            break if pipe_to_process.empty?
-
-            ready, = IO.select(pipe_to_process.keys, nil, nil, 0.1)
-            ready&.each { |pipe| pipe_to_process[pipe].read_available(pipe) }
+            break unless tick_all(processes)
           end
 
           processes.each(&:finalize)
         end
 
+        def self.tick_all(processes, poll_interval: POLL_INTERVAL)
+          processes_by_io = processes.each_with_object({}) do |process, memo|
+            process.pipes.reject(&:closed?).each { |pipe| memo[pipe] = process }
+          end
+          return false if processes_by_io.empty?
+
+          ready, = IO.select(processes_by_io.keys, nil, nil, poll_interval)
+          ready&.each { |pipe| processes_by_io[pipe].read_available(pipe) }
+
+          true
+        end
+
         def initialize(on_stdout: nil, on_stderr: nil)
           @on_stdout = on_stdout
           @on_stderr = on_stderr
@@ -55,11 +63,13 @@ module RSpec
 
             $stdout = stdout_write
             $stderr = stderr_write
-            STDOUT.reopen(stdout_write)
-            STDERR.reopen(stderr_write)
+            $stdin = File.open("/dev/null")
+            STDOUT.reopen($stdout)
+            STDERR.reopen($stderr)
+            STDIN.reopen($stdin)
 
             begin
-              yield
+              yield self
             rescue => e
               stderr_write.puts "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
               exit 1
@@ -111,12 +121,17 @@ module RSpec
         def finalize
           return if done?
 
-          process_buffer(@stdout_buffer, @on_stdout, partial: true)
-          process_buffer(@stderr_buffer, @on_stderr, partial: true)
-
-          _, status = Process.wait2(@pid)
-          @exit_status = status.exitstatus
           @done = true
+
+          process_buffer(@stdout_buffer, @on_stdout, drain_remaining: true)
+          process_buffer(@stderr_buffer, @on_stderr, drain_remaining: true)
+
+          begin
+            _, status = Process.waitpid2(@pid)
+            @exit_status = status.exitstatus
+          rescue Errno::ECHILD
+          end
+
           self
         end
 
@@ -130,21 +145,17 @@ module RSpec
 
         private
 
-        def process_buffer(buffer, callback, partial: false)
-          return unless callback
+        def process_buffer(buffer, callback, drain_remaining: false)
+          while (newline_pos = buffer.index("\n"))
+            # String#slice! seems like it was invented specifically for this scenario,
+            # when you need to cut out a string fragment destructively
+            line = buffer.slice!(0..newline_pos).chomp
+            callback&.call(line)
+          end
 
-          if partial
-            unless buffer.empty?
-              callback.call(buffer.chomp)
-              buffer.clear
-            end
-          else
-            while (newline_pos = buffer.index("\n"))
-              # String#slice! seems like it was invented specifically for this scenario,
-              # when you need to cut out a string fragment destructively
-              line = buffer.slice!(0..newline_pos).chomp
-              callback.call(line)
-            end
+          if drain_remaining && !buffer.empty?
+            callback&.call(buffer.chomp)
+            buffer.clear
           end
         end
       end

data/lib/rspec/conductor/util/terminal.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "screen_buffer"
-
 module RSpec
   module Conductor
     module Util
@@ -30,7 +28,7 @@ module RSpec
           end
 
           def lines
-            [self]
+            @content ? [self] : []
           end
         end
 

data/lib/rspec/conductor/version.rb

@@ -2,6 +2,6 @@
 
 module RSpec
   module Conductor
-    VERSION = "1.0.8"
+    VERSION = "1.0.10"
   end
 end

data/lib/rspec/conductor/worker.rb

@@ -1,23 +1,20 @@
 # frozen_string_literal: true
 
-require_relative 'ext/rspec'
-
 module RSpec
   module Conductor
     class Worker
-      def initialize(worker_number:, socket:, rspec_args: [], verbose: false, postfork_require: :spec_helper)
+      def initialize(worker_number:, socket:, rspec_args: [], postfork_require: :spec_helper, debug_io: nil)
         @worker_number = worker_number
         @socket = socket
         @rspec_args = rspec_args
-        @verbose = verbose
         @postfork_require = postfork_require
-
+        @debug_io = debug_io
         @message_queue = []
       end
 
       def run
-        suppress_output unless @verbose
         debug "Worker #{@worker_number} starting"
+        setup_signal_handlers
         setup_load_path
         require_postfork_preloads
 
@@ -57,6 +54,11 @@ module RSpec
 
       private
 
+      def setup_signal_handlers
+        Signal.trap(:INT, :IGNORE)
+        Signal.trap(:TERM, :EXIT)
+      end
+
       def setup_load_path
         parsed_options.configure(RSpec.configuration)
         @default_path = RSpec.configuration.default_path || "spec"
@@ -75,12 +77,6 @@ module RSpec
         $LOAD_PATH.unshift(path)
       end
 
-      def suppress_output
-        $stdout.reopen(null_io_out)
-        $stderr.reopen(null_io_out)
-        $stdin.reopen(null_io_in)
-      end
-
       def require_postfork_preloads
         if @postfork_require == :spec_helper
           rails_helper = File.expand_path("rails_helper.rb", @default_full_path)
@@ -172,16 +168,12 @@ module RSpec
       end
 
       def debug(message)
-        $stderr.puts "[worker #{@worker_number}] #{message}"
+        @debug_io.puts message if @debug_io
       end
 
       def null_io_out
         @null_io_out ||= File.open(File::NULL, "w")
       end
-
-      def null_io_in
-        @null_io_in ||= File.open(File::NULL, "r")
-      end
     end
   end
 end

data/lib/rspec/conductor/worker_process.rb

@@ -1,6 +1,71 @@
+# frozen_string_literal: true
+
+require "socket"
+
 module RSpec
   module Conductor
-    WorkerProcess = Struct.new(:pid, :number, :status, :socket, :current_spec, keyword_init: true) do
+    WorkerProcess = Struct.new(:pid, :child_process, :number, :on_message, :status, :socket, :current_spec, keyword_init: true) do
+      def self.spawn(number:, test_env_number:, on_message:, on_stdout: nil, on_stderr: nil, **worker_init_args)
+        parent_socket, child_socket = Socket.pair(:UNIX, :STREAM, 0)
+        child_process = Util::ChildProcess.fork(on_stdout: on_stdout, on_stderr: on_stderr) do
+          ENV["TEST_ENV_NUMBER"] = test_env_number
+          parent_socket.close
+          Worker.new(
+            worker_number: number,
+            socket: Protocol::Socket.new(child_socket),
+            **worker_init_args
+          ).run
+        end
+        child_socket.close
+
+        new(
+          pid: child_process.pid,
+          child_process: child_process,
+          on_message: on_message,
+          number: number,
+          status: :running,
+          socket: Protocol::Socket.new(parent_socket),
+          current_spec: nil
+        )
+      end
+
+      def self.tick_all(worker_processes)
+        worker_processes_by_io = worker_processes.select(&:running?).to_h { |w| [w.socket.io, w] }
+        readable_ios, = IO.select(worker_processes_by_io.keys, nil, nil, 0)
+        readable_ios&.each { |io| worker_processes_by_io.fetch(io).handle_message }
+        Util::ChildProcess.tick_all(worker_processes.map(&:child_process))
+      end
+
+      def self.wait_all(worker_processes)
+        Util::ChildProcess.wait_all(worker_processes.map(&:child_process))
+      end
+
+      def handle_message
+        message = receive_message
+        return unless message && on_message
+
+        on_message.call(self, message)
+      end
+
+      def send_message(message)
+        socket.send_message(message)
+      end
+
+      def receive_message
+        socket.receive_message
+      end
+
+      def shut_down(status)
+        return unless running?
+
+        self.status = status
+        socket.close
+      end
+
+      def running?
+        status == :running
+      end
+
       def hash
         [number].hash
       end

data/lib/rspec/conductor.rb

@@ -28,12 +28,14 @@ module RSpec
 end
 
 require_relative "conductor/util/ansi"
+require_relative "conductor/util/screen_buffer"
 require_relative "conductor/util/terminal"
+require_relative "conductor/util/child_process"
 require_relative "conductor/version"
 require_relative "conductor/protocol"
 require_relative "conductor/server"
 require_relative "conductor/worker"
-require_relative "conductor/results"
+require_relative "conductor/suite_run"
 require_relative "conductor/worker_process"
 require_relative "conductor/cli"
 require_relative "conductor/rspec_subscriber"
@@ -42,6 +44,8 @@ require_relative "conductor/formatters/plain"
 require_relative "conductor/formatters/ci"
 require_relative "conductor/formatters/fancy"
 
+require_relative "conductor/ext/rspec"
+
 if defined?(Rails)
   require_relative "conductor/railtie"
 end

data/lib/tasks/rspec_conductor.rake

@@ -49,7 +49,7 @@ module RSpec
           configs
         end
 
-        def run_for_each_database(count, action)
+        def run_for_each_database(count, action, &block)
           raise ArgumentError, "count must be positive" if count < 1
 
           puts "#{action} #{count} test databases in parallel..."

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-conductor
 version: !ruby/object:Gem::Version
-  version: 1.0.8
+  version: 1.0.10
 platform: ruby
 authors:
 - Mark Abramov
@@ -48,9 +48,9 @@ files:
 - lib/rspec/conductor/formatters/plain.rb
 - lib/rspec/conductor/protocol.rb
 - lib/rspec/conductor/railtie.rb
-- lib/rspec/conductor/results.rb
 - lib/rspec/conductor/rspec_subscriber.rb
 - lib/rspec/conductor/server.rb
+- lib/rspec/conductor/suite_run.rb
 - lib/rspec/conductor/util/ansi.rb
 - lib/rspec/conductor/util/child_process.rb
 - lib/rspec/conductor/util/screen_buffer.rb
@@ -82,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Queue-based parallel test runner for rspec
 test_files: []