def run_once(self, params):
# Convert params to a Params object
params = kvm_utils.Params(params)
# Report the parameters we've received and write them as keyvals
logging.debug("Test parameters:")
keys = params.keys()
keys.sort()
for key in keys:
logging.debug(" %s = %s", key, params[key])
self.write_test_keyval({key: params[key]})
# Set the log file dir for the logging mechanism used by kvm_subprocess
# (this must be done before unpickling env)
kvm_utils.set_log_file_dir(self.debugdir)
# Open the environment file
logging.info("Unpickling env. You may see some harmless error "
"messages.")
env_filename = os.path.join(self.bindir, params.get("env", "env"))
env = kvm_utils.Env(env_filename, self.env_version)
test_passed = False
try:
try:
try:
# Get the test routine corresponding to the specified
# test type
t_type = params.get("type")
# Verify if we have the correspondent source file for it
subtest_dir = os.path.join(self.bindir, "tests")
module_path = os.path.join(subtest_dir, "%s.py" % t_type)
if not os.path.isfile(module_path):
raise error.TestError("No %s.py test file found" %
t_type)
# Load the test module
f, p, d = imp.find_module(t_type, [subtest_dir])
test_module = imp.load_module(t_type, f, p, d)
f.close()
# Preprocess
try:
kvm_preprocessing.preprocess(self, params, env)
finally:
env.save()
# Run the test function
run_func = getattr(test_module, "run_%s" % t_type)
try:
run_func(self, params, env)
finally:
env.save()
test_passed = True
except Exception, e:
logging.error("Test failed: %s: %s", e.__class__.__name__,
e)
try:
kvm_preprocessing.postprocess_on_error(
self, params, env)
finally:
env.save()
raise
finally:
# Postprocess
try:
try:
kvm_preprocessing.postprocess(self, params, env)
except Exception, e:
if test_passed:
raise
logging.error(
"Exception raised during "
"postprocessing: %s", e)
finally:
env.save()
except Exception, e:
if params.get("abort_on_error") != "yes":
raise
# Abort on error
logging.info("Aborting job (%s)", e)
for vm in env.get_all_vms():
if vm.is_dead():
continue
logging.info("VM '%s' is alive.", vm.name)
for m in vm.monitors:
logging.info("'%s' has a %s monitor unix socket at: %s",
vm.name, m.protocol, m.filename)
logging.info("The command line used to start '%s' was:\n%s",
vm.name, vm.make_qemu_command())
raise error.JobError("Abort requested (%s)" % e)
def run_once(self, params):
import logging
import kvm_utils
import kvm_preprocessing
# Seed the random number generator
random.seed()
# Enable core dumps
resource.setrlimit(resource.RLIMIT_CORE, (-1, -1))
# Report the parameters we've received and write them as keyvals
logging.debug("Test parameters:")
keys = params.keys()
keys.sort()
for key in keys:
logging.debug(" %s = %s", key, params[key])
self.write_test_keyval({key: params[key]})
# Open the environment file
env_filename = os.path.join(self.bindir, params.get("env", "env"))
env = load_env(env_filename, {})
logging.debug("Contents of environment: %s" % str(env))
try:
try:
# Get the test routine corresponding to the specified test type
type = params.get("type")
routine_obj = self.test_routines.get(type)
# If type could not be found in self.test_routines...
if not routine_obj:
message = "Unsupported test type: %s" % type
logging.error(message)
raise error.TestError(message)
# If we don't have the test routine yet...
if not routine_obj.routine:
# Dynamically import the module
module = __import__(routine_obj.module_name)
# Get the needed routine
routine_name = "module." + routine_obj.routine_name
routine_obj.routine = eval(routine_name)
# Preprocess
kvm_preprocessing.preprocess(self, params, env)
dump_env(env, env_filename)
# Run the test function
routine_obj.routine(self, params, env)
dump_env(env, env_filename)
except Exception, e:
logging.error("Test failed: %s", e)
logging.debug("Postprocessing on error...")
kvm_preprocessing.postprocess_on_error(self, params, env)
dump_env(env, env_filename)
raise
finally:
# Postprocess
kvm_preprocessing.postprocess(self, params, env)
logging.debug("Contents of environment: %s", str(env))
dump_env(env, env_filename)
# Verify if we have the correspondent source file for it
module_path = os.path.join(self.subtest_dir, '%s.py' % type)
if not os.path.isfile(module_path):
raise error.TestError("No %s.py test file found" % type)
# Load the tests directory (which was turned into a py module)
try:
test_module = __import__("tests.%s" % type)
except ImportError, e:
raise error.TestError("Failed to import test %s: %s" %
(type, e))
# Preprocess
kvm_preprocessing.preprocess(self, params, env)
kvm_utils.dump_env(env, env_filename)
# Run the test function
eval("test_module.%s.run_%s(self, params, env)" % (type, type))
kvm_utils.dump_env(env, env_filename)
except Exception, e:
logging.error("Test failed: %s", e)
logging.debug("Postprocessing on error...")
kvm_preprocessing.postprocess_on_error(self, params, env)
kvm_utils.dump_env(env, env_filename)
raise
finally:
# Postprocess
kvm_preprocessing.postprocess(self, params, env)
logging.debug("Contents of environment: %s", str(env))
kvm_utils.dump_env(env, env_filename)
def run_once(self, params):
# Report the parameters we've received and write them as keyvals
logging.debug("Test parameters:")
keys = params.keys()
keys.sort()
for key in keys:
logging.debug(" %s = %s", key, params[key])
self.write_test_keyval({key: params[key]})
# Set the log file dir for the logging mechanism used by kvm_subprocess
# (this must be done before unpickling env)
kvm_utils.set_log_file_dir(self.debugdir)
# Open the environment file
logging.info("Unpickling env. You may see some harmless error "
"messages.")
env_filename = os.path.join(self.bindir, params.get("env", "env"))
env = kvm_utils.load_env(env_filename, self.env_version)
logging.debug("Contents of environment: %s", env)
test_passed = False
try:
try:
try:
# Get the test routine corresponding to the specified
# test type
t_type = params.get("type")
# Verify if we have the correspondent source file for it
subtest_dir = os.path.join(self.bindir, "tests")
module_path = os.path.join(subtest_dir, "%s.py" % t_type)
if not os.path.isfile(module_path):
raise error.TestError("No %s.py test file found" %
t_type)
# Load the test module
f, p, d = imp.find_module(t_type, [subtest_dir])
test_module = imp.load_module(t_type, f, p, d)
f.close()
# Preprocess
try:
kvm_preprocessing.preprocess(self, params, env)
finally:
kvm_utils.dump_env(env, env_filename)
# Run the test function
run_func = getattr(test_module, "run_%s" % t_type)
try:
run_func(self, params, env)
finally:
kvm_utils.dump_env(env, env_filename)
test_passed = True
except Exception, e:
logging.error("Test failed: %s: %s",
e.__class__.__name__, e)
try:
kvm_preprocessing.postprocess_on_error(
self, params, env)
finally:
kvm_utils.dump_env(env, env_filename)
raise
finally:
# Postprocess
try:
try:
kvm_preprocessing.postprocess(self, params, env)
except Exception, e:
if test_passed:
raise
logging.error("Exception raised during "
"postprocessing: %s", e)
finally:
kvm_utils.dump_env(env, env_filename)
logging.debug("Contents of environment: %s", env)
except Exception, e:
if params.get("abort_on_error") != "yes":
raise
# Abort on error
logging.info("Aborting job (%s)", e)
for vm in kvm_utils.env_get_all_vms(env):
if vm.is_dead():
continue
logging.info("VM '%s' is alive.", vm.name)
for m in vm.monitors:
logging.info("'%s' has a %s monitor unix socket at: %s",
vm.name, m.protocol, m.filename)
logging.info("The command line used to start '%s' was:\n%s",
vm.name, vm.make_qemu_command())
raise error.JobError("Abort requested (%s)" % e)