Merge remote branch 'cros/upstream' into master

client/bin/job.py

 """The main job wrapper
 
 This is the core infrastructure.
 
 Copyright Andy Whitcroft, Martin J. Bligh 2006
 """
 
 import copy, os, platform, re, shutil, sys, time, traceback, types, glob
 import logging, getpass, errno, weakref
 import cPickle as pickle
@@ skipping 117 matching lines @@
     @classmethod
     def _find_base_directories(cls):
         """
         Determine locations of autodir and clientdir (which are the same)
         using os.environ. Serverdir does not exist in this context.
         """
         autodir = clientdir = cls._get_environ_autodir()
         return autodir, clientdir, None
 
 
+    @classmethod
+    def _parse_args(cls, args):
+        return re.findall("[^\s]*?['|\"].*?['|\"]|[^\s]+", args)
+
+
     def _find_resultdir(self, options):
         """
         Determine the directory for storing results. On a client this is
         always <autodir>/results/<tag>, where tag is passed in on the command
         line as an option.
         """
         return os.path.join(self.autodir, 'results', options.tag)
 
 
     def _get_status_logger(self):
         """Return a reference to the status logger."""
         return self._logger
 
 
     def _pre_record_init(self, control, options):
         """
         Initialization function that should peform ONLY the required
         setup so that the self.record() method works.
 
         As of now self.record() needs self.resultdir, self._group_level,
         self.harness and of course self._logger.
         """
         if not options.cont:
             self._cleanup_debugdir_files()
             self._cleanup_results_dir()
 
         logging_manager.configure_logging(
-                client_logging_config.ClientLoggingConfig(),
-                results_dir=self.resultdir,
-                verbose=options.verbose)
+            client_logging_config.ClientLoggingConfig(),
+            results_dir=self.resultdir,
+            verbose=options.verbose)
         logging.info('Writing results to %s', self.resultdir)
 
         # init_group_level needs the state
         self.control = os.path.realpath(control)
         self._is_continuation = options.cont
         self._current_step_ancestry = []
         self._next_step_index = 0
         self._load_state()
 
-        self.harness = harness.select(options.harness, self)
+        # harness is chosen by following rules:
+        # 1. explicitly specified via command line
+        # 2. harness stored in state file (if continuing job '-c')
+        # 3. default harness
+        selected_harness = None
+        if options.harness:
+            selected_harness = options.harness
+            self._state.set('client', 'harness', selected_harness)
+        else:
+            stored_harness = self._state.get('client', 'harness', None)
+            if stored_harness:
+                selected_harness = stored_harness
+
+        self.harness = harness.select(selected_harness, self)
 
         # set up the status logger
         def client_job_record_hook(entry):
             msg_tag = ''
             if '.' in self._logger.global_filename:
                 msg_tag = self._logger.global_filename.split('.', 1)[1]
             # send the entry to the job harness
             message = '\n'.join([entry.message] + entry.extra_message_lines)
             rendered_entry = self._logger.render_entry(entry)
             self.harness.test_status_detail(entry.status_code, entry.subdir,
                                             entry.operation, message, msg_tag)
             self.harness.test_status(rendered_entry, msg_tag)
             # send the entry to stdout, if it's enabled
             logging.info(rendered_entry)
         self._logger = base_job.status_logger(
-            self, status_indenter(self), record_hook=client_job_record_hook)
-
+            self, status_indenter(self), record_hook=client_job_record_hook,
+            tap_writer=self._tap)
 
     def _post_record_init(self, control, options, drop_caches,
                           extra_copy_cmdline):
         """
         Perform job initialization not required by self.record().
         """
         self._init_drop_caches(drop_caches)
 
         self._init_packages()
 
@@ skipping 18 matching lines @@
         self.profilers = profilers.profilers(self)
 
         self._init_bootloader()
 
         self.machines = [options.hostname]
         self.hosts = set([local_host.LocalHost(hostname=options.hostname,
                                                bootloader=self.bootloader)])
 
         self.args = []
         if options.args:
-            self.args = options.args.split()
+            self.args = self._parse_args(options.args)
 
         if options.user:
             self.user = options.user
         else:
             self.user = getpass.getuser()
 
         self.sysinfo.log_per_reboot_data()
 
         if not options.cont:
             self.record('START', None, None)
@@ skipping 331 matching lines @@
         function:
                 subroutine to run
         *args:
                 arguments for the function
 
         Returns the result of the passed in function
         """
 
         try:
             self.record('START', subdir, testname)
+            self._state.set('client', 'unexpected_reboot', (subdir, testname))
             result = function(*args, **dargs)
             self.record('END GOOD', subdir, testname)
             return result
         except error.TestBaseException, e:
             self.record('END %s' % e.exit_status, subdir, testname)
             raise
         except error.JobError, e:
             self.record('END ABORT', subdir, testname)
             raise
         except Exception, e:
             # This should only ever happen due to a bug in the given
             # function's code.  The common case of being called by
             # run_test() will never reach this.  If a control file called
             # run_group() itself, bugs in its function will be caught
             # here.
             err_msg = str(e) + '\n' + traceback.format_exc()
             self.record('END ERROR', subdir, testname, err_msg)
             raise
+        finally:
+            self._state.discard('client', 'unexpected_reboot')
 
 
     def run_group(self, function, tag=None, **dargs):
         """
         Run a function nested within a group level.
 
         function:
                 Callable to run.
         tag:
                 An optional tag name for the group.  If None (default)
@@ skipping 44 matching lines @@
         @param running_id: An optional running_id to include in the reboot
             failure log message
 
         @raise JobError: Raised if the current configuration does not match the
             pre-reboot configuration.
         """
         # check to see if any partitions have changed
         partition_list = partition_lib.get_partition_list(self,
                                                           exclude_swap=False)
         mount_info = partition_lib.get_mount_info(partition_list)
-
         old_mount_info = self._state.get('client', 'mount_info')
         if mount_info != old_mount_info:
             new_entries = mount_info - old_mount_info
             old_entries = old_mount_info - mount_info
             description = ("mounted partitions are different after reboot "
                            "(old entries: %s, new entries: %s)" %
                            (old_entries, new_entries))
             self._record_reboot_failure(subdir, "reboot.verify_config",
                                         description, running_id=running_id)
             raise error.JobError("Reboot failed: %s" % description)
@@ skipping 185 matching lines @@
             raise error.JobError(msg)
 
 
     def quit(self):
         # XXX: should have a better name.
         self.harness.run_pause()
         raise error.JobContinue("more to come")
 
 
     def complete(self, status):
-        """Clean up and exit"""
+        """Write pending TAP reports, clean up, and exit"""
+        # write out TAP reports
+        if self._tap.do_tap_report:
+            self._tap.write()
+            self._tap._write_tap_archive()
+
         # We are about to exit 'complete' so clean up the control file.
         dest = os.path.join(self.resultdir, os.path.basename(self._state_file))
         shutil.move(self._state_file, dest)
 
         self.harness.run_complete()
         self.disable_external_logging()
         sys.exit(status)
 
 
     def _load_state(self):
@@ skipping 152 matching lines @@
         except Exception, detail:
             # Syntax errors or other general Python exceptions coming out of
             # the top level of the control file itself go through here.
             raise error.UnhandledJobError(detail)
 
         # If we loaded in a mid-job state file, then we presumably
         # know what steps we have yet to run.
         if not self._is_continuation:
             if 'step_init' in global_control_vars:
                 self.next_step(global_control_vars['step_init'])
+        else:
+            # if last job failed due to unexpected reboot, record it as fail
+            # so harness gets called
+            last_job = self._state.get('client', 'unexpected_reboot', None)
+            if last_job:
+                subdir, testname = last_job
+                self.record('FAIL', subdir, testname, 'unexpected reboot')
+                self.record('END FAIL', subdir, testname)
 
         # Iterate through the steps.  If we reboot, we'll simply
         # continue iterating on the next step.
         while len(self._state.get('client', 'steps')) > 0:
             steps = self._state.get('client', 'steps')
             (ancestry, fn_name, args, dargs) = steps.pop(0)
             self._state.set('client', 'steps', steps)
 
             self._next_step_index = 0
             ret = self._create_frame(global_control_vars, ancestry, fn_name)
@@ skipping 119 matching lines @@
         #  2) define steps, and select the first via next_step()
         myjob.step_engine()
 
     except error.JobContinue:
         sys.exit(5)
 
     except error.JobComplete:
         sys.exit(1)
 
     except error.JobError, instance:
-        logging.error("JOB ERROR: " + instance.args[0])
+        logging.error("JOB ERROR: " + str(instance))
         if myjob:
             command = None
             if len(instance.args) > 1:
                 command = instance.args[1]
-                myjob.record('ABORT', None, command, instance.args[0])
-            myjob.record('END ABORT', None, None, instance.args[0])
+                myjob.record('ABORT', None, command, str(instance))
+            myjob.record('END ABORT', None, None, str(instance))
             assert myjob._record_indent == 0
             myjob.complete(1)
         else:
             sys.exit(1)
 
     except Exception, e:
         # NOTE: job._run_step_fn and job.step_engine will turn things into
         # a JobError for us.  If we get here, its likely an autotest bug.
         msg = str(e) + '\n' + traceback.format_exc()
         logging.critical("JOB ERROR (autotest bug?): " + msg)
         if myjob:
             myjob.record('END ABORT', None, None, msg)
             assert myjob._record_indent == 0
             myjob.complete(1)
         else:
             sys.exit(1)
 
     # If we get here, then we assume the job is complete and good.
     myjob.record('END GOOD', None, None)
     assert myjob._record_indent == 0
 
     myjob.complete(0)
 
 
 site_job = utils.import_site_class(
     __file__, "autotest_lib.client.bin.site_job", "site_job", base_client_job)
 
 class job(site_job):
     pass