def command_akit_jobs_run(root, job, output, start, branch, build, flavor, console_level, logfile_level):
# pylint: disable=unused-import,import-outside-toplevel
# We do the imports of the automation framework code inside the action functions because
# we don't want to startup loggin and the processing of inputs and environment variables
# until we have entered an action method. Thats way we know how to setup the environment.
# IMPORTANT: We need to load the context first because it will trigger the loading
# of the default user configuration
from akit.environment.context import Context
from akit.compat import import_by_name
from akit.environment.variables import extend_path
try:
ctx = Context()
ctx.insert("/environment/jobtype", 'testrun')
test_root = os.path.abspath(os.path.expandvars(os.path.expanduser(root)))
if not os.path.isdir(test_root):
errmsg = "The specified root folder does not exist. root=%s" % root
if test_root != root:
errmsg += " expanded=%s" % test_root
raise argparse.ArgumentError("--root", errmsg)
# Make sure we extend PATH to include the test root
extend_path(test_root)
# We perform activation a little later in the testrunner.py file so we can
# handle exceptions in the context of testrunner_main function
import akit.activation.testrun
from akit.xlogging.foundations import logging_initialize, getAutomatonKitLogger
# Initialize logging
logging_initialize()
logger = getAutomatonKitLogger()
from akit.extensionpoints import AKitExtensionPoints
akep = AKitExtensionPoints()
# At this point in the code, we either lookup an existing test job or we create a test job
# from the includes, excludes or test_module
TestJobType = akep.get_testplus_default_job_type()
if job is not None:
job_parts = job.split("@")
if len(job_parts) != 2:
errmsg = "A --job parameter must be of the form 'package.module@JobClass'"
raise click.UsageError(errmsg)
job_package, job_class = job_parts
try:
job_mod = import_by_name(job_package)
except ImportError as imperr:
errmsg = "Failure while importing job package %r" % job_package
raise argparse.ArgumentError("--job", errmsg) from imperr
if not hasattr(job_mod, job_class):
errmsg = "The job package %r does not have a job type %r." % (job_package, job_class)
raise argparse.ArgumentError("--job", errmsg)
TestJobType = getattr(job_mod, job_class)
result_code = 0
with TestJobType(logger, test_root) as tjob:
result_code = tjob.execute()
sys.exit(result_code)
finally:
pass
return
def command_akit_testing_run(root, includes, excludes, output, start, runid,
branch, build, flavor, credentials_file,
landscape_file, landscape_name, runtime_file,
runtime_name, topology_file, topology_name,
console_level, logfile_level, debugger,
breakpoints, time_travel, timeportals,
prerun_diagnostic, postrun_diagnostic):
# pylint: disable=unused-import,import-outside-toplevel
# We do the imports of the automation framework code inside the action functions because
# we don't want to startup loggin and the processing of inputs and environment variables
# until we have entered an action method. Thats way we know how to setup the environment.
# IMPORTANT: We need to load the context first because it will trigger the loading
# of the default user configuration
from akit.environment.context import Context
from akit.environment.contextpaths import ContextPaths
from akit.environment.variables import extend_path, JOB_TYPES, AKIT_VARIABLES
from akit.environment.optionoverrides import (
override_build_branch, override_build_flavor, override_build_name,
override_config_credentials, override_config_landscape,
override_config_landscape_name, override_config_runtime,
override_config_runtime_name, override_config_topology,
override_config_topology_name, override_loglevel_console,
override_loglevel_file, override_output_directory, override_runid,
override_starttime, override_testroot, override_debug_breakpoints,
override_debug_debugger, override_timetravel, override_timeportals)
ctx = Context()
env = ctx.lookup("/environment")
# We need to set the job type before we trigger activation.
env["jobtype"] = JOB_TYPES.TESTRUN
# We perform activation a little later in the testrunner.py file so we can
# handle exceptions in the context of testrunner_main function
import akit.activation.testrun
from akit.xlogging.foundations import logging_initialize, getAutomatonKitLogger
if branch is not None:
override_build_branch(branch)
if build is not None:
override_build_name(build)
if flavor is not None:
override_build_flavor(flavor)
if credentials_file is not None:
override_config_credentials(credentials_file)
if landscape_file is not None and landscape_name is not None:
errmsg = "The '--landscape-file' and '--landscape-name' options should not be used together."
raise click.BadOptionUsage("landscape-name", errmsg)
if landscape_file is not None:
override_config_landscape(landscape_file)
if landscape_name is not None:
override_config_landscape_name(landscape_name)
if landscape_file is not None or landscape_name is not None:
landscape_filename = AKIT_VARIABLES.AKIT_CONFIG_LANDSCAPE
option_name = "landscape" if landscape_file is not None else "landscape-name"
if not os.path.exists(landscape_filename):
errmsg = "The specified landscape file does not exist. filename={}".format(
landscape_filename)
raise click.BadOptionUsage(option_name, errmsg)
if runtime_file is not None and runtime_name is not None:
errmsg = "The '--runtime-file' and '--runtime-name' options should not be used together."
raise click.BadOptionUsage("runtime-name", errmsg)
if runtime_file is not None:
override_config_runtime(runtime_file)
if runtime_name is not None:
override_config_runtime_name(runtime_name)
if runtime_file is not None or runtime_name is not None:
runtime_filename = AKIT_VARIABLES.AKIT_CONFIG_RUNTIME
option_name = "runtime" if runtime_file is not None else "runtime-name"
if not os.path.exists(runtime_filename):
errmsg = "The specified runtime file does not exist. filename={}".format(
runtime_filename)
raise click.BadOptionUsage(option_name, errmsg)
if topology_file is not None and topology_name is not None:
errmsg = "The '--topology-file' and '--topology-name' options should not be used together."
raise click.BadOptionUsage("option_name", errmsg)
if topology_file is not None:
override_config_topology(topology_file)
if topology_name is not None:
override_config_topology_name(topology_name)
if topology_file is not None or topology_name is not None:
topology_filename = AKIT_VARIABLES.AKIT_CONFIG_TOPOLOGY
option_name = "topology" if topology_file is not None else "topology-name"
if not os.path.exists(topology_filename):
errmsg = "The specified topology file does not exist. filename={}".format(
topology_filename)
raise click.BadOptionUsage(option_name, errmsg)
if console_level is not None:
override_loglevel_console(console_level)
if logfile_level is not None:
override_loglevel_file(logfile_level)
if output is not None:
override_output_directory(output)
if start is not None:
override_starttime(start)
if runid is not None:
override_runid(runid)
# Process the commandline args here and then set the variables on the environment
# as necessary. We need to do this before we import activate.
if breakpoints is not None:
override_debug_breakpoints(breakpoints)
# If a breakpoint was passed bug the debugger was not, use 'debugpy' for the
# default debugger.
if debugger is None:
override_debug_debugger('debugpy')
if debugger is not None:
override_debug_debugger('debugpy')
if time_travel is not None:
override_timetravel(time_travel)
if timeportals is not None:
override_timeportals(timeportals)
if prerun_diagnostic:
ctx.insert("/environment/configuration/diagnostics/prerun-diagnostic",
{})
if postrun_diagnostic:
ctx.insert("/environment/configuration/diagnostics/postrun-diagnostic",
{})
if root is None:
if AKIT_VARIABLES.AKIT_TESTROOT is not None:
root = AKIT_VARIABLES.AKIT_TESTROOT
elif ctx.lookup(ContextPaths.TESTROOT) is not None:
root = ctx.lookup(ContextPaths.TESTROOT)
else:
root = "."
test_root = os.path.abspath(os.path.expandvars(os.path.expanduser(root)))
if not os.path.isdir(test_root):
errmsg = "The specified root folder does not exist. root=%s" % root
if test_root != root:
errmsg += " expanded=%s" % test_root
raise click.BadParameter(errmsg)
override_testroot(root)
# Make sure we extend PATH to include the test root
extend_path(test_root)
# Initialize logging
logging_initialize()
logger = getAutomatonKitLogger()
from akit.extensionpoints import AKitExtensionPoints
akep = AKitExtensionPoints()
# At this point in the code, we either lookup an existing test job or we create a test job
# from the includes, excludes or test_module
TestJobType = akep.get_testplus_default_job_type()
result_code = 0
with TestJobType(logger,
test_root,
includes=includes,
excludes=excludes,
branch=branch,
build=build,
flavor=flavor) as tjob:
result_code = tjob.execute()
sys.exit(result_code)
return