def run_virt_sub_test(test, params, env, sub_type=None, tag=None):
"""
Call another test script in one test script.
:param test: Virt Test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
:param sub_type: Type of called test script.
:param tag: Tag for get the sub_test params
"""
if sub_type is None:
raise error.TestError("No sub test is found")
shared_test_dir = os.path.dirname(test.virtdir)
shared_test_dir = os.path.join(shared_test_dir, "generic",
"tests")
subtest_dir = None
subtest_dirs = data_dir.SubdirList(shared_test_dir)
subtest_dir_specific = os.path.join(test.bindir, params.get('vm_type'),
"tests")
subtest_dirs += data_dir.SubdirList(subtest_dir_specific)
for d in subtest_dirs:
module_path = os.path.join(d, "%s.py" % sub_type)
if os.path.isfile(module_path):
subtest_dir = d
break
if subtest_dir is None:
raise error.TestError("Could not find test file %s.py "
"on either %s or %s "
"directory" % (sub_type,
subtest_dir_specific,
shared_test_dir))
f, p, d = imp.find_module(sub_type, [subtest_dir])
test_module = imp.load_module(sub_type, f, p, d)
f.close()
# Run the test function
run_func = utils_misc.get_test_entrypoint_func(sub_type, test_module)
if tag is not None:
params = params.object_params(tag)
run_func(test, params, env)
def run_virt_sub_test(test, params, env, sub_type=None, tag=None):
"""
Call another test script in one test script.
:param test: Virt Test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
:param sub_type: Type of called test script.
:param tag: Tag for get the sub_test params
"""
if sub_type is None:
raise error.TestError("No sub test is found")
virt_dir = os.path.dirname(test.virtdir)
subtest_dir_virt = os.path.join(virt_dir, "tests")
subtest_dir_specific = os.path.join(test.bindir, params.get('vm_type'),
"tests")
subtest_dir = None
subtest_dirs = data_dir.SubdirList(subtest_dir_virt)
subtest_dirs += data_dir.SubdirList(subtest_dir_specific)
for d in subtest_dirs:
module_path = os.path.join(d, "%s.py" % sub_type)
if os.path.isfile(module_path):
subtest_dir = d
break
if subtest_dir is None:
raise error.TestError(
"Could not find test file %s.py "
"on either %s or %s "
"directory" % (sub_type, subtest_dir_specific, subtest_dir_virt))
f, p, d = imp.find_module(sub_type, [subtest_dir])
test_module = imp.load_module(sub_type, f, p, d)
f.close()
# Run the test function
run_func = utils_misc.get_test_entrypoint_func(sub_type, test_module)
if tag is not None:
params = params.object_params(tag)
run_func(test, params, env)
def run_once(self, params):
# Convert params to a Params object
params = utils_params.Params(params)
# If a dependency test prior to this test has failed, let's fail
# it right away as TestNA.
if params.get("dependency_failed") == 'yes':
raise exceptions.TestSkipError("Test dependency failed")
# Report virt test version
logging.info(version.get_pretty_version_info())
# 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)
utils_misc.set_log_file_dir(self.debugdir)
# Open the environment file
custom_env_path = params.get("custom_env_path", "")
if custom_env_path:
env_path = custom_env_path
else:
env_path = params.get("vm_type")
env_filename = os.path.join(self.bindir, "backends", env_path,
params.get("env", "env"))
env = utils_env.Env(env_filename, self.env_version)
other_subtests_dirs = params.get("other_tests_dirs", "")
test_passed = False
t_type = None
try:
try:
try:
subtest_dirs = []
bin_dir = self.bindir
for d in other_subtests_dirs.split():
# Replace split char.
d = os.path.join(*d.split("/"))
subtestdir = os.path.join(bin_dir, d, "tests")
if not os.path.isdir(subtestdir):
raise exceptions.TestError("Directory %s not"
" exist." % (subtestdir))
subtest_dirs += data_dir.SubdirList(subtestdir,
bootstrap.test_filter)
# Verify if we have the correspondent source file for it
for generic_subdir in asset.get_test_provider_subdirs('generic'):
subtest_dirs += data_dir.SubdirList(generic_subdir,
bootstrap.test_filter)
for multi_host_migration_subdir in asset.get_test_provider_subdirs(
'multi_host_migration'):
subtest_dirs += data_dir.SubdirList(multi_host_migration_subdir,
bootstrap.test_filter)
for specific_subdir in asset.get_test_provider_subdirs(params.get("vm_type")):
subtest_dirs += data_dir.SubdirList(specific_subdir,
bootstrap.test_filter)
subtest_dir = None
# Get the test routine corresponding to the specified
# test type
logging.debug("Searching for test modules that match "
"'type = %s' and 'provider = %s' "
"on this cartesian dict",
params.get("type"), params.get("provider", None))
t_types = params.get("type").split()
provider = params.get("provider", None)
if provider is not None:
subtest_dirs = [
d for d in subtest_dirs if provider in d]
# Make sure we can load provider_lib in tests
for s in subtest_dirs:
if os.path.dirname(s) not in sys.path:
sys.path.insert(0, os.path.dirname(s))
test_modules = {}
for t_type in t_types:
for d in subtest_dirs:
module_path = os.path.join(d, "%s.py" % t_type)
if os.path.isfile(module_path):
subtest_dir = d
break
if subtest_dir is None:
msg = ("Could not find test file %s.py on tests"
"dirs %s" % (t_type, subtest_dirs))
raise exceptions.TestError(msg)
# Load the test module
f, p, d = imp.find_module(t_type, [subtest_dir])
test_modules[t_type] = imp.load_module(t_type, f, p, d)
f.close()
# Preprocess
try:
params = env_process.preprocess(self, params, env)
finally:
env.save()
# Run the test function
for t_type in t_types:
test_module = test_modules[t_type]
run_func = utils_misc.get_test_entrypoint_func(
t_type, test_module)
try:
run_func(self, params, env)
self.verify_background_errors()
finally:
env.save()
test_passed = True
error_message = funcatexit.run_exitfuncs(env, t_type)
if error_message:
raise exceptions.TestWarn("funcatexit failed with: %s"
% error_message)
except Exception as e:
if t_type is not None:
error_message = funcatexit.run_exitfuncs(env, t_type)
if error_message:
logging.error(error_message)
logging.error("Test failed: %s: %s",
e.__class__.__name__, e)
try:
env_process.postprocess_on_error(
self, params, env)
finally:
env.save()
raise
finally:
# Postprocess
try:
try:
env_process.postprocess(self, params, env)
except Exception as e:
if test_passed:
raise
logging.error("Exception raised during "
"postprocessing: %s", e)
finally:
env.save()
except Exception as e:
if params.get("abort_on_error") != "yes":
raise
# Abort on error
logging.info("Aborting job (%s)", e)
if params.get("vm_type") == "qemu":
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_create_command())
raise exceptions.JobError("Abort requested (%s)" % e)
def _runTest(self):
params = self.params
# Report virt test version
logging.info(version.get_pretty_version_info())
self._log_parameters()
# Warn of this special condition in related location in output & logs
if os.getuid() == 0 and params.get('nettype', 'user') == 'user':
logging.warning("")
logging.warning("Testing with nettype='user' while running "
"as root may produce unexpected results!!!")
logging.warning("")
subtest_dirs = self._get_subtest_dirs()
# Get the test routine corresponding to the specified
# test type
logging.debug("Searching for test modules that match "
"'type = %s' and 'provider = %s' "
"on this cartesian dict",
params.get("type"),
params.get("provider", None))
t_types = params.get("type").split()
utils.insert_dirs_to_path(subtest_dirs)
test_modules = utils.find_test_modules(t_types, subtest_dirs)
# Open the environment file
env_filename = os.path.join(data_dir.get_tmp_dir(),
params.get("env", "env"))
env = utils_env.Env(env_filename, self.env_version)
if params.get_boolean("job_env_cleanup", "yes"):
self.runner_queue.put({"func_at_exit": cleanup_env,
"args": (env_filename, self.env_version),
"once": True})
test_passed = False
t_type = None
try:
try:
try:
# Pre-process
try:
params = env_process.preprocess(self, params, env)
finally:
self._safe_env_save(env)
# Run the test function
for t_type in t_types:
test_module = test_modules[t_type]
run_func = utils_misc.get_test_entrypoint_func(
t_type, test_module)
try:
run_func(self, params, env)
self.verify_background_errors()
finally:
self._safe_env_save(env)
test_passed = True
error_message = funcatexit.run_exitfuncs(env, t_type)
if error_message:
raise exceptions.TestWarn("funcatexit failed with: %s" %
error_message)
except: # nopep8 Old-style exceptions are not inherited from Exception()
stacktrace.log_exc_info(sys.exc_info(), 'avocado.test')
if t_type is not None:
error_message = funcatexit.run_exitfuncs(env, t_type)
if error_message:
logging.error(error_message)
try:
env_process.postprocess_on_error(self, params, env)
finally:
self._safe_env_save(env)
raise
finally:
# Post-process
try:
try:
params['test_passed'] = str(test_passed)
env_process.postprocess(self, params, env)
except: # nopep8 Old-style exceptions are not inherited from Exception()
stacktrace.log_exc_info(sys.exc_info(),
'avocado.test')
if test_passed:
raise
logging.error("Exception raised during "
"postprocessing: %s",
sys.exc_info()[1])
finally:
if self._safe_env_save(env) or params.get("env_cleanup", "no") == "yes":
env.destroy() # Force-clean as it can't be stored
except Exception as e:
if params.get("abort_on_error") != "yes":
raise
# Abort on error
logging.info("Aborting job (%s)", e)
if params.get("vm_type") == "qemu":
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("It has a %s monitor unix socket at: %s",
m.protocol, m.filename)
logging.info("The command line used to start it was:\n%s",
vm.make_create_command())
raise exceptions.JobError("Abort requested (%s)" % e)
return test_passed
def run_once(self, params):
# Convert params to a Params object
params = utils_params.Params(params)
# If a dependency test prior to this test has failed, let's fail
# it right away as TestNA.
if params.get("dependency_failed") == 'yes':
raise error.TestNAError("Test dependency failed")
# Report virt test version
logging.info(version.get_pretty_version_info())
# 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)
utils_misc.set_log_file_dir(self.debugdir)
# Open the environment file
custom_env_path = params.get("custom_env_path", "")
if custom_env_path:
env_path = custom_env_path
else:
env_path = params.get("vm_type")
env_filename = os.path.join(self.bindir, "backends", env_path,
params.get("env", "env"))
env = utils_env.Env(env_filename, self.env_version)
other_subtests_dirs = params.get("other_tests_dirs", "")
test_passed = False
t_type = None
try:
try:
try:
subtest_dirs = []
bin_dir = self.bindir
for d in other_subtests_dirs.split():
# Replace split char.
d = os.path.join(*d.split("/"))
subtestdir = os.path.join(bin_dir, d, "tests")
if not os.path.isdir(subtestdir):
raise error.TestError("Directory %s not"
" exist." % (subtestdir))
subtest_dirs += data_dir.SubdirList(subtestdir,
bootstrap.test_filter)
# Verify if we have the correspondent source file for it
for generic_subdir in asset.get_test_provider_subdirs('generic'):
subtest_dirs += data_dir.SubdirList(generic_subdir,
bootstrap.test_filter)
for specific_subdir in asset.get_test_provider_subdirs(params.get("vm_type")):
subtest_dirs += data_dir.SubdirList(specific_subdir,
bootstrap.test_filter)
subtest_dir = None
# Get the test routine corresponding to the specified
# test type
logging.debug("Searching for test modules that match "
"'type = %s' and 'provider = %s' "
"on this cartesian dict",
params.get("type"), params.get("provider", None))
t_types = params.get("type").split()
provider = params.get("provider", None)
if provider is not None:
subtest_dirs = [
d for d in subtest_dirs if provider in d]
# Make sure we can load provider_lib in tests
for s in subtest_dirs:
if os.path.dirname(s) not in sys.path:
sys.path.insert(0, os.path.dirname(s))
test_modules = {}
for t_type in t_types:
for d in subtest_dirs:
module_path = os.path.join(d, "%s.py" % t_type)
if os.path.isfile(module_path):
subtest_dir = d
break
if subtest_dir is None:
msg = ("Could not find test file %s.py on tests"
"dirs %s" % (t_type, subtest_dirs))
raise error.TestError(msg)
# Load the test module
f, p, d = imp.find_module(t_type, [subtest_dir])
test_modules[t_type] = imp.load_module(t_type, f, p, d)
f.close()
# Preprocess
try:
params = env_process.preprocess(self, params, env)
finally:
env.save()
# Run the test function
for t_type in t_types:
test_module = test_modules[t_type]
run_func = utils_misc.get_test_entrypoint_func(
t_type, test_module)
try:
run_func(self, params, env)
self.verify_background_errors()
finally:
env.save()
test_passed = True
error_message = funcatexit.run_exitfuncs(env, t_type)
if error_message:
raise error.TestWarn("funcatexit failed with: %s"
% error_message)
except Exception, e:
if t_type is not None:
error_message = funcatexit.run_exitfuncs(env, t_type)
if error_message:
logging.error(error_message)
logging.error("Test failed: %s: %s",
e.__class__.__name__, e)
try:
env_process.postprocess_on_error(
self, params, env)
finally:
env.save()
raise
finally:
# Postprocess
try:
try:
env_process.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)
if params.get("vm_type") == "qemu":
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_create_command())
raise error.JobError("Abort requested (%s)" % e)
def _runTest(self):
params = self.params
# If a dependency test prior to this test has failed, let's fail
# it right away as TestNA.
if params.get("dependency_failed") == 'yes':
raise error.TestNAError("Test dependency failed")
# Report virt test version
logging.info(version.get_pretty_version_info())
# 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])
# Warn of this special condition in related location in output & logs
if os.getuid() == 0 and params.get('nettype', 'user') == 'user':
logging.warning("")
logging.warning("Testing with nettype='user' while running "
"as root may produce unexpected results!!!")
logging.warning("")
# Find the test
subtest_dirs = []
test_filter = bootstrap.test_filter
other_subtests_dirs = params.get("other_tests_dirs", "")
for d in other_subtests_dirs.split():
d = os.path.join(*d.split("/"))
subtestdir = os.path.join(self.bindir, d, "tests")
if not os.path.isdir(subtestdir):
raise error.TestError("Directory %s does not "
"exist" % subtestdir)
subtest_dirs += data_dir.SubdirList(subtestdir,
test_filter)
provider = params.get("provider", None)
if provider is None:
# Verify if we have the correspondent source file for
# it
generic_subdirs = asset.get_test_provider_subdirs(
'generic')
for generic_subdir in generic_subdirs:
subtest_dirs += data_dir.SubdirList(generic_subdir,
test_filter)
specific_subdirs = asset.get_test_provider_subdirs(
params.get("vm_type"))
for specific_subdir in specific_subdirs:
subtest_dirs += data_dir.SubdirList(
specific_subdir, bootstrap.test_filter)
else:
provider_info = asset.get_test_provider_info(provider)
for key in provider_info['backends']:
subtest_dirs += data_dir.SubdirList(
provider_info['backends'][key]['path'],
bootstrap.test_filter)
subtest_dir = None
# Get the test routine corresponding to the specified
# test type
logging.debug("Searching for test modules that match "
"'type = %s' and 'provider = %s' "
"on this cartesian dict",
params.get("type"),
params.get("provider", None))
t_types = params.get("type").split()
# Make sure we can load provider_lib in tests
for s in subtest_dirs:
if os.path.dirname(s) not in sys.path:
sys.path.insert(0, os.path.dirname(s))
test_modules = {}
for t_type in t_types:
for d in subtest_dirs:
module_path = os.path.join(d, "%s.py" % t_type)
if os.path.isfile(module_path):
logging.debug("Found subtest module %s",
module_path)
subtest_dir = d
break
if subtest_dir is None:
msg = ("Could not find test file %s.py on test"
"dirs %s" % (t_type, subtest_dirs))
raise error.TestError(msg)
# Load the test module
f, p, d = imp.find_module(t_type, [subtest_dir])
test_modules[t_type] = imp.load_module(t_type, f, p, d)
f.close()
# TODO: the environment file is deprecated code, and should be removed
# in future versions. Right now, it's being created on an Avocado temp
# dir that is only persisted during the runtime of one job, which is
# different from the original idea of the environment file (which was
# persist information accross virt-test/avocado-vt job runs)
env_filename = os.path.join(data_dir.get_tmp_dir(),
params.get("env", "env"))
env = utils_env.Env(env_filename, self.env_version)
self.runner_queue.put({"func_at_exit": cleanup_env,
"args": (env_filename, self.env_version),
"once": True})
test_passed = False
t_type = None
try:
try:
try:
# Preprocess
try:
params = env_process.preprocess(self, params, env)
finally:
self.__safe_env_save(env)
# Run the test function
for t_type in t_types:
test_module = test_modules[t_type]
run_func = utils_misc.get_test_entrypoint_func(
t_type, test_module)
try:
run_func(self, params, env)
self.verify_background_errors()
finally:
self.__safe_env_save(env)
test_passed = True
error_message = funcatexit.run_exitfuncs(env, t_type)
if error_message:
raise error.TestWarn("funcatexit failed with: %s" %
error_message)
except Exception:
if t_type is not None:
error_message = funcatexit.run_exitfuncs(env, t_type)
if error_message:
logging.error(error_message)
try:
env_process.postprocess_on_error(self, params, env)
finally:
self.__safe_env_save(env)
raise
finally:
# Postprocess
try:
try:
params['test_passed'] = str(test_passed)
env_process.postprocess(self, params, env)
except Exception, e:
if test_passed:
raise
logging.error("Exception raised during "
"postprocessing: %s", e)
finally:
if self.__safe_env_save(env):
env.destroy() # Force-clean as it can't be stored
except Exception, e:
if params.get("abort_on_error") != "yes":
raise
# Abort on error
logging.info("Aborting job (%s)", e)
if params.get("vm_type") == "qemu":
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("It has a %s monitor unix socket at: %s",
m.protocol, m.filename)
logging.info("The command line used to start it was:\n%s",
vm.make_create_command())
raise error.JobError("Abort requested (%s)" % e)