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 161 matching lines @@
             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()
 
-        # 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
+        _harness = self.handle_persistent_option(options, 'harness')
+        _harness_args = self.handle_persistent_option(options, 'harness_args')
 
-        self.harness = harness.select(selected_harness, self)
+        self.harness = harness.select(_harness, self, _harness_args)
 
         # 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,
@@ skipping 175 matching lines @@
 
 
     def control_get(self):
         return self.control
 
 
     def control_set(self, control):
         self.control = os.path.abspath(control)
 
 
-    def harness_select(self, which):
-        self.harness = harness.select(which, self)
+    def harness_select(self, which, harness_args):
+        self.harness = harness.select(which, self, harness_args)
 
 
     def config_set(self, name, value):
         self._config.set(name, value)
 
 
     def config_get(self, name):
         return self._config.get(name)
 
 
@@ skipping 191 matching lines @@
                 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
+            try:
+                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.
@@ skipping 285 matching lines @@
         has_steps = self._state.has('client', 'steps')
         if not self._is_continuation and has_steps:
             raise RuntimeError('Loaded state can only contain client.steps if '
                                'this is a continuation')
 
         if not has_steps:
             logging.info('Initializing the state engine')
             self._state.set('client', 'steps', [])
 
 
+    def handle_persistent_option(self, options, option_name):
+        """
+        Select option from command line or persistent state.
+        Store selected option to allow standalone client to continue
+        after reboot with previously selected options.
+        Priority:
+        1. explicitly specified via command line
+        2. stored in state file (if continuing job '-c')
+        3. default == None
+        """
+        option = None
+        cmd_line_option = getattr(options, option_name)
+        if cmd_line_option:
+            option = cmd_line_option
+            self._state.set('client', option_name, option)
+        else:
+            stored_option = self._state.get('client', option_name, None)
+            if stored_option:
+                option = stored_option
+        logging.debug('Persistent option %s now set to %s', option_name, option)
+        return option
+
+
     def __create_step_tuple(self, fn, args, dargs):
         # Legacy code passes in an array where the first arg is
         # the function or its name.
         if isinstance(fn, list):
             assert(len(args) == 0)
             assert(len(dargs) == 0)
             args = fn[1:]
             fn = fn[0]
         # Pickling actual functions is hairy, thus we have to call
         # them by name.  Unfortunately, this means only functions
@@ skipping 307 matching lines @@
     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