parallel_cucumber 0.2.19 → 0.2.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ae598edd0afabdd7a9ff4ae2b117505e52a05028e79e8c01065548cf28d3298
-  data.tar.gz: acb97b25354b64a8acdd9bfc87c631135042759a16b2aa3df4717a459c0e3946
+  metadata.gz: 3c5786a5361ff67156526199fce9a686256fa49e33dc6c5af590c5f2ea17adce
+  data.tar.gz: 49d1792f94978bbfe9ea954e13dc9e0ebfe0742dad6aef966395e2885a462bdf
 SHA512:
-  metadata.gz: 731c24ee0e9d627768a97be407ab15ff2259e9ba14dae9cba0cc995100e737c64ae11fc29560a6c4eabd0faafb06a8fbdd15a880271efeba2fe08e52b2c14511
-  data.tar.gz: f2ca8028be443de6b883a99358d5e2c32de9d916768b6a0f2be01945aefc8459cd83b3e982cdc89921e2a580e0a3789fff45011d9ede4a13a5fbe23e2b485bb3
+  metadata.gz: fc9332b43d59d80cedd19f8c2fd63cb231624e318a81a40fc378bd212e1dffb90aeb0ba7c359f6dae8cccec524d5f5828eb42d7f8e976a404ea5f7dba92ed283
+  data.tar.gz: 8f57b2ba36db0f161cfdf7db981411b365d8fc5d03b4369b388898c0e21b5e064331f4f91d154340a62075d16de4571e27ce406ee2eb84523a7156661dc45f77

data/lib/parallel_cucumber/cli.rb

@@ -8,7 +8,6 @@ module ParallelCucumber
       batch_size: 1,
       batch_timeout: 600,
       setup_timeout: 30,
-      precheck_timeout: 30,
       batch_error_timeout: 30,
       cucumber_options: '',
       debug: false,
@@ -90,10 +89,6 @@ module ParallelCucumber
           options[:test_command] = test_command
         end
 
-        opts.on('--pre-batch-check COMMAND', 'Command causing worker to quit on exit failure') do |pre_check|
-          options[:pre_check] = pre_check
-        end
-
         opts.on('--log-dir DIR', 'Directory for worker logfiles') do |log_dir|
           options[:log_dir] = log_dir
         end
@@ -173,13 +168,6 @@ module ParallelCucumber
           options[:batch_timeout] = batch_timeout
         end
 
-        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

data/lib/parallel_cucumber/dsl.rb

@@ -23,6 +23,10 @@ module ParallelCucumber
         Hooks.register_after_batch(proc)
       end
 
+      def worker_health_check(&proc)
+        Hooks.register_worker_health_check(proc)
+      end
+
       def before_workers(&proc)
         Hooks.register_before_workers(proc)
       end
@@ -34,6 +38,10 @@ module ParallelCucumber
       def on_batch_error(&proc)
         Hooks.register_on_batch_error(proc)
       end
+
+      def on_dry_run_error(&proc)
+        Hooks.register_on_dry_run_error(proc)
+      end
     end
   end
 end

data/lib/parallel_cucumber/helper/command.rb

@@ -15,8 +15,13 @@ module ParallelCucumber
         end
 
         ONE_SECOND = 1
+        STACKTRACE_COLLECTION_TIMEOUT = 10
 
-        def exec_command(env, desc, script, logger, log_decoration = {}, timeout: 30, capture: false, return_script_error: false) # rubocop:disable Metrics/ParameterLists, Metrics/LineLength
+        # rubocop:disable Metrics/ParameterLists, Metrics/LineLength
+        def exec_command(env, desc, script, logger, log_decoration = {},
+                         timeout: 30, capture: false, return_script_error: false,
+                         return_on_timeout: false, collect_stacktrace: false
+        )
           block_name = ''
           if log_decoration['worker_block']
             if log_decoration['start'] || log_decoration['end']
@@ -28,42 +33,48 @@ module ParallelCucumber
           full_script = "#{script} 2>&1"
           env_string = env.map { |k, v| "#{k}=#{v}" }.sort.join(' ')
           logger << "== Running command `#{full_script}` at #{Time.now}\n== with environment variables: #{env_string}\n"
-          pstat = nil
+          wait_thread = nil
           pout = nil
           capture &&= [''] # Pass by reference
           exception = nil
+          command_pid = nil
 
           begin
             completed = begin
-              pin, pout, pstat = Open3.popen2e(env, full_script)
-              logger << "Command has pid #{pstat[:pid]}\n"
+              pin, pout, wait_thread = Open3.popen2e(env, full_script)
+              command_pid = wait_thread[:pid].to_s
+              logger << "Command has pid #{command_pid}\n"
               pin.close
               out_reader = Thread.new do
-                output_reader(pout, pstat, logger, capture)
+                output_reader(pout, wait_thread, logger, capture)
               end
 
               unless out_reader.join(timeout)
                 raise TimedOutError
               end
 
-              graceful_process_shutdown(out_reader, pstat, pout, logger)
+              graceful_process_shutdown(out_reader, wait_thread, pout, logger)
 
-              pstat.value # reap already-terminated child.
-              "Command completed #{pstat.value} at #{Time.now}"
+              wait_thread.value # reap already-terminated child.
+              "Command completed #{wait_thread.value} at #{Time.now}"
             end
 
             logger << "#{completed}\n"
 
-            raise "Script returned #{pstat.value.exitstatus}" unless pstat.value.success? || return_script_error
+            raise "Script returned #{wait_thread.value.exitstatus}" unless wait_thread.value.success? || return_script_error
 
             capture_or_empty = capture ? capture.first : '' # Even '' is truthy
-            return pstat.value.success? ? capture_or_empty : nil
+            return wait_thread.value.success? ? capture_or_empty : nil
           rescue TimedOutError => e
-            force_kill_process_with_tree(out_reader, pstat, pout, full_script, logger, timeout)
+            process_tree = Helper::Processes.ps_tree
+            send_usr1_to_process_with_tree(command_pid, full_script, logger, process_tree) if collect_stacktrace
+            force_kill_process_with_tree(out_reader, wait_thread, pout, full_script, logger, timeout, process_tree, command_pid)
+
+            return capture.first if return_on_timeout
 
             exception = e
           rescue => e
-            logger.debug("Exception #{pstat ? pstat[:pid] : "pstat=#{pstat}=nil"}")
+            logger.debug("Exception #{wait_thread ? wait_thread[:pid] : "wait_thread=#{wait_thread}=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}")
 
@@ -75,6 +86,7 @@ module ParallelCucumber
 
           raise exception
         end
+        # rubocop:enable Metrics/ParameterLists, Metrics/LineLength
 
         def log_until_incomplete_line(logger, out_string)
           loop do
@@ -87,13 +99,13 @@ module ParallelCucumber
 
         private
 
-        def output_reader(pout, pstat, logger, capture)
+        def output_reader(pout, wait_thread, 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"
+            unless io_select || wait_thread.alive?
+              logger << "\n== Terminating because io_select=#{io_select} when wait_thread.alive?=#{wait_thread.alive?}\n"
               break
             end
             next unless io_select
@@ -103,44 +115,45 @@ module ParallelCucumber
             out_string = log_until_incomplete_line(logger, out_string + partial)
           end
         rescue EOFError
-          logger << "\n== EOF is normal exit, #{pstat.inspect}\n"
+          logger << "\n== EOF is normal exit, #{wait_thread.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
+                     "pipe=#{wait_thread.status}+#{wait_thread.status ? '≤no value≥' : wait_thread.value}\n"].join
         end
 
-        def graceful_process_shutdown(out_reader, pstat, pout, logger)
-          out_reader.value # Should terminate with pstat
+        def graceful_process_shutdown(out_reader, wait_thread, pout, logger)
+          out_reader.value # Should terminate with wait_thread
           pout.close
-          if pstat.status
-            logger << "== Thread #{pstat.inspect} is not dead"
+          if wait_thread.status
+            logger << "== Thread #{wait_thread.inspect} is not dead"
 
-            if pstat.join(3)
-              logger << "== Thread #{pstat.inspect} joined late"
+            if wait_thread.join(3)
+              logger << "== Thread #{wait_thread.inspect} joined late"
             else
-              pstat.terminate # Just in case
-              logger << "== Thread #{pstat.inspect} terminated"
+              wait_thread.terminate # Just in case
+              logger << "== Thread #{wait_thread.inspect} terminated"
             end # Make an effort to reap
           end
 
-          pstat.value # reap already-terminated child.
-          "Command completed #{pstat.value} at #{Time.now}"
+          wait_thread.value # reap already-terminated child.
+          "Command completed #{wait_thread.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
+        def send_usr1_to_process_with_tree(command_pid, full_script, logger, tree)
+          return if Helper::Processes.ms_windows?
+
+          logger << "Timeout, so trying SIGUSR1 to trigger watchdog stacktrace #{command_pid}=#{full_script}"
+          Helper::Processes.kill_tree('SIGUSR1', command_pid, logger, tree)
+          sleep(STACKTRACE_COLLECTION_TIMEOUT) # Wait enough time for child processes to act on SIGUSR1
+        end
+
+        def force_kill_process_with_tree(out_reader, wait_thread, pout, full_script, logger, timeout, tree, pid) # 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)
-            sleep 2
-          end
 
-          logger << "Timeout, so trying SIGINT at #{pstat[:pid]}=#{full_script}"
+          logger << "Timeout, so trying SIGINT at #{wait_thread[:pid]}=#{full_script}"
 
           log_copy = Thread.new do
             pout.each_line { |l| logger << l }
@@ -167,7 +180,7 @@ module ParallelCucumber
             end
 
             logger << "About to reap root #{pid}"
-            pstat.value # reap root - everything else should be reaped by init.
+            wait_thread.value # reap root - everything else should be reaped by init.
             logger << "Reaped root #{pid}"
           end
         end

data/lib/parallel_cucumber/helper/cucumber/cucumber.rb

@@ -47,6 +47,13 @@ module ParallelCucumber
           report
         end
 
+        def unknown_result(tests)
+          res = tests.map do |test|
+            [test.to_sym, {status: ::ParallelCucumber::Status::UNKNOWN}]
+          end
+          res.to_h
+        end
+
         private
 
         def dry_run_report(options, args_string)

data/lib/parallel_cucumber/helper/cucumber/json_status_formatter.rb

@@ -20,6 +20,7 @@ module ParallelCucumber
             details[:exception_classname] = event.result.exception.class.to_s
             details[:exception_message] = event.result.exception.message
           end
+          details[:name] = "#{event.test_case.feature}: #{event.test_case.name}"
           details[:finish_time] = Time.now.to_i
           @result[event.test_case.location.to_s] = details
         end

data/lib/parallel_cucumber/helper/processes.rb

@@ -35,7 +35,7 @@ module ParallelCucumber
           else
             descendants(root, logger, tree, old_tree, 'kill') do |pid, node|
               begin
-                logger.warn "Killing #{node}"
+                logger.warn "Sending signal #{sig} to #{node}"
                 Process.kill(sig, pid.to_i)
               rescue Errno::ESRCH
                 nil # It's gone already? Hurrah!
@@ -44,7 +44,7 @@ module ParallelCucumber
           end
           # Let's kill pid unconditionally: descendants will go astray once reparented.
           begin
-            logger.warn "Killing #{root} just in case"
+            logger.warn "Sending signal #{sig} to root process #{root} just in case"
             Process.kill(sig, root.to_i)
           rescue Errno::ESRCH
             nil # It's gone already? Hurrah!

data/lib/parallel_cucumber/hooks.rb

@@ -1,12 +1,19 @@
 module ParallelCucumber
   class Hooks
-    @before_batch_hooks ||= []
-    @after_batch_hooks  ||= []
-    @before_workers     ||= []
-    @after_workers      ||= []
-    @on_batch_error     ||= []
+    @worker_health_check ||= []
+    @before_batch_hooks  ||= []
+    @after_batch_hooks   ||= []
+    @before_workers      ||= []
+    @after_workers       ||= []
+    @on_batch_error      ||= []
+    @on_dry_run_error    ||= []
 
     class << self
+      def register_worker_health_check(proc)
+        raise(ArgumentError, 'Please provide a valid callback') unless proc.respond_to?(:call)
+        @worker_health_check << proc
+      end
+
       def register_before_batch(proc)
         raise(ArgumentError, 'Please provide a valid callback') unless proc.respond_to?(:call)
         @before_batch_hooks << proc
@@ -32,6 +39,17 @@ module ParallelCucumber
         @on_batch_error << proc
       end
 
+      def register_on_dry_run_error(proc)
+        raise(ArgumentError, 'Please provide a valid callback') unless proc.respond_to?(:call)
+        @on_dry_run_error << proc
+      end
+
+      def fire_worker_health_check(*args)
+        @worker_health_check.each do |hook|
+          hook.call(*args)
+        end
+      end
+
       def fire_before_batch_hooks(*args)
         @before_batch_hooks.each do |hook|
           hook.call(*args)
@@ -61,6 +79,12 @@ module ParallelCucumber
           hook.call(*args)
         end
       end
+
+      def fire_on_dry_run_error(error)
+        @on_dry_run_error.each do |hook|
+          hook.call(error)
+        end
+      end
     end
   end
 end

data/lib/parallel_cucumber/main.rb

@@ -30,8 +30,12 @@ module ParallelCucumber
         exit(1)
       end
 
-      all_tests = Helper::Cucumber.selected_tests(@options[:cucumber_options], @options[:cucumber_args])
-
+      begin
+        all_tests = Helper::Cucumber.selected_tests(@options[:cucumber_options], @options[:cucumber_args])
+      rescue StandardError => error
+        Hooks.fire_on_dry_run_error(error)
+        raise error
+      end
       if all_tests.empty?
         @logger.info('There is no tests to run, exiting...')
         exit(0)

data/lib/parallel_cucumber/version.rb

@@ -1,3 +1,3 @@
 module ParallelCucumber
-  VERSION = '0.2.19'.freeze
+  VERSION = '0.2.24'.freeze
 end

data/lib/parallel_cucumber/worker.rb

@@ -10,11 +10,9 @@ module ParallelCucumber
       @group_by = options[:group_by]
       @batch_timeout = options[:batch_timeout]
       @batch_error_timeout = options[:batch_error_timeout]
-      @precheck_timeout = options[:precheck_timeout]
       @setup_timeout = options[:setup_timeout]
       @cucumber_options = options[:cucumber_options]
       @test_command = options[:test_command]
-      @pre_check = options[:pre_check]
       @index = index
       @name = "W#{@index}"
       @setup_worker = options[:setup_worker]
@@ -99,12 +97,7 @@ module ParallelCucumber
               job = @jobs_queue.pop(false)
               case job.type
               when Job::PRECHECK
-                precmd = precheck(env)
-                if (m = precmd.match(/precmd:retry-after-(\d+)-seconds/))
-                  @manager.inform_idle(@name)
-                  sleep(1 + m[1].to_i)
-                  next
-                end
+                Hooks.fire_worker_health_check(env)
                 @manager.inform_healthy(@name)
               when Job::RUN_TESTS
                 run_batch(env, results, running_total, job.details)
@@ -161,18 +154,6 @@ module ParallelCucumber
       @logger.update_into(@stdout_logger)
     end
 
-    def precheck(env)
-      return 'default no-op pre_check' unless @pre_check
-      begin
-        return Helper::Command.exec_command(
-          env, 'precheck', @pre_check, @logger, @log_decoration, timeout: @precheck_timeout, capture: true
-        )
-      rescue
-        @logger.error('Pre-check failed: quitting immediately')
-        raise 'Pre-check failed: quitting immediately'
-      end
-    end
-
     def running_totals(batch_results, running_total)
       batch_info = Status.constants.map do |status|
         status = Status.const_get(status)
@@ -220,7 +201,8 @@ module ParallelCucumber
       begin
         ParallelCucumber::Helper::Command.exec_command(
           batch_env, 'batch', mapped_batch_cmd, @logger, @log_decoration,
-          timeout: @batch_timeout, return_script_error: true
+          timeout: @batch_timeout, capture: true, return_script_error: true,
+          return_on_timeout: true, collect_stacktrace: true
         )
       rescue => e
         @logger << "ERROR #{e} #{e.backtrace.first(5)}"
@@ -232,7 +214,7 @@ module ParallelCucumber
           @logger.warn("There was exception in on_batch_error hook #{exc.message} \n #{trace}")
         end
 
-        return tests.map { |t| [t, ::ParallelCucumber::Status::UNKNOWN] }.to_h
+        return Helper::Cucumber.unknown_result(tests)
       end
       parse_results(test_state, tests)
     ensure
@@ -291,18 +273,18 @@ module ParallelCucumber
     def parse_results(f, tests)
       unless File.file?(f)
         @logger.error("Results file does not exist: #{f}")
-        return tests.map { |t| [t, ::ParallelCucumber::Status::UNKNOWN] }.to_h
+        return Helper::Cucumber.unknown_result(tests)
       end
       json_report = File.read(f)
       if json_report.empty?
         @logger.error("Results file is empty: #{f}")
-        return tests.map { |t| [t, ::ParallelCucumber::Status::UNKNOWN] }.to_h
+        return Helper::Cucumber.unknown_result(tests)
       end
       Helper::Cucumber.parse_json_report(json_report)
     rescue => e
       trace = e.backtrace.join("\n\t").sub("\n\t", ": #{$ERROR_INFO}#{e.class ? " (#{e.class})" : ''}\n\t")
       @logger.error("Threw: JSON parse of results caused #{trace}")
-      tests.map { |t| [t, ::ParallelCucumber::Status::UNKNOWN] }.to_h
+      Helper::Cucumber.unknown_result(tests)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parallel_cucumber
 version: !ruby/object:Gem::Version
-  version: 0.2.19
+  version: 0.2.24
 platform: ruby
 authors:
 - Alexander Bayandin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-24 00:00:00.000000000 Z
+date: 2021-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.59.2
+        version: 0.73.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.59.2
+        version: 0.73.0
 description: Our own parallel cucumber with queue and workers
 email: a.bayandin@gmail.com
 executables:
@@ -127,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Run cucumber in parallel