parallel_cucumber 0.2.0.pre.36 → 0.2.3

data/lib/parallel_cucumber/version.rb

@@ -1,3 +1,3 @@
 module ParallelCucumber
-  VERSION = '0.2.0.pre.36'.freeze
+  VERSION = '0.2.3'.freeze
 end

data/lib/parallel_cucumber/worker.rb

@@ -1,5 +1,6 @@
 require 'English'
 require 'timeout'
+require 'tmpdir' # I loathe Ruby.
 
 module ParallelCucumber
   class Tracker
@@ -22,15 +23,17 @@ module ParallelCucumber
   class Worker
     include ParallelCucumber::Helper::Utils
 
-    def initialize(options, index)
+    def initialize(options, index, stdout_logger)
       @batch_size = options[:batch_size]
+      @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]
-      @pretty = options[:pretty]
-      @env_variables = options[:env_variables]
+      @on_batch_error = options[:on_batch_error]
       @index = index
       @queue_connection_params = options[:queue_connection_params]
       @setup_worker = options[:setup_worker]
@@ -40,19 +43,43 @@ module ParallelCucumber
       @log_decoration = options[:log_decoration]
       @log_dir = options[:log_dir]
       @log_file = "#{@log_dir}/worker_#{index}.log"
+      @stdout_logger = stdout_logger # .sync writes only.
+    end
+
+    def autoshutting_file
+      file_handle = { log_file: @log_file }
+
+      def file_handle.write(message)
+        File.open(self[:log_file], 'a') { |f| f << message }
+      rescue => e
+        STDERR.puts "Log failure: #{e} writing '#{message.to_s.chomp}' to #{self[:log_file]}"
+      end
+
+      def file_handle.close
+      end
+
+      def file_handle.fsync
+      end
+
+      def file_handle.path
+        self[:log_file]
+      end
+
+      file_handle
     end
 
     def start(env)
       env = env.dup.merge!('WORKER_LOG' => @log_file)
 
       File.delete(@log_file) if File.exist?(@log_file)
-      File.open(@log_file, 'a') do |file_handle|
-        file_handle.sync = true
-        @logger = ParallelCucumber::CustomLogger.new(MultiDelegator.delegate(:write, :close).to(STDOUT, file_handle))
-        @logger.progname = "Worker-#{@index}"
-        @logger.level = @debug ? ParallelCucumber::CustomLogger::DEBUG : ParallelCucumber::CustomLogger::INFO
 
-        @logger.info("Starting, also logging to #{@log_file}")
+      @logger = ParallelCucumber::CustomLogger.new(autoshutting_file)
+      @logger.progname = "Worker-#{@index}"
+      @logger.level = @debug ? ParallelCucumber::CustomLogger::DEBUG : ParallelCucumber::CustomLogger::INFO
+
+      results = {}
+      begin
+        @logger.info("Logging to #{@log_file}")
 
         unless @worker_delay.zero?
           @logger.info("Waiting #{@worker_delay * @index} seconds before start")
@@ -62,39 +89,51 @@ module ParallelCucumber
         @logger.debug(<<-LOG)
         Additional environment variables: #{env.map { |k, v| "#{k}=#{v}" }.join(' ')}
         LOG
+        @logger.update_into(@stdout_logger)
 
-        results = {}
-        running_total = Hash.new(0)
+        # TODO: Replace running total with queues for passed, failed, unknown, skipped.
+        running_total = Hash.new(0) # Default new keys to 0
+        running_total[:group] = env[@group_by] if @group_by
         begin
           setup(env)
 
           queue = ParallelCucumber::Helper::Queue.new(@queue_connection_params)
+          directed_queue = ParallelCucumber::Helper::Queue.new(@queue_connection_params, "_#{@index}")
           queue_tracker = Tracker.new(queue)
 
           loop_mm, loop_ss = time_it do
             loop do
-              break if queue.empty?
+              break if queue.empty? && directed_queue.empty?
               batch = []
-              precheck(env)
+              precmd = precheck(env)
+              if (m = precmd.match(/precmd:retry-after-(\d+)-seconds/))
+                sleep(1 + m[1].to_i)
+                next
+              end
               @batch_size.times do
-                # TODO: Handle recovery of dequeued tests, if a worker dies mid-processing.
-                batch << queue.dequeue
+                # TODO: Handle recovery of possibly toxic dequeued undirected tests if a worker dies mid-processing.
+                batch << (directed_queue.empty? ? queue : directed_queue).dequeue
               end
               batch.compact!
-              batch.sort!
+              batch.sort! # Workaround for https://github.com/cucumber/cucumber-ruby/issues/952
               break if batch.empty?
 
               run_batch(env, queue_tracker, results, running_total, batch)
             end
           end
           @logger.debug("Loop took #{loop_mm} minutes #{loop_ss} seconds")
+          @logger.update_into(@stdout_logger)
+        rescue => e
+          trace = e.backtrace.join("\n\t").sub("\n\t", ": #{$ERROR_INFO}#{e.class ? " (#{e.class})" : ''}\n\t")
+          @logger.error("Threw: #{e.inspect} #{trace}")
         ensure
-          teardown(env)
-
           results[":worker-#{@index}"] = running_total
-          results
+          teardown(env)
         end
+      ensure
+        @logger.update_into(@stdout_logger)
       end
+      results
     end
 
     def run_batch(env, queue_tracker, results, running_total, tests)
@@ -104,24 +143,56 @@ module ParallelCucumber
 
       batch_mm, batch_ss = time_it do
         batch_results = test_batch(batch_id, env, running_total, tests)
-
+        begin
+          Hooks.fire_after_batch_hooks(batch_results, batch_id, env)
+        rescue => e
+          trace = e.backtrace.join("\n\t")
+          @logger.warn("There was exception in after_batch hook #{e.message} \n #{trace}")
+        end
         process_results(batch_results, tests)
-
         running_totals(batch_results, running_total)
         results.merge!(batch_results)
       end
-
+    ensure
       @logger.debug("Batch #{batch_id} took #{batch_mm} minutes #{batch_ss} seconds")
+      @logger.update_into(@stdout_logger)
     end
 
     def precheck(env)
-      return unless @pre_check
-      continue = Helper::Command.exec_command(
-        env, 'precheck', @pre_check, @log_file, @logger, @log_decoration, @batch_timeout
-      )
-      return if continue
-      @logger.error('Pre-check failed: quitting immediately')
-      raise :prechek_failed
+      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 on_batch_error(batch_env, batch_id, error_file, tests, error)
+      return unless @on_batch_error
+
+      begin
+        error_info = {
+          class: error.class,
+          message: error.message,
+          backtrace: error.backtrace
+        }
+        batch_error_info = {
+          batch_id: batch_id,
+          tests: tests,
+          error: error_info
+        }
+        File.write(error_file, batch_error_info.to_json)
+        command = "#{@on_batch_error} #{error_file}"
+        Helper::Command.exec_command(
+          batch_env, 'on_batch_error', command, @logger, @log_decoration, timeout: @batch_error_timeout
+        )
+      rescue => e
+        message = "on-batch-error failed: #{e.message}"
+        @logger.warn(message)
+      end
     end
 
     def running_totals(batch_results, running_total)
@@ -134,7 +205,7 @@ module ParallelCucumber
         running_total[s] += tt.count unless tt.empty?
       end
       running_total[:batches] += 1
-      @logger.info(running_total.sort.to_s)
+      @logger.info(running_total.sort.to_s + ' t=' + Time.now.to_s)
     end
 
     def process_results(batch_results, tests)
@@ -152,12 +223,14 @@ module ParallelCucumber
     end
 
     def test_batch(batch_id, env, running_total, tests)
-      test_batch_dir = "/tmp/w-#{batch_id}"
+      # Prefer /tmp to Mac's brain-dead /var/folders/y8/8kqjszcs2slchjx2z5lrw2t80000gp/T/w-1497514590-0 nonsense
+      prefer_tmp = ENV.fetch('PREFER_TMP', Dir.tmpdir)
+      test_batch_dir = "#{Dir.exist?(prefer_tmp) ? prefer_tmp : Dir.tmpdir}/w-#{batch_id}"
       FileUtils.rm_rf(test_batch_dir)
       FileUtils.mkpath(test_batch_dir)
 
       test_state = "#{test_batch_dir}/test_state.json"
-      cmd = "#{@test_command} #{@pretty} --format json --out #{test_state} #{@cucumber_options} "
+      cmd = "#{@test_command} --format json --out #{test_state} #{@cucumber_options} "
       batch_env = {
         :TEST_BATCH_ID.to_s => batch_id,
         :TEST_BATCH_DIR.to_s => test_batch_dir,
@@ -166,74 +239,86 @@ module ParallelCucumber
       mapped_batch_cmd, file_map = Helper::Cucumber.batch_mapped_files(cmd, test_batch_dir, batch_env)
       file_map.each { |_user, worker| FileUtils.mkpath(worker) if worker =~ %r{\/$} }
       mapped_batch_cmd += ' ' + tests.join(' ')
-      res = ParallelCucumber::Helper::Command.exec_command(
-        batch_env, 'batch', mapped_batch_cmd, @log_file, @logger, @log_decoration, @batch_timeout
-      )
-      batch_results = if res.nil?
-                        {}
-                      else
-                        Helper::Command.wrap_block(@log_decoration, 'file copy', @logger) do
-                          # Use system cp -r because Ruby's has crap diagnostics in weird situations.
-                          # Copy files we might have renamed or moved
-                          file_map.each do |user, worker|
-                            unless worker == user
-                              cp_out = `cp -Rv #{worker} #{user} 2>&1`
-                              @logger.debug("Copy of #{worker} to #{user} said: #{cp_out}")
-                            end
-                          end
-                          # Copy everything else too, in case it's interesting.
-                          cp_out = `cp -Rv #{test_batch_dir}/*  #{@log_dir} 2>&1`
-                          @logger.debug("Copy of #{test_batch_dir}/* to #{@log_dir} said: #{cp_out}")
-                          parse_results(test_state)
-                        end
-                      end
+      begin
+        ParallelCucumber::Helper::Command.exec_command(
+          batch_env, 'batch', mapped_batch_cmd, @logger, @log_decoration,
+          timeout: @batch_timeout, return_script_error: true
+        )
+      rescue => e
+        @logger << "ERROR #{e} #{e.backtrace.first(5)}"
+        error_file = "#{test_batch_dir}/error.json"
+        on_batch_error(batch_env, batch_id, error_file, tests, e)
+        return { script_failure: 1 }
+      end
+      parse_results(test_state)
     ensure
+      Helper::Command.wrap_block(@log_decoration, "file copy #{Time.now}", @logger) do
+        # Copy files we might have renamed or moved
+        file_map.each do |user, worker|
+          next if worker == user
+          Helper::Processes.cp_rv(worker, user, @logger)
+        end
+        @logger << "\nCopied files in map: #{file_map.first(5)}...#{file_map.count}  #{Time.now}\n"
+        # Copy everything else too, in case it's interesting.
+        Helper::Processes.cp_rv("#{test_batch_dir}/*", @log_dir, @logger)
+        @logger << "\nCopied everything else #{Time.now}  #{Time.now}\n"
+      end
+      @logger.update_into(@stdout_logger)
       FileUtils.rm_rf(test_batch_dir)
-      batch_results
+      @logger << "\nRemoved all files  #{Time.now}\n" # Tracking down 30 minute pause!
+      @logger.update_into(@stdout_logger)
     end
 
     def teardown(env)
       return unless @teardown_worker
       mm, ss = time_it do
-        @logger.info('Teardown running')
-        success = Helper::Command.exec_command(
-          env, 'teardown', @teardown_worker, @log_file, @logger, @log_decoration
-        )
-        @logger.warn('Teardown finished with error') unless success
+        @logger.info("\nTeardown running at #{Time.now}\n")
+
+        begin
+          Helper::Command.exec_command(
+            env, 'teardown', @teardown_worker, @logger, @log_decoration, timeout: @setup_timeout
+          )
+        rescue
+          @logger.warn('Teardown finished with error')
+        end
       end
+    ensure
       @logger.debug("Teardown took #{mm} minutes #{ss} seconds")
+      @logger.update_into(@stdout_logger)
     end
 
     def setup(env)
       return unless @setup_worker
       mm, ss = time_it do
         @logger.info('Setup running')
-        success = Helper::Command.exec_command(
-          env, 'setup', @setup_worker, @log_file, @logger, @log_decoration, @setup_timeout
-        )
-        unless success
-          @logger.warn('Setup failed: quitting immediately')
-          raise :setup_failed
+
+        begin
+          Helper::Command.exec_command(env, 'setup', @setup_worker, @logger, @log_decoration, timeout: @setup_timeout)
+        rescue
+          @logger.warn("Setup failed: #{@index} quitting immediately")
+          raise 'Setup failed: quitting immediately'
         end
       end
+    ensure
       @logger.debug("Setup took #{mm} minutes #{ss} seconds")
+      @logger.update_into(@stdout_logger)
     end
 
     def parse_results(f)
       unless File.file?(f)
         @logger.error("Results file does not exist: #{f}")
-        return {}
+        return { results_missing: 1 }
       end
       json_report = File.read(f)
       if json_report.empty?
         @logger.error("Results file is empty: #{f}")
-        return {}
+        return { results_empty: 1 }
       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}")
-      {}
+      { json_fail: 1 }
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parallel_cucumber
 version: !ruby/object:Gem::Version
-  version: 0.2.0.pre.36
+  version: 0.2.3
 platform: ruby
 authors:
 - Alexander Bayandin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-28 00:00:00.000000000 Z
+date: 2018-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber
@@ -58,28 +58,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.31'
+        version: '0.41'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.31'
+        version: '0.41'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.43'
+        version: '0.51'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.43'
+        version: '0.51'
 description: Our own parallel cucumber with queue and workers
 email: a.bayandin@gmail.com
 executables:
@@ -91,6 +91,7 @@ files:
 - bin/parallel_cucumber
 - lib/parallel_cucumber.rb
 - lib/parallel_cucumber/cli.rb
+- lib/parallel_cucumber/dsl.rb
 - lib/parallel_cucumber/helper/command.rb
 - lib/parallel_cucumber/helper/cucumber.rb
 - lib/parallel_cucumber/helper/multi_delegator.rb
@@ -98,6 +99,7 @@ files:
 - lib/parallel_cucumber/helper/queue.rb
 - lib/parallel_cucumber/helper/unittest/cucumber_test.rb
 - lib/parallel_cucumber/helper/utils.rb
+- lib/parallel_cucumber/hooks.rb
 - lib/parallel_cucumber/logger.rb
 - lib/parallel_cucumber/main.rb
 - lib/parallel_cucumber/status.rb
@@ -118,14 +120,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.6
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Run cucumber in parallel
 test_files: []
-has_rdoc: