Ignore sysinfo pre/post abortions.

server/autotest.py

 # Copyright 2007 Google Inc. Released under the GPL v2
 
 import re, os, sys, traceback, subprocess, time, pickle, glob, tempfile
 import logging, getpass
 from autotest_lib.server import installable_object, prebuild, utils
 from autotest_lib.client.common_lib import base_job, log, error, autotemp
 from autotest_lib.client.common_lib import global_config, packages
 from autotest_lib.client.common_lib import utils as client_utils
 
 AUTOTEST_SVN  = 'svn://test.kernel.org/autotest/trunk/client'
@@ skipping 265 matching lines @@
         try:
             utils.system('tools/make_clean', ignore_status=True)
         finally:
             os.chdir(cwd)
         super(BaseAutotest, self).get(location)
         self.got = True
 
 
     def run(self, control_file, results_dir='.', host=None, timeout=None,
             tag=None, parallel_flag=False, background=False,
-            client_disconnect_timeout=1800):
+            client_disconnect_timeout=1800, ignore_aborts=False):
         """
         Run an autotest job on the remote machine.
 
         @param control_file: An open file-like-obj of the control file.
         @param results_dir: A str path where the results should be stored
                 on the local filesystem.
         @param host: A Host instance on which the control file should
                 be run.
         @param timeout: Maximum number of seconds to wait for the run or None.
         @param tag: Tag name for the client side instance of autotest.
         @param parallel_flag: Flag set when multiple jobs are run at the
                 same time.
         @param background: Indicates that the client should be launched as
                 a background job; the code calling run will be responsible
                 for monitoring the client and collecting the results.
         @param client_disconnect_timeout: Seconds to wait for the remote host
                 to come back after a reboot.  [default: 30 minutes]
+        @param ignore_aborts: If the Autotest client aborts unexpectedly, don't
+                record job status as ABORT.
 
         @raises AutotestRunError: If there is a problem executing
                 the control file.
         """
         host = self._get_host_and_setup(host)
         results_dir = os.path.abspath(results_dir)
 
         if tag:
             results_dir = os.path.join(results_dir, tag)
 
         atrun = _Run(host, results_dir, tag, parallel_flag, background)
         self._do_run(control_file, results_dir, host, atrun, timeout,
-                     client_disconnect_timeout)
+                     client_disconnect_timeout, ignore_aborts)
 
 
     def _get_host_and_setup(self, host):
         if not host:
             host = self.host
         if not self.installed:
             self.install(host)
 
         host.wait_up(timeout=30)
         return host
 
 
     def _do_run(self, control_file, results_dir, host, atrun, timeout,
-                client_disconnect_timeout):
+                client_disconnect_timeout, ignore_aborts):
         try:
             atrun.verify_machine()
         except:
             logging.error("Verify failed on %s. Reinstalling autotest",
                           host.hostname)
             self.install(host)
         atrun.verify_machine()
         debug = os.path.join(results_dir, 'debug')
         try:
             os.makedirs(debug)
@@ skipping 48 matching lines @@
         host.send_file(state_file, atrun.remote_control_file + '.init.state')
         os.remove(state_file)
 
         # Copy control_file to remote_control_file on the host
         host.send_file(tmppath, atrun.remote_control_file)
         if os.path.abspath(tmppath) != os.path.abspath(control_file):
             os.remove(tmppath)
 
         atrun.execute_control(
                 timeout=timeout,
-                client_disconnect_timeout=client_disconnect_timeout)
+                client_disconnect_timeout=client_disconnect_timeout,
+                ignore_aborts=ignore_aborts)
 
 
     def run_timed_test(self, test_name, results_dir='.', host=None,
                        timeout=None, *args, **dargs):
         """
         Assemble a tiny little control file to just run one test,
         and run it as an autotest client-side test
         """
         if not host:
             host = self.host
@@ skipping 243 matching lines @@
                     return result
                 elif not self.host.wait_up(client_disconnect_timeout):
                     raise error.AutoservSSHTimeout(
                         "client was disconnected, reconnect timed out")
         finally:
             client_log.close()
             self.host.job.pop_execution_context()
 
 
     def execute_section(self, section, timeout, stderr_redirector,
-                        client_disconnect_timeout):
+                        client_disconnect_timeout, ignore_aborts=False):
         logging.info("Executing %s/bin/autotest %s/control phase %d",
                      self.autodir, self.autodir, section)
 
         if self.background:
             result = self._execute_in_background(section, timeout)
         else:
             result = self._execute_daemon(section, timeout, stderr_redirector,
                                           client_disconnect_timeout)
 
         last_line = stderr_redirector.last_line
 
         # check if we failed hard enough to warrant an exception
         if result.exit_status == 1:
             err = error.AutotestRunError("client job was aborted")
         elif not self.background and not result.stderr:
             err = error.AutotestRunError(
                 "execute_section %s failed to return anything\n"
                 "stdout:%s\n" % (section, result.stdout))
         else:
             err = None
 
         # log something if the client failed AND never finished logging
-        if err and not self.is_client_job_finished(last_line):
+        if (err and not self.is_client_job_finished(last_line)
+            and not ignore_aborts):
             self.log_unexpected_abort(stderr_redirector)
 
         if err:
             raise err
         else:
             return stderr_redirector.last_line
 
 
     def _wait_for_reboot(self, old_boot_id):
         logging.info("Client is rebooting")
@@ skipping 14 matching lines @@
                 self.host.hardreset(wait=False)
             except (AttributeError, error.AutoservUnsupportedError):
                 warning = "Hard reset unsupported on %s"
                 warning %= self.host.hostname
                 logging.warning(warning)
             raise error.AutotestRunError("%s failed to boot after %ds" %
                                          (self.host.hostname, BOOT_TIME))
         self.host.reboot_followup()
 
 
-    def execute_control(self, timeout=None, client_disconnect_timeout=None):
+    def execute_control(self, timeout=None, client_disconnect_timeout=None,
+                        ignore_aborts=False):
         if not self.background:
             collector = log_collector(self.host, self.tag, self.results_dir)
             hostname = self.host.hostname
             remote_results = collector.client_results_dir
             local_results = collector.server_results_dir
             self.host.job.add_client_log(hostname, remote_results,
                                          local_results)
             job_record_context = self.host.job.get_record_context()
 
         section = 0
         start_time = time.time()
 
         logger = client_logger(self.host, self.tag, self.results_dir)
         try:
             while not timeout or time.time() < start_time + timeout:
                 if timeout:
                     section_timeout = start_time + timeout - time.time()
                 else:
                     section_timeout = None
                 boot_id = self.host.get_boot_id()
                 last = self.execute_section(section, section_timeout,
-                                            logger, client_disconnect_timeout)
+                                            logger, client_disconnect_timeout,
+                                            ignore_aborts)
                 if self.background:
                     return
                 section += 1
                 if self.is_client_job_finished(last):
                     logging.info("Client complete")
                     return
                 elif self.is_client_job_rebooting(last):
                     try:
                         self._wait_for_reboot(boot_id)
                     except error.AutotestRunError, e:
@@ skipping 312 matching lines @@
 
         @returns: True if the test passes, False otherwise."""
         at = self._Autotest()
         control_file = ('result = job.run_test(%s)\n'
                         'job.set_state("test_result", result)\n')
         test_args = [repr(test_name)]
         test_args += ['%s=%r' % (k, v) for k, v in dargs.iteritems()]
         control_file %= ', '.join(test_args)
         at.run(control_file, host=self)
         return at.job.get_state('test_result', default=False)