parallel_cucumber 0.2.0.pre.36 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9a409cddb7ad8882664b62866dd1d9ffb39caa9d
-  data.tar.gz: 0224ea5dd38f661176160e0534f1b5c673f9d147
+  metadata.gz: c446c47f0dd453f9b1a8f66e11d374fbf6e16b2e
+  data.tar.gz: 7a15cd91d8a712344a63d843899278d52a8d86b1
 SHA512:
-  metadata.gz: 155b9bd2377687099c769731f2cf576d4e8984883745adadc08a48ac6403ea0f6e779714c0ade86b2dc816f469733ce78cb22c7826b195c6aed74df7fb3cca33
-  data.tar.gz: bd51ffc599151b873599bff76353b3c565f878d18262b6d1c981b364eb708ac3fa6e3e89e611987124a56d110337873d0a2b498d07a57a59944033a3bcf9c8e5
+  metadata.gz: 9c24151c5b51f480adcfc7641b9e5f784ac397c875c7568d60a36451af2ac7569d67f95ddc68ce31fd0f5331323d8bf6aa5fc58b70bcb86e28b0071cc4ecaaa9
+  data.tar.gz: 4f2a5adf38c27af996b465fb60da139aee157c3becc975332e1e95a3a0fec857fb5ff027ee1145bd5ee453abcf634d1335184e3b160a19660332c9e00e0cb4e0

data/README.md

@@ -7,17 +7,31 @@ Usage: parallel_cucumber [options] [ [FILE|DIR|URL][:LINE[:LINE]*] ]
 Example: parallel_cucumber -n 4 -o "-f pretty -f html -o report.html" examples/i18n/en/features
     -n WORKERS                       How many workers to use. Default is 1 or longest list in -e
     -o, --cucumber-options "OPTIONS" Run cucumber with these options
+    -r, --require "file_path"        Load files for parallel_cucumber
+        --directed-tests JSON        Direct tests to specific workers, e.g. {"0": "-t @head"}
         --test-command COMMAND       Command to run for test phase, default cucumber
         --pre-batch-check COMMAND    Command causing worker to quit on exit failure
+        --on-batch-error COMMAND     Command to call on any error happened while running batch of tests.
+                 It will receive as argument json file with list of tests and error happened.
+        --no-pretty                  Now a no-op for compatibility there is no default pretty
+        --log-dir DIR                Directory for worker logfiles
+        --log-decoration JSON        Block quoting for logs, e.g. {start: "#start %s", end: "#end %s"}
+        --summary JSON               Summary files, e.g. {failed: "./failed.txt", unknown: "./unknown.txt"}
     -e, --env-variables JSON         Set additional environment variables to processes
         --batch-size SIZE            How many tests each worker takes from queue at once. Default is 1
+        --group-by ENV_VAR           Key for cumulative report
     -q ARRAY,                        `url,name` Url for TCP connection: `redis://[password]@[hostname]:[port]/[db]` (password, port and database are optional), for unix socket connection: `unix://[path to Redis socket]`. Default is redis://127.0.0.1:6379 and name is `queue`
         --queue-connection-params
         --setup-worker SCRIPT        Execute SCRIPT before each worker
         --teardown-worker SCRIPT     Execute SCRIPT after each worker
         --worker-delay SECONDS       Delay before next worker starting. Could be used for avoiding 'spikes' in CPU and RAM usage Default is 0
         --batch-timeout SECONDS      Timeout for each batch of tests. Default is 600
+        --precheck-timeout SECONDS   Timeout for each test precheck. Default is 600
+        --batch-error-timeout SECONDS
+                                     Timeout for each batch_error script. Default is 30
+        --setup-timeout SECONDS      Timeout for each worker's set-up phase. Default is 30
         --debug                      Print more debug information
+        --long-running-tests STRING  Cucumber arguments for long-running-tests
     -v, --version                    Show version
     -h, --help                       Show this
 ```

data/lib/parallel_cucumber.rb

@@ -10,3 +10,4 @@ require 'parallel_cucumber/main'
 require 'parallel_cucumber/status'
 require 'parallel_cucumber/version'
 require 'parallel_cucumber/worker'
+require 'parallel_cucumber/hooks'

data/lib/parallel_cucumber/cli.rb

@@ -8,8 +8,11 @@ module ParallelCucumber
       batch_size: 1,
       batch_timeout: 600,
       setup_timeout: 30,
+      precheck_timeout: 30,
+      batch_error_timeout: 30,
       cucumber_options: '',
       debug: false,
+      directed_tests: {},
       log_dir: '.',
       log_decoration: {},
       env_variables: {},
@@ -62,6 +65,21 @@ module ParallelCucumber
           options[:cucumber_options] = cucumber_options
         end
 
+        opts.on('-r', '--require "file_path"', 'Load files for parallel_cucumber') do |load_file|
+          raise(ArgumentError, "No such file to load: #{load_file}") unless File.exist?(load_file)
+          options[:load_files] ||= []
+          options[:load_files] << load_file
+        end
+
+        opts.on('--directed-tests JSON', 'Direct tests to specific workers, e.g. {"0": "-t @head"}') do |json|
+          options[:directed_tests] = begin
+            JSON.parse(json)
+          rescue JSON::ParserError
+            puts 'Log block quoting not in JSON format. Did you forget to escape the quotes?'
+            raise
+          end
+        end
+
         opts.on('--test-command COMMAND',
                 "Command to run for test phase, default #{DEFAULTS[:test_command]}") do |test_command|
           options[:test_command] = test_command
@@ -71,11 +89,14 @@ module ParallelCucumber
           options[:pre_check] = pre_check
         end
 
-        options[:pretty] = '--format pretty'
-        opts.on('--no-pretty', "Suppress the default 'pretty' formatter directed at stdout") do
-          options[:pretty] = ''
+        opts.on('--on-batch-error COMMAND',
+                'Command to call on any error happened while running batch of tests.
+                 It will receive as argument json file with list of tests and error happened.') do |on_batch_error|
+          options[:on_batch_error] = on_batch_error
         end
 
+        opts.on('--no-pretty', 'Now a no-op for compatibility there is no default pretty') {}
+
         opts.on('--log-dir DIR', 'Directory for worker logfiles') do |log_dir|
           options[:log_dir] = log_dir
         end
@@ -108,7 +129,7 @@ module ParallelCucumber
         end
 
         help_message = "How many tests each worker takes from queue at once. Default is #{DEFAULTS[:batch_size]}"
-        opts.on('--batch-size SIZE', Integer, help_message.gsub(/\s+/, ' ').strip) do |batch_size|
+        opts.on('--batch-size SIZE', Integer, help_message) do |batch_size|
           if batch_size < 1
             puts "The minimum batch size is 1 but given: '#{batch_size}'"
             exit 1
@@ -116,14 +137,18 @@ module ParallelCucumber
           options[:batch_size] = batch_size
         end
 
-        help_message = <<-TEXT
+        opts.on('--group-by ENV_VAR', 'Key for cumulative report') do |group_by|
+          options[:group_by] = group_by
+        end
+
+        help_message = <<-TEXT.gsub(/\s+/, ' ').strip
          `url,name`
           Url for TCP connection:
           `redis://[password]@[hostname]:[port]/[db]` (password, port and database are optional),
           for unix socket connection: `unix://[path to Redis socket]`.
           Default is redis://127.0.0.1:6379 and name is `queue`
         TEXT
-        opts.on('-q', '--queue-connection-params ARRAY', Array, help_message.gsub(/\s+/, ' ').strip) do |params|
+        opts.on('-q', '--queue-connection-params ARRAY', Array, help_message) do |params|
           options[:queue_connection_params] = params
         end
 
@@ -135,26 +160,40 @@ module ParallelCucumber
           options[:teardown_worker] = script
         end
 
-        help_message = <<-TEXT
+        help_message = <<-TEXT.gsub(/\s+/, ' ').strip
           Delay before next worker starting.
           Could be used for avoiding 'spikes' in CPU and RAM usage
           Default is #{DEFAULTS[:worker_delay]}
         TEXT
-        opts.on('--worker-delay SECONDS', Float, help_message.gsub(/\s+/, ' ').strip) do |worker_delay|
+        opts.on('--worker-delay SECONDS', Float, help_message) do |worker_delay|
           options[:worker_delay] = worker_delay
         end
 
-        help_message = <<-TEXT
+        help_message = <<-TEXT.gsub(/\s+/, ' ').strip
           Timeout for each batch of tests. Default is #{DEFAULTS[:batch_timeout]}
         TEXT
-        opts.on('--batch-timeout SECONDS', Float, help_message.gsub(/\s+/, ' ').strip) do |batch_timeout|
+        opts.on('--batch-timeout SECONDS', Float, help_message) do |batch_timeout|
           options[:batch_timeout] = batch_timeout
         end
 
-        help_message = <<-TEXT
+        help_message = <<-TEXT.gsub(/\s+/, ' ').strip
+          Timeout for each test precheck. Default is #{DEFAULTS[:batch_timeout]}
+        TEXT
+        opts.on('--precheck-timeout SECONDS', Float, help_message) do |timeout|
+          options[:precheck_timeout] = timeout
+        end
+
+        help_message = <<-TEXT.gsub(/\s+/, ' ').strip
+          Timeout for each batch_error script. Default is #{DEFAULTS[:batch_error_timeout]}
+        TEXT
+        opts.on('--batch-error-timeout SECONDS', Float, help_message) do |timeout|
+          options[:batch_error_timeout] = timeout
+        end
+
+        help_message = <<-TEXT.gsub(/\s+/, ' ').strip
           Timeout for each worker's set-up phase. Default is #{DEFAULTS[:setup_timeout]}
         TEXT
-        opts.on('--setup-timeout SECONDS', Float, help_message.gsub(/\s+/, ' ').strip) do |setup_timeout|
+        opts.on('--setup-timeout SECONDS', Float, help_message) do |setup_timeout|
           options[:setup_timeout] = setup_timeout
         end
 
@@ -162,6 +201,11 @@ module ParallelCucumber
           options[:debug] = debug
         end
 
+        help_message = 'Cucumber arguments for long-running-tests'
+        opts.on('--long-running-tests STRING', String, help_message) do |cucumber_long_run_args|
+          options[:long_running_tests] = cucumber_long_run_args
+        end
+
         opts.on('-v', '--version', 'Show version') do
           puts ParallelCucumber::VERSION
           exit 0
@@ -174,7 +218,7 @@ module ParallelCucumber
       end
 
       option_parser.parse!(argv)
-      options[:cucumber_args] = argv
+      options[:cucumber_args] = argv.join(' ')
 
       options
     rescue OptionParser::InvalidOption => e

data/lib/parallel_cucumber/dsl.rb

@@ -0,0 +1,18 @@
+require_relative 'hooks'
+
+module ParallelCucumber
+  module DSL
+    class << self
+
+      # Registers a callback hook which will be called at the end of every batch
+      # There can be more than one after_batch, they will be invoked sequentially
+      # If one hook fails, rest all will be skipped
+      # @yieldparam [optional, Hash] batch_results results of all tests in a batch
+      # @yieldparam [optional, String] batch_id batch id
+      # @yieldparam [optional, Hash] batch_env env of batch
+      def after_batch(&proc)
+        Hooks.register_after_batch(proc)
+      end
+    end
+  end
+end

data/lib/parallel_cucumber/helper/command.rb

@@ -1,85 +1,176 @@
 module ParallelCucumber
   module Helper
     module Command
+      class TimedOutError < RuntimeError; end
       class << self
         def wrap_block(log_decoration, block_name, logger)
+          [$stdout, $stderr].each(&:flush)
           logger << format(log_decoration['start'] + "\n", block_name) if log_decoration['start']
+          [$stdout, $stderr].each(&:flush)
           yield
         ensure
+          [$stdout, $stderr].each(&:flush)
           logger << format(log_decoration['end'] + "\n", block_name) if log_decoration['end']
+          [$stdout, $stderr].each(&:flush)
         end
 
-        def exec_command(env, desc, script, log_file, logger, log_decoration = {}, timeout = 30) # rubocop:disable Metrics/ParameterLists, Metrics/LineLength
-          file = File.open(log_file)
-          file.seek(0, File::SEEK_END)
-          full_script = "#{script} >>#{log_file} 2>&1"
+        ONE_SECOND = 1
+
+        def exec_command(env, desc, script, logger, log_decoration = {}, timeout: 30, capture: false, return_script_error: false) # rubocop:disable Metrics/ParameterLists, Metrics/LineLength
+          block_name = ''
+          if log_decoration['worker_block']
+            if log_decoration['start'] || log_decoration['end']
+              block_name = "#{"#{env['TEST_USER']}-w#{env['WORKER_INDEX']}>"} #{desc}"
+            end
+          end
+
+          logger << format(log_decoration['start'] + "\n", block_name) if log_decoration['start']
+          full_script = "#{script} 2>&1"
           env_string = env.map { |k, v| "#{k}=#{v}" }.sort.join(' ')
-          message = <<-LOG
-        Running command `#{full_script}` with environment variables: #{env_string}
-          LOG
-          logger.debug(message)
+          logger << "== Running command `#{full_script}` at #{Time.now}\n== with environment variables: #{env_string}\n"
           pstat = nil
           pout = nil
+          capture &&= [''] # Pass by reference
+          exception = nil
+
           begin
-            completed = Timeout.timeout(timeout) do
+            completed = begin
               pin, pout, pstat = Open3.popen2e(env, full_script)
-              logger.debug("Command has pid #{pstat[:pid]}")
+              logger << "Command has pid #{pstat[:pid]}\n"
               pin.close
-              out = pout.readlines.join("\n") # Not expecting anything in 'out' due to redirection, but...
-              pout.close
-              pstat.value # N.B. Await process termination
-              "Command completed #{pstat.value} and expecting '#{out}' to be empty due to redirects"
-            end
-            logger.debug(completed)
-            # system("lsof #{log_file} >> #{log_file} 2>&1")
-            system("ps -axf | grep '#{pstat[:pid]}\\s' >> #{log_file}")
-            return pstat.value.success?
-          rescue Timeout::Error
-            pout.close
-            logger.debug("Timeout, so trying SIGINT #{pstat[:pid]}")
-            wait_sigint = 15
-            logger.error("Timeout #{timeout}s was reached. Sending SIGINT(2), then waiting up to #{wait_sigint}s")
-            tree = Helper::Processes.ps_tree
-            begin
-              Helper::Processes.kill_tree('SIGINT', pstat[:pid].to_s, tree)
-              timed_out = wait_sigint.times do |t|
-                break if Helper::Processes.all_pids_dead?(pstat[:pid].to_s, nil, tree)
-                logger.info("Wait dead #{t}")
-                sleep 1
+              out_reader = Thread.new do
+                output_reader(pout, pstat, logger, capture)
               end
-              if timed_out
-                logger.error("Process #{pstat[:pid]} lasted #{wait_sigint}s after SIGINT(2), so SIGKILL(9)! Fatality!")
-                Helper::Processes.kill_tree('SIGKILL', pstat[:pid].to_s, nil, tree)
+
+              unless out_reader.join(timeout)
+                raise TimedOutError
               end
-              logger.debug("About to reap root #{pstat[:pid]}")
-              pstat.value # reap root - everything else should be reaped by init.
-              logger.debug("Reaped root #{pstat[:pid]}")
-              # system("lsof #{log_file} >> #{log_file}")
-              logger.debug("Tried SIGKILL #{pstat[:pid]} - hopefully no processes still have #{log_file}!")
+
+              graceful_process_shutdown(out_reader, pstat, pout, logger)
+
+              pstat.value # reap already-terminated child.
+              "Command completed #{pstat.value} at #{Time.now}"
             end
+
+            logger << "#{completed}\n"
+
+            raise "Script returned #{pstat.value.exitstatus}" unless pstat.value.success? || return_script_error
+
+            capture_or_empty = capture ? capture.first : '' # Even '' is truthy
+            return pstat.value.success? ? capture_or_empty : nil
+          rescue TimedOutError => e
+            force_kill_process_with_tree(out_reader, pstat, pout, full_script, logger, timeout)
+
+            exception = e
           rescue => e
             logger.debug("Exception #{pstat ? pstat[:pid] : "pstat=#{pstat}=nil"}")
             trace = e.backtrace.join("\n\t").sub("\n\t", ": #{$ERROR_INFO}#{e.class ? " (#{e.class})" : ''}\n\t")
-            logger.error("Threw: for #{full_script}, caused #{trace}")
+            logger.error("Threw for #{full_script}, caused #{trace}")
+
+            exception = e
           ensure
-            # It's only logging - don't really care if we lose some, though it would be nice if we didn't.
-            if log_decoration['worker_block']
-              prefix = "#{env['TEST_USER']}-w#{env['WORKER_INDEX']}>"
-              block_name = ''
-              if log_decoration['start'] || log_decoration['end']
-                block_name = "#{prefix} #{desc}"
-                prefix = ''
-              end
-              message = ''
-              message << format(log_decoration['start'] + "\n", block_name) if log_decoration['start']
-              message << "#{prefix}#{file.readline}" until file.eof
-              message << format(log_decoration['end'] + "\n", block_name) if log_decoration['end']
-              logger << message
-              file.close
+            logger << format(log_decoration['end'] + "\n", block_name) if log_decoration['end']
+          end
+          logger.error("*** UNUSUAL TERMINATION FOR: #{script}")
+
+          raise exception
+        end
+
+        def log_until_incomplete_line(logger, out_string)
+          loop do
+            line, out_string = out_string.split(/\n/, 2)
+            return line || '' unless out_string
+            logger << line
+            logger << "\n"
+          end
+        end
+
+        private
+
+        def output_reader(pout, pstat, logger, capture)
+          out_string = ''
+
+          loop do
+            io_select = IO.select([pout], [], [], ONE_SECOND)
+            unless io_select || pstat.alive?
+              logger << "\n== Terminating because io_select=#{io_select} when pstat.alive?=#{pstat.alive?}\n"
+              break
             end
+            next unless io_select
+            # Windows doesn't support read_nonblock!
+            partial = pout.readpartial(8192)
+            capture[0] += partial if capture
+            out_string = log_until_incomplete_line(logger, out_string + partial)
+          end
+        rescue EOFError
+          logger << "\n== EOF is normal exit, #{pstat.inspect}\n"
+        rescue => e
+          logger << "\n== Exception in out_reader due to #{e.inspect} #{e.backtrace}\n"
+        ensure
+          logger << out_string
+          logger << ["\n== Left out_reader at #{Time.now}; ",
+                     "pipe=#{pstat.status}+#{pstat.status ? '≤no value≥' : pstat.value}\n"].join
+        end
+
+        def graceful_process_shutdown(out_reader, pstat, pout, logger)
+          out_reader.value # Should terminate with pstat
+          pout.close
+          if pstat.status
+            logger << "== Thread #{pstat.inspect} is not dead"
+
+            if pstat.join(3)
+              logger << "== Thread #{pstat.inspect} joined late"
+            else
+              pstat.terminate # Just in case
+              logger << "== Thread #{pstat.inspect} terminated"
+            end # Make an effort to reap
+          end
+
+          pstat.value # reap already-terminated child.
+          "Command completed #{pstat.value} at #{Time.now}"
+        end
+
+        def force_kill_process_with_tree(out_reader, pstat, pout, full_script, logger, timeout) # rubocop:disable Metrics/ParameterLists, Metrics/LineLength
+          out_reader.exit
+          tree = Helper::Processes.ps_tree
+          pid = pstat[:pid].to_s
+          unless Helper::Processes.ms_windows?
+            logger << "Timeout, so trying SIGUSR1 to trigger watchdog stacktrace #{pstat[:pid]}=#{full_script}"
+            Helper::Processes.kill_tree('SIGUSR1', pid, logger, tree)
+            logger << %x(ps -ax)
+            sleep 2
+          end
+
+          logger << "Timeout, so trying SIGINT at #{pstat[:pid]}=#{full_script}"
+
+          log_copy = Thread.new do
+            pout.each_line { |l| logger << l }
+          end
+          log_copy.exit unless log_copy.join(2)
+
+          pout.close
+
+          wait_sigint = 15
+          logger << "Timeout #{timeout}s was reached. Sending SIGINT(2), SIGKILL after #{wait_sigint}s."
+          begin
+            Helper::Processes.kill_tree('SIGINT', pid, logger, tree)
+
+            timed_out = wait_sigint.times do |t|
+              break if Helper::Processes.all_pids_dead?(pid, logger, nil, tree)
+              logger << "Wait dead #{t} pid #{pid}"
+              sleep 1
+            end
+
+            if timed_out
+              logger << "Process #{pid} lasted #{wait_sigint}s after SIGINT(2), so SIGKILL(9)! Fatality!"
+              Helper::Processes.kill_tree('SIGKILL', pid, logger, nil, tree)
+              logger << "Tried SIGKILL #{pid}!"
+            end
+
+            logger << "About to reap root #{pid}"
+            pstat.value # reap root - everything else should be reaped by init.
+            logger << "Reaped root #{pid}"
           end
-          logger.debug("Unusual termination for command: #{script}")
-          nil
         end
       end
     end