def coordinator_example_main(): logging_initialize() from akit.interop.landscaping.landscape import Landscape, startup_landscape startup_landscape() lscape = Landscape() s17 = lscape.checkout_a_device_by_modelNumber("S17") upnpcoord = lscape.upnp_coord firstdev = upnpcoord.watch_devices[0].upnp print(type(firstdev)) print(firstdev) powerdev = None for upnpdev in upnpcoord.watch_devices: if upnpdev.power is not None: powerdev = upnpdev.power break if powerdev is not None: powerdev.off() time.sleep(2) powerdev.on() time.sleep(2) powerdev.off() time.sleep(2) powerdev.on() devProps = firstdev.serviceDeviceProperties() value = devProps.action_GetLEDState() if devProps.subscribe_to_events(): var_zonename = devProps.lookup_event_variable("ZoneName") znval = var_zonename.wait_for_value(timeout=600) print (var_zonename) isbval = devProps.lookup_event_variable("IsZoneBridge") print (isbval) LEDSTATES = ["Off", "On"] SMALL_COUNTER = 0 LARGE_COUNTER = 0 while True: time.sleep(2) if SMALL_COUNTER == 0: print("tick") else: print("tock") if LARGE_COUNTER == 0: print("Refreshing upnp device status.") SMALL_COUNTER = (SMALL_COUNTER + 1) % 2 LARGE_COUNTER = (LARGE_COUNTER + 1) % 30
def coordinator_example_main(): logging_initialize() lscape: Landscape = startup_landscape(include_upnp=True) s11 = lscape.checkout_a_device_by_modelNumber("S11").upnp svc_avt = s11.serviceAVTransport() var_cur_uri = svc_avt.lookup_default_variable("AVTransportURI") cur_uri = var_cur_uri.value print("") print("") print("Bdee bdee bdee, Thats all folks!") print("") print("")
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 generic_test_entrypoint(): """ This is the generic test entry point for test modules. It provides a standardized set of commanline parameters that can be used to run test files as scripts. .. note:: The `generic_test_entrypoint` is a useful tool to place at the bottom of test files to allow them to easily be run for debugging purposes. """ # We must exit with a result code, initialize it to 0 here result_code = 0 base_parser = argparse.ArgumentParser() base_parser.add_argument("-i", "--include", dest="includes", action="append", default=[], help="Add an include search statement.") base_parser.add_argument("-x", "--exclude", dest="excludes", action="append", default=[], help="Add an exclude filter statement.") base_parser.add_argument("--console-level", dest="consolelevel", action="store", default="INFO", choices=LOG_LEVEL_NAMES, help="The logging level for console output.") base_parser.add_argument("--logfile-level", dest="logfilelevel", action="store", default="DEBUG", choices=LOG_LEVEL_NAMES, help="The logging level for logfile output.") test_module = sys.modules["__main__"] ctx = Context() env = ctx.lookup("/environment") # Set the jobtype env["jobtype"] = "testrun" test_results_dir = get_path_for_testresults() if not os.path.exists(test_results_dir): os.makedirs(test_results_dir) env["output_directory"] = test_results_dir test_root = find_testmodule_root(test_module) module_fullname = find_testmodule_fullname(test_module) # Copy the test module to the name of the module_fullname name so the loader won't reload it sys.modules[module_fullname] = test_module if test_module.__name__ == "__main__": test_module.__name__ = module_fullname # Re-map the object classes from the module over to the module name we just registered the test # module under. test_class_coll = inspect.getmembers(test_module, inspect.isclass) for testclass_name, testclass_obj in test_class_coll: tcobj_module_name = testclass_obj.__module__ if tcobj_module_name == "__main__": testclass_obj.__module__ = module_fullname args = base_parser.parse_args() logging_initialize() includes = args.includes excludes = args.excludes if len(includes) == 0: includes.append("*") result_code = 0 with DefaultTestJob(logger, test_root, includes=includes, excludes=excludes, test_module=test_module) as tjob: result_code = tjob.execute() sys.exit(result_code) return
def command_akit_landscape_verify(credentials_file, landscape_file, runtime_file): # 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 JOB_TYPES, AKIT_VARIABLES from akit.environment.optionoverrides import (override_config_credentials, override_config_landscape, override_config_runtime) ctx = Context() env = ctx.lookup("/environment") # We need to set the job type before we trigger activation. env["jobtype"] = JOB_TYPES.COMMAND # Activate the AutomationKit environment with characteristics of a console application import akit.activation.console from akit.xlogging.foundations import logging_initialize, getAutomatonKitLogger # Initialize logging logging_initialize() logger = getAutomatonKitLogger() if credentials_file is not None: override_config_credentials(credentials_file) if landscape_file is not None: override_config_landscape(landscape_file) if runtime_file is not None: override_config_runtime(runtime_file) from akit.interop.landscaping.landscape import Landscape, startup_landscape from akit.interop.landscaping.landscapedevice import LandscapeDevice lscape: Landscape = startup_landscape(include_ssh=True, include_upnp=True) upnp_device_configs = lscape.get_upnp_device_configs() if len(upnp_device_configs): print("======================= UPNP DEVICES =======================") for dev in upnp_device_configs: skip_dev = True if "skip" in dev and dev["skip"] else False upnp_info = dev["upnp"] usn = upnp_info["USN"] modelName = upnp_info["modelName"] modelNumber = upnp_info["modelNumber"] status = "Down" lscape_dev: LandscapeDevice = lscape.lookup_device_by_keyid(usn) if lscape_dev is not None: status = lscape_dev.verify_status() dev_info_lines = [ " Model: {} - {}".format(modelName, modelNumber), " USN: {}".format(usn), " Skip: {}".format(skip_dev), " Status: {}".format(status) ] dev_info = os.linesep.join(dev_info_lines) print(dev_info) print("") ssh_devices_configs = lscape.get_ssh_device_configs(exclude_upnp=True) if len(ssh_devices_configs): print("======================= SSH DEVICES =======================") for dev in ssh_devices_configs: skip_dev = True if "skip" in dev and dev["skip"] else False host = dev["host"] status = "Down" lscape_dev: LandscapeDevice = lscape.lookup_device_by_keyid(host) if lscape_dev is not None: status = lscape_dev.verify_status() dev_info_lines = [ " HOST: {}".format(host), " Status: {}".format(status) ] dev_info = os.linesep.join(dev_info_lines) print(dev_info) print("") 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
def command_akit_testing_query(root, includes, excludes, debug): # 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.variables import extend_path, AKIT_VARIABLES ctx = Context() env = ctx.lookup("/environment") # Set the jobtype env["jobtype"] = "testrun" test_root = None if root is not None: AKIT_VARIABLES.AKIT_TESTROOT = root elif AKIT_VARIABLES.AKIT_TESTROOT is not None: root = AKIT_VARIABLES.AKIT_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) env["testroot"] = test_root # Make sure we extend PATH to include the test root extend_path(test_root) # We use console activation because all our input output is going through the terminal import akit.activation.console 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() result_code = 0 with TestJobType(logger, test_root, includes=includes, excludes=excludes) as tjob: query_results = tjob.query() test_names = [tn for tn in query_results.keys()] test_names.sort() print() print("Tests:") for tname in test_names: tref = query_results[tname] print(" " + tname) param_names = [pn for pn in tref.subscriptions.keys()] param_names.sort() for pname in param_names: pinfo = tref.subscriptions[pname] print(" {}: {}".format(pname, pinfo.describe_source())) print() if len(tjob.import_errors) > 0: print("IMPORT ERRORS:", file=sys.stderr) for ifilename in tjob.import_errors: imperr_msg = ifilename print(" " + imperr_msg, file=sys.stderr) print("", file=sys.stderr) return
AKIT_VARIABLES.AKIT_ACTIVATION_PROFILE) raise AKitSemanticError(errmsg) AKIT_VARIABLES.AKIT_ACTIVATION_PROFILE = ActivationProfile.Service if "AKIT_SERVICE_NAME" not in os.environ: errmsg = "To use the AutomationKit to provide a service, you must " \ "set the AKIT_SERVICE_NAME environment variable." raise AKitConfigurationError(errmsg) service_name = os.environ["AKIT_SERVICE_NAME"] AKIT_VARIABLES.AKIT_LOG_LEVEL_CONSOLE = "INFO" AKIT_VARIABLES.AKIT_SERVICE_NAME = service_name AKIT_VARIABLES.AKIT_JOBTYPE = "service" AKIT_VARIABLES.AKIT_OUTPUT_DIRECTORY = "~/akit/services/{}".format( service_name) # For console activation we don't want to log to the console and we want # to point the logs to a different output folder os.environ["AKIT_LOG_LEVEL_CONSOLE"] = AKIT_VARIABLES.AKIT_LOG_LEVEL_CONSOLE os.environ["AKIT_JOBTYPE"] = AKIT_VARIABLES.AKIT_JOBTYPE os.environ["AKIT_OUTPUT_DIRECTORY"] = AKIT_VARIABLES.AKIT_OUTPUT_DIRECTORY import akit.activation.base # pylint: disable=unused-import,wrong-import-position from akit.xlogging.foundations import logging_initialize, LoggingDefaults # pylint: disable=wrong-import-position LoggingDefaults.DefaultFileLoggingHandler = RotatingFileHandler logging_initialize()