rspec-multiprocess_runner 0.1.0 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4c75ed167254b35531b51f11a1dda272f3587055
+  data.tar.gz: c5cb965e6c3e0caaecc65f7e4236124c98d407af
+SHA512:
+  metadata.gz: 35139e859a97c7b20cbff792b652be8172c1a70dbed65ac2277bf53a18486092cae8199820782d8747ce4830cbf927ec73f4ae6625888f2939b10a6103668c0e
+  data.tar.gz: 79868c598e2dfc09f467ccf9badc6382afce4b9930f6711784bdb7f336878a3921608a8fd240dbaf77fdac6818be1c99816b20687fe29755f9f4259e895738ad

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+# 0.2.0
+
+* Terminate workers when the coordinator process is interrupted with SIGINT (^C)
+  or SIGTERM (`kill` with no args) (#3)
+* Add per-example timeout option. When using `multirspec` or the rake tasks, it
+  defaults to 15 seconds (#2)
+* **Breaking change**: per-file timeout is now disabled by default (#2)
+* **Breaking change**: changed arguments for `Coordinator`'s constructor
+* Correct signal used when requesting that stalled processes quit (use TERM
+  instead of QUIT)
+* Stop idle processes once there's no work, instead of waiting and stopping
+  everything when the suite is complete
+
 # 0.1.0
 
 * Initial version

data/README.md

@@ -95,16 +95,27 @@ Create a coordinator and tell it to run:
 
     worker_count = 4
     per_file_timeout = 5 * 60    # 5 minutes in seconds
-    rspec_args = %w(--backtrace)
+    rspec_options = %w(--backtrace)
     files = Dir['**/*_spec.rb']
 
-    coordinator = RSpec::MultiprocessRunner::Coordinator(worker_count, per_file_timeout, rspec_args, files)
+    coordinator = RSpec::MultiprocessRunner::Coordinator.new(
+      worker_count, files,
+      {
+        file_timeout_seconds: per_file_timeout,
+        rspec_options: rspec_options
+      }
+    )
     coordinator.run
 
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/cdd/rspec-multiprocess_runner.
 
+### Project infrastructure
+
+* [Source on GitHub](https://github.com/cdd/rspec-multiprocess_runner)
+* [![Build Status](https://travis-ci.org/cdd/rspec-multiprocess_runner.svg?branch=master)](https://travis-ci.org/cdd/rspec-multiprocess_runner)
+  [Continuous Integration on Travis-CI](https://travis-ci.org/cdd/rspec-multiprocess_runner)
 
 ## License
 

data/exe/multirspec

@@ -6,11 +6,27 @@ require 'rspec/multiprocess_runner/coordinator'
 options = RSpec::MultiprocessRunner::CommandLineOptions.new.parse(ARGV.dup)
 exit(2) unless options
 
-success = RSpec::MultiprocessRunner::Coordinator.new(
+coordinator = RSpec::MultiprocessRunner::Coordinator.new(
   options.worker_count,
-  options.file_timeout_seconds,
-  options.rspec_options,
-  options.files_to_run
-).run
+  options.files_to_run,
+  {
+    file_timeout_seconds: options.file_timeout_seconds,
+    example_timeout_seconds: options.example_timeout_seconds,
+    rspec_options: options.rspec_options
+  }
+)
+
+trap("INT") do
+  $stderr.puts "INT happened"
+  coordinator.shutdown(print_summary: true)
+  Kernel.exit(4)
+end
+
+trap("TERM") do
+  coordinator.shutdown
+  Kernel.exit(3)
+end
+
+success = coordinator.run
 
 exit(success ? 0 : 1)

data/lib/rspec/multiprocess_runner/command_line_options.rb

@@ -5,12 +5,13 @@ require 'pathname'
 module RSpec::MultiprocessRunner
   # @private
   class CommandLineOptions
-    attr_accessor :worker_count, :file_timeout_seconds, :rspec_options,
-      :explicit_files_or_directories, :pattern
+    attr_accessor :worker_count, :file_timeout_seconds, :example_timeout_seconds,
+      :rspec_options, :explicit_files_or_directories, :pattern
 
     def initialize
       self.worker_count = 3
-      self.file_timeout_seconds = 300
+      self.file_timeout_seconds = nil
+      self.example_timeout_seconds = 15
       self.pattern = "**/*_spec.rb"
       self.rspec_options = []
     end
@@ -58,19 +59,31 @@ module RSpec::MultiprocessRunner
       @help_requested
     end
 
+    def print_default(default_value)
+      if default_value
+        "default: #{default_value}"
+      else
+        "none by default"
+      end
+    end
+
     def build_parser
       OptionParser.new do |parser|
         parser.banner = "#{File.basename $0} [options] [files or directories] [-- rspec options]"
 
-        parser.on("-w", "--worker-count COUNT", Integer, "Number of workers to run (default: #{worker_count})") do |n|
+        parser.on("-w", "--worker-count COUNT", Integer, "Number of workers to run (#{print_default worker_count})") do |n|
           self.worker_count = n
         end
 
-        parser.on("-t", "--file-timeout SECONDS", Integer, "Maximum time to allow any single file to run (default: #{file_timeout_seconds})") do |s|
+        parser.on("-t", "--file-timeout SECONDS", Float, "Maximum time to allow any single file to run (#{print_default file_timeout_seconds})") do |s|
           self.file_timeout_seconds = s
         end
 
-        parser.on("-P", "--pattern PATTERN", "A glob to use to select files to run (default: #{pattern})") do |pattern|
+        parser.on("-T", "--example-timeout SECONDS", Float, "Maximum time to allow any single example to run (#{print_default example_timeout_seconds})") do |s|
+          self.example_timeout_seconds = s
+        end
+
+        parser.on("-P", "--pattern PATTERN", "A glob to use to select files to run (#{print_default pattern})") do |pattern|
           self.pattern = pattern
         end
 

data/lib/rspec/multiprocess_runner/coordinator.rb

@@ -4,13 +4,14 @@ require 'rspec/multiprocess_runner/worker'
 
 module RSpec::MultiprocessRunner
   class Coordinator
-    def initialize(worker_count, file_timeout, rspec_options, files)
+    def initialize(worker_count, files, options={})
       @worker_count = worker_count
-      @file_timeout = file_timeout
-      @rspec_options = rspec_options
+      @file_timeout_seconds = options[:file_timeout_seconds]
+      @example_timeout_seconds = options[:example_timeout_seconds]
+      @rspec_options = options[:rspec_options]
       @spec_files = files
       @workers = []
-      @deactivated_workers = []
+      @stopped_workers = []
     end
 
     def run
@@ -26,7 +27,23 @@ module RSpec::MultiprocessRunner
     end
 
     def failed?
-      !@deactivated_workers.empty? || any_example_failed?
+      !failed_workers.empty? || !@spec_files.empty? || any_example_failed?
+    end
+
+    def shutdown(options={})
+      if @shutting_down
+        # Immediately kill the workers if shutdown is requested again
+        end_workers_in_parallel(@workers.dup, :kill_now)
+      else
+        @shutting_down = true
+        print "Shutting down #{pluralize(@workers.size, "worker")} …" if options[:print_summary]
+        # end_workers_in_parallel modifies @workers, so dup before sending in
+        end_workers_in_parallel(@workers.dup, :shutdown_now)
+        if options[:print_summary]
+          puts " done"
+          print_summary
+        end
+      end
     end
 
     private
@@ -40,28 +57,46 @@ module RSpec::MultiprocessRunner
         act_on_available_worker_messages(0.3)
         reap_stalled_workers
         start_missing_workers
+        quit_idle_unnecessary_workers
         break unless @workers.detect(&:working?)
       end
     end
 
     def quit_all_workers
-      quit_threads = @workers.map do |worker|
+      # quit_workers modifies @workers, so dup before sending in
+      quit_workers(@workers.dup)
+    end
+
+    def end_workers_in_parallel(some_workers, end_method)
+      end_threads = some_workers.map do |worker|
+        # This method is not threadsafe because it updates instance variables.
+        # But it's fine to run it outside of the thread because it doesn't
+        # block.
+        mark_worker_as_stopped(worker)
         Thread.new do
-          worker.quit
-          worker.wait_until_quit
+          worker.send(end_method)
         end
       end
-      quit_threads.each(&:join)
+      end_threads.each(&:join)
+    end
+
+    def quit_workers(some_workers)
+      end_workers_in_parallel(some_workers, :quit_when_idle_and_wait_for_quit)
     end
 
     def work_left_to_do?
       !@spec_files.empty?
     end
 
+    def failed_workers
+      @stopped_workers.select { |w| w.deactivation_reason }
+    end
+
     def act_on_available_worker_messages(timeout)
       while (select_result = IO.select(worker_sockets, nil, nil, timeout))
         select_result.first.each do |readable_socket|
           ready_worker = @workers.detect { |worker| worker.socket == readable_socket }
+          next unless ready_worker # Worker is already gone
           worker_status = ready_worker.receive_and_act_on_message_from_worker
           if worker_status == :dead
             reap_one_worker(ready_worker, "died")
@@ -74,8 +109,12 @@ module RSpec::MultiprocessRunner
 
     def reap_one_worker(worker, reason)
       worker.reap
-      @deactivated_workers << worker
       worker.deactivation_reason = reason
+      mark_worker_as_stopped(worker)
+    end
+
+    def mark_worker_as_stopped(worker)
+      @stopped_workers << worker
       @workers.reject! { |w| w == worker }
     end
 
@@ -92,7 +131,12 @@ module RSpec::MultiprocessRunner
     def create_and_start_worker_if_necessary(n)
       if work_left_to_do?
         $stderr.puts "(Re)starting worker #{n}"
-        new_worker = Worker.new(n, @file_timeout, @rspec_options)
+        new_worker = Worker.new(
+          n,
+          file_timeout_seconds: @file_timeout_seconds,
+          example_timeout_seconds: @example_timeout_seconds,
+          rspec_options: @rspec_options
+        )
         @workers << new_worker
         new_worker.start
         new_worker.run_file(@spec_files.shift)
@@ -109,11 +153,19 @@ module RSpec::MultiprocessRunner
       end
     end
 
+    def quit_idle_unnecessary_workers
+      unless work_left_to_do?
+        idle_workers = @workers.reject(&:working?)
+        quit_workers(idle_workers)
+      end
+    end
+
     def print_summary
       elapsed = Time.now - @start_time
       by_status_and_time = combine_example_results.each_with_object({}) do |result, idx|
         (idx[result.status] ||= []) << result
       end
+      print_skipped_files_details
       print_pending_example_details(by_status_and_time["pending"])
       print_failed_example_details(by_status_and_time["failed"])
       print_failed_process_details
@@ -124,11 +176,20 @@ module RSpec::MultiprocessRunner
     end
 
     def combine_example_results
-      (@workers + @deactivated_workers).flat_map(&:example_results).sort_by { |r| r.time_finished }
+      (@workers + @stopped_workers).flat_map(&:example_results).sort_by { |r| r.time_finished }
     end
 
     def any_example_failed?
-      (@workers + @deactivated_workers).detect { |w| w.example_results.detect { |r| r.status == "failed" } }
+      (@workers + @stopped_workers).detect { |w| w.example_results.detect { |r| r.status == "failed" } }
+    end
+
+    def print_skipped_files_details
+      return if @spec_files.empty?
+      puts
+      puts "Skipped files:"
+      @spec_files.each do |spec_file|
+        puts "  - #{spec_file}"
+      end
     end
 
     def print_pending_example_details(pending_example_results)
@@ -161,21 +222,23 @@ module RSpec::MultiprocessRunner
       example_count = by_status_and_time.map { |status, results| results.size }.inject(0) { |sum, ct| sum + ct }
       failure_count = by_status_and_time["failed"] ? by_status_and_time["failed"].size : 0
       pending_count = by_status_and_time["pending"] ? by_status_and_time["pending"].size : 0
-      process_failure_count = @deactivated_workers.size
+      process_failure_count = failed_workers.size
+      skipped_count = @spec_files.size
 
       # Copied from RSpec
       summary = pluralize(example_count, "example")
       summary << ", " << pluralize(failure_count, "failure")
       summary << ", #{pending_count} pending" if pending_count > 0
       summary << ", " << pluralize(process_failure_count, "failed proc") if process_failure_count > 0
+      summary << ", " << pluralize(skipped_count, "skipped file") if skipped_count > 0
       puts summary
     end
 
     def print_failed_process_details
-      return if @deactivated_workers.empty?
+      return if failed_workers.empty?
       puts
       puts "Failed processes:"
-      @deactivated_workers.each do |worker|
+      failed_workers.each do |worker|
         puts "  - #{worker.pid} (env #{worker.environment_number}) #{worker.deactivation_reason} on #{worker.current_file}"
       end
     end

data/lib/rspec/multiprocess_runner/rake_task.rb

@@ -30,9 +30,13 @@ module RSpec::MultiprocessRunner
     attr_accessor :worker_count
 
     # The maximum number of seconds to allow a single spec file to run
-    # before killing it. Defaults to 300.
+    # before killing it. Defaults to disabled.
     attr_accessor :file_timeout_seconds
 
+    # The maximum number of seconds to allow a single example to run
+    # before killing it. Defaults to 15.
+    attr_accessor :example_timeout_seconds
+
     # Whether or not to fail Rake when an error occurs (typically when
     # examples fail). Defaults to `true`.
     attr_accessor :fail_on_error
@@ -94,6 +98,9 @@ module RSpec::MultiprocessRunner
       if worker_count
         cmd_parts << '--worker-count' << worker_count.to_s
       end
+      if example_timeout_seconds
+        cmd_parts << '--example-timeout' << example_timeout_seconds.to_s
+      end
       if file_timeout_seconds
         cmd_parts << '--file-timeout' << file_timeout_seconds.to_s
       end

data/lib/rspec/multiprocess_runner/version.rb

@@ -1,5 +1,5 @@
 module RSpec
   module MultiprocessRunner
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/rspec/multiprocess_runner/worker.rb

@@ -29,11 +29,12 @@ module RSpec::MultiprocessRunner
     STATUS_EXAMPLE_COMPLETE = "example_complete"
     STATUS_RUN_COMPLETE = "run_complete"
 
-    def initialize(environment_number, file_timeout, rspec_arguments=[])
+    def initialize(environment_number, options)
       @environment_number = environment_number
       @worker_socket, @coordinator_socket = Socket.pair(:UNIX, :STREAM)
-      @rspec_arguments = rspec_arguments + ["--format", ReportingFormatter.to_s]
-      @file_timeout = file_timeout
+      @rspec_arguments = (options[:rspec_options] || []) + ["--format", ReportingFormatter.to_s]
+      @example_timeout_seconds = options[:example_timeout_seconds]
+      @file_timeout_seconds = options[:file_timeout_seconds]
       @example_results = []
 
       # Use a single configuration and world across all individual runs
@@ -65,6 +66,17 @@ module RSpec::MultiprocessRunner
         @coordinator_socket.close
         @pid = Process.pid
         ENV["TEST_ENV_NUMBER"] = environment_number.to_s
+
+        # reset TERM handler so that
+        # - the coordinator's version (if any) is not executed twice
+        # - it actually terminates the process, instead of doing the ruby
+        #   default (throw an exception, which gets caught by RSpec)
+        Kernel.trap("TERM", "SYSTEM_DEFAULT")
+        # rely on the coordinator to handle INT
+        Kernel.trap("INT", "IGNORE")
+        # prevent RSpec from trapping INT, also
+        ::RSpec::Core::Runner.instance_eval { def self.trap_interrupt; end }
+
         set_process_name
         run_loop
       end
@@ -84,18 +96,15 @@ module RSpec::MultiprocessRunner
 
     public
 
-    def quit
+    def quit_when_idle_and_wait_for_quit
       send_message_to_worker(command: COMMAND_QUIT)
-    end
-
-    def wait_until_quit
       Process.wait(self.pid)
     end
 
     def run_file(filename)
       send_message_to_worker(command: COMMAND_RUN_FILE, filename: filename)
       @current_file = filename
-      @current_file_started_at = Time.now
+      @current_file_started_at = @current_example_started_at = Time.now
     end
 
     def working?
@@ -103,21 +112,28 @@ module RSpec::MultiprocessRunner
     end
 
     def stalled?
-      working? && (Time.now - @current_file_started_at > @file_timeout)
+      file_stalled =
+        if @file_timeout_seconds
+          working? && (Time.now - @current_file_started_at > @file_timeout_seconds)
+        end
+      example_stalled =
+        if @example_timeout_seconds
+          working? && (Time.now - @current_example_started_at > @example_timeout_seconds)
+        end
+      file_stalled || example_stalled
+    end
+
+    def shutdown_now
+      terminate_then_kill(5)
+    end
+
+    def kill_now
+      Process.kill(:KILL, pid)
+      Process.detach(pid)
     end
 
     def reap
-      begin
-        Timeout.timeout(4) do
-          $stderr.puts "Reaping troubled process #{environment_number} (#{pid}; #{@current_file}) with QUIT"
-          Process.kill(:QUIT, pid)
-          Process.wait(pid)
-        end
-      rescue Timeout::Error
-        $stderr.puts "Reaping troubled process #{environment_number} (#{pid}) with KILL"
-        Process.kill(:KILL, pid)
-        Process.wait(pid)
-      end
+      terminate_then_kill(3, "Reaping troubled process #{environment_number} (#{pid}; #{@current_file})")
     end
 
     def receive_and_act_on_message_from_worker
@@ -126,6 +142,19 @@ module RSpec::MultiprocessRunner
 
     private
 
+    def terminate_then_kill(timeout, message=nil)
+      begin
+        Timeout.timeout(timeout) do
+          $stderr.puts "#{message} with TERM" if message
+          Process.kill(:TERM, pid)
+          Process.wait(pid)
+        end
+      rescue Timeout::Error
+        $stderr.puts "#{message} with KILL" if message
+        kill_now
+      end
+    end
+
     def receive_message_from_worker
       receive_message(@coordinator_socket)
     end
@@ -136,6 +165,7 @@ module RSpec::MultiprocessRunner
       when STATUS_RUN_COMPLETE
         @current_file = nil
         @current_file_started_at = nil
+        @current_example_started_at = nil
       when STATUS_EXAMPLE_COMPLETE
         example_results << ExampleResult.new(message_hash)
         suffix =
@@ -149,6 +179,7 @@ module RSpec::MultiprocessRunner
           suffix += "\n#{message_hash["details"]}"
         end
         $stdout.puts "#{environment_number} (#{pid}): #{message_hash["description"]}#{suffix}"
+        @current_example_started_at = Time.now
       else
         $stderr.puts "Received unsupported status #{message_hash["status"].inspect} in worker #{pid}"
       end
@@ -194,16 +225,25 @@ module RSpec::MultiprocessRunner
       end
     end
 
+    def handle_closed_coordinator_socket
+      # when the coordinator socket is closed, there's nothing more to do
+      exit
+    end
+
     def receive_message_from_coordinator(socket)
       receive_message(socket)
     end
 
     def send_message_to_coordinator(message_hash)
-      send_message(@worker_socket, message_hash)
+      begin
+        send_message(@worker_socket, message_hash)
+      rescue Errno::EPIPE
+        handle_closed_coordinator_socket
+      end
     end
 
     def act_on_message_from_coordinator(message_hash)
-      return unless message_hash # ignore EOF
+      return handle_closed_coordinator_socket unless message_hash # EOF
       case message_hash["command"]
       when "quit"
         exit

metadata

@@ -1,84 +1,75 @@
 --- !ruby/object:Gem::Specification
 name: rspec-multiprocess_runner
 version: !ruby/object:Gem::Version
-  version: 0.1.0
-  prerelease: 
+  version: 0.2.0
 platform: ruby
 authors:
 - Rhett Sutphin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-12-15 00:00:00.000000000 Z
+date: 2015-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-core
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
-    - - <
+    - - "<"
       - !ruby/object:Gem::Version
         version: 2.99.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
-    - - <
+    - - "<"
       - !ruby/object:Gem::Version
         version: 2.99.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.10'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: 
@@ -89,9 +80,9 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -112,32 +103,25 @@ files:
 homepage: https://github.com/cdd/rspec-multiprocess_runner
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -1609184745420465239
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -1609184745420465239
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.4.5.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A runner for RSpec 2 that uses multiple processes to execute specs in parallel
 test_files: []