def _run_step_fn(self, local_vars, fn, args, dargs):
"""Run a (step) function within the given context"""
local_vars['__args'] = args
local_vars['__dargs'] = dargs
try:
exec('__ret = %s(*__args, **__dargs)' % fn, local_vars, local_vars)
return local_vars['__ret']
except SystemExit:
raise # Send error.JobContinue and JobComplete on up to runjob.
except error.TestNAError as detail:
self.record(detail.exit_status, None, fn, str(detail))
except Exception as detail:
raise error.UnhandledJobError(detail)
def step_engine(self):
"""The multi-run engine used when the control file defines step_init.
Does the next step.
"""
# Set up the environment and then interpret the control file.
# Some control files will have code outside of functions,
# which means we need to have our state engine initialized
# before reading in the file.
global_control_vars = {'job': self,
'args': self.args}
exec(JOB_PREAMBLE, global_control_vars, global_control_vars)
try:
execfile(self.control, global_control_vars, global_control_vars)
except error.TestNAError as detail:
self.record(detail.exit_status, None, self.control, str(detail))
except SystemExit:
raise # Send error.JobContinue and JobComplete on up to runjob.
except Exception as 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)
local_vars, self._current_step_ancestry = ret
local_vars = self._run_step_fn(local_vars, fn_name, args, dargs)
self._add_step_init(local_vars, fn_name)
self._state.set('client', 'steps', steps)
def _run_step_fn(self, local_vars, fn, args, dargs):
"""Run a (step) function within the given context"""
local_vars['__args'] = args
local_vars['__dargs'] = dargs
try:
exec('__ret = %s(*__args, **__dargs)' % fn, local_vars, local_vars)
return local_vars['__ret']
except SystemExit:
raise # Send error.JobContinue and JobComplete on up to runjob.
except error.TestNAError, detail:
self.record(detail.exit_status, None, fn, str(detail))
except Exception, detail:
raise error.UnhandledJobError(detail)
def _create_frame(self, global_vars, ancestry, fn_name):
"""Set up the environment like it would have been when this
function was first defined.
Child step engine 'implementations' must have 'return locals()'
at end end of their steps. Because of this, we can call the
parent function and get back all child functions (i.e. those
defined within it).
Unfortunately, the call stack of the function calling
job.next_step might have been deeper than the function it
added. In order to make sure that the environment is what it
should be, we need to then pop off the frames we built until
we find the frame where the function was first defined."""