def get_config(self, config, requested_config_options,
requested_command_config_options):
return ExtensionConfig({
'13': 13,
'14': 13,
'15': 13,
}, priority=13)
def get_config(self, config, requested_config_options,
requested_command_config_options):
dot_zebra_file = self.find_zebra_file(os.getcwd())
if dot_zebra_file:
return _recursively_load_configuration(dot_zebra_file, 9)
else:
return ExtensionConfig({}, 9)
def get_config(self, config, requested_config_options,
requested_command_config_options):
return ExtensionConfig(
{
AVAILABLE_POWER_SWITCHES.name: ['gude'],
AVAILABLE_POWER_METERS.name: ['gude']
}, 1, 'gude')
def get_config(self, config, requested_config_options,
requested_command_config_options):
changelog_type = config.get(APPLICATION_CHANGELOG_TYPE)
changelog_config = {}
if changelog_type == ChangeLogType.ZNAKE:
root_package = config.get(APPLICATION_ROOT)
version_module_name = '{root}.version'.format(root=root_package)
version_module = importlib.import_module(version_module_name)
versions = []
changelog_config = {}
for version_info in version_module.changelog:
version = version_info['version']
versions.append(version)
changelog_config['.'.join(['changelog', version,
'date'])] = version_info['date']
changelog_config['.'.join(['changelog', version, 'changes'
])] = version_info['changes']
changelog_config['changelog.versions'] = versions
if changelog_type != ChangeLogType.NONE:
changelog_config['ext.changelogcommand.enabled'] = True
return ExtensionConfig(
changelog_config,
priority=9,
)
def get_config(self, config, requested_config_options,
requested_command_config_options):
extension_configs = defaultdict(list)
if config.get(
COMMAND) == 'run' and config.get(LOGDEFAULTS_ENABLED) is True:
for extension in config.get(ENABLED_EXTENSIONS):
level = 'warning'
if extension in ['testrunner']:
level = 'info'
file_path = os.path.join('extensions',
'{ext}.log'.format(ext=extension))
self._log_file_config(config, extension, file_path,
extension_configs)
ext_level_config_name = '.'.join(
['ext', extension, EXTENSION_LOG_LEVEL.name])
extension_configs[ext_level_config_name] = level
self._log_file_config(config, 'all', 'all.log', extension_configs,
'')
self._log_file_config(config,
'alljsonl',
'all.jsonl',
extension_configs,
'',
filetype='json')
self._log_file_config(config,
'allinfo',
'all_info.log',
extension_configs,
'',
level='info')
self._log_file_config(config, 'messages', 'messages.log',
extension_configs, 'zaf.messages')
self._log_file_config(config,
'config',
'config.log',
extension_configs,
'zaf.config.manager',
format='%(message)s')
self._log_file_config(config, 'extensions', 'extensions.log',
extension_configs, 'zaf.extensions')
self._log_file_config(config, 'components', 'components.log',
extension_configs, 'zaf.component')
self._log_file_config(
config,
'testcase.log',
'testcase.log',
extension_configs,
'testcase',
additional_logger_levels={'info': ['k2.extension.testrunner']})
extension_configs[LOG_LEVEL.name] = 'warning'
self._setup_testrun_directory(extension_configs, 'debug')
return ExtensionConfig(extension_configs, priority=self.priority)
def get_config(self, config, requested_config_options,
requested_command_config_options):
print('11: {prio}'.format(prio=config._raw_get('11')))
print('12: {prio}'.format(prio=config._raw_get('12')))
print('13: {prio}'.format(prio=config._raw_get('13')))
print('14: {prio}'.format(prio=config._raw_get('14')))
print('15: {prio}'.format(prio=config._raw_get('15')))
return ExtensionConfig({}, priority=1)
def get_config(self, config, requested_config_options,
requested_command_config_options):
prog_name = config.get(ENTRYPOINT_NAME, 'zaf')
check_for_ambiguous_duplicates(prog_name, requested_config_options,
requested_command_config_options)
return ExtensionConfig(parse_partial(config, prog_name,
requested_config_options),
priority=CLICK_CONFIG_PRIORITY)
def get_config(self, config, requested_config_options,
requested_command_config_options):
return ExtensionConfig(
{
REGISTRY_CACHE_OPTION.key: find_docker_registry_cache(),
},
priority=1,
source='dockerconfig')
def get_config(self, config, requested_config_options,
requested_command_config_options):
load_order = self.__class__.load_order
previous = config._raw_get(str(load_order - 1), default=20)
print('load order: {order}, previous: {prev}'.format(
order=load_order, prev=previous))
assert previous == load_order - 1
return ExtensionConfig({str(load_order): load_order}, priority=1)
def test_get_config_returns_config_from_dot_zebra_file(self):
with patch.object(DotZebraExtension, 'find_zebra_file', return_value='.zebra'), \
patch('zebra.config.dotzebra._recursively_load_configuration',
return_value=ExtensionConfig({'image': 'abs.u16'}, 9)):
with create_harness() as harness:
self.assertEqual(
harness.extension.get_config(Mock(), [],
{}).config['image'],
'abs.u16')
def get_config(self, config, requested_config_options, requested_command_config_options):
if config.get(ANSIBLE_ENABLED, False):
selected_nodes = config.get(ANSIBLE_NODE)
if selected_nodes:
config = {'suts.ids': selected_nodes}
else:
config = {'suts.ids': config.get(ANSIBLE_NODES)}
else:
config = {}
return ExtensionConfig(config, priority=1, source='ansiblesuts')
def get_config(self, config, requested_config_options,
requested_command_config_options):
verbosity = config.get(VERBOSE)
if verbosity == 0:
return ExtensionConfig(
{
'log.warning': [''],
'log.info': ['zebra'],
'log.debug': [],
},
9,
source='verbosity')
else:
return ExtensionConfig(
{
'log.warning': [''],
'log.info': [],
'log.debug': ['zebra'],
},
9,
source='verbosity')
def get_config(self, config, requested_config_options, requested_command_config_options):
extension_config = {}
for sut in config.get(SUT):
if config.get(SUT_SERIAL_ENABLED, entity=sut):
if config.get(SUT_SERIAL_PORTS, entity=sut):
raise MissingConditionalConfigOption(
'Mixing of sut and serial port id options is not supported!')
add_sut_options_to_extension_config(sut, extension_config, config)
sut_add_log_source(extension_config, sut, serial_log_line_entity(sut))
else:
for port in config.get(SUT_SERIAL_PORTS, entity=sut):
if config.get(SERIAL_ENABLED, entity=port) and config.get(SERIAL_LOG_ENABLED,
entity=port):
sut_add_log_source(extension_config, sut, serial_log_line_entity(port))
return ExtensionConfig(extension_config, 1, 'zserial')
def _recursively_load_configuration(path, priority, parent_path=None):
extension_configs = []
try:
config = _load_yaml_configuration(path)
_validate_configuration(config)
except FileNotFoundError as e:
parent_string = ", included from file '{parent_path}',".format(
parent_path=parent_path) if parent_path else ''
raise FileNotFoundError(
"File '{included_file}'{parent} was not found.".format(
included_file=path, parent=parent_string)) from e
except ConfigLoaderError as e:
e.args = (e.args[0] + ' (source: {path})'.format(path=path), )
raise
extension_configs.append(
ExtensionConfig(config, priority=priority, source=path))
if 'include.files' in config:
for include_path in config['include.files']:
include_path = _ensure_absolute_path(include_path, path)
extension_configs.extend(
_recursively_load_configuration(include_path, priority - 1,
path))
# Should not be included in config because this is not a valid config option
del config['include.files']
entity_include_keys_to_be_deleted = []
for key in config.keys():
if key.endswith('.include.files'):
entity_include_keys_to_be_deleted.append(key)
entity = key.split('.include.files')[0]
include_files = [
_ensure_absolute_path(x, path) for x in config[key]
]
extension_configs.extend(
_load_entity_include(entity, include_files, priority, path))
# Should not be included in config because these are already loaded and
# if they are kept they might be loaded again by entity include extensions.
for key in entity_include_keys_to_be_deleted:
del config[key]
return extension_configs
def get_config(self, config, requested_config_options, requested_command_config_options):
def get_option_ids_sorted_by_dependencies(options):
"""
Get the option ids from the options and sort to give ids that others depend on first.
The ordering is done so that entity options are validated first so that they
can be used later on to retrieve the values for the "at"-options without
triggering strange errors.
"""
def order(option_id):
if option_id.entity:
return -1
else:
return 1
return sorted((option.option_id for option in options), key=order)
def find_command_options(command_name):
for command, options in requested_command_config_options.items():
if command.name == command_name:
return options
return []
checker = ConfigOptionIdTypeChecker(config)
all_options = requested_config_options + find_command_options(config.get(COMMAND))
for option_id in get_option_ids_sorted_by_dependencies(all_options):
if option_id.at is not None:
if option_id.at.multiple:
for entity in config.get(option_id.at):
value = config.get(option_id, entity=entity, transform=False)
checker.assert_type(option_id, value, entity)
else:
entity = config.get(option_id.at)
value = config.get(option_id, entity=entity, transform=False)
checker.assert_type(option_id, value, entity)
else:
value = config.get(option_id, transform=False)
checker.assert_type(option_id, value)
return ExtensionConfig({}, priority=0)
def get_config(self, config, requested_config_options,
requested_command_config_options):
def _glob(pattern):
return glob.glob(pattern)
extension_configs = [
ExtensionConfig(self.default_config, priority=self.priority)
]
for path in itertools.chain(
*list(map(_glob, self.config_file_glob_patterns))):
if os.path.isdir(path) and is_bash_completion():
logger.debug(
"Directory found during bash completion. Skipping path '{path}'"
.format(path=path))
else:
extension_configs.extend(
_recursively_load_configuration(path, self.priority))
return extension_configs
def _load_entity_include(entity_prefix,
included_files,
priority,
parent_path=None):
"""Load include files for the and prefixes all keys with entity prefix."""
extension_configs = []
for entity_include_path in included_files:
entity_configs = _recursively_load_configuration(
entity_include_path, priority - 1, parent_path)
for entity_config in entity_configs:
updated_config = {}
for entity_key, entity_value in entity_config.config.items():
updated_config['{entity_prefix}.{entity_key}'.format(
entity_prefix=entity_prefix,
entity_key=entity_key)] = entity_value
extension_configs.append(
ExtensionConfig(updated_config, entity_config.priority,
entity_config.source))
return extension_configs
def get_config(self, config, requested_config_options,
requested_command_config_options):
return ExtensionConfig({AVAILABLE_POWER_SWITCHES.name: ['sispm']}, 1,
'sispmpowerswitch')
def get_config(self, config, requested_config_options, requested_command_config_options):
return ExtensionConfig({AVAILABLE_POWER_METERS.name: ['dummy']}, 1, 'dummypowermeter')
def get_config(self, config, requested_config_options, requested_command_config_options):
"""Change log level for cleancontainers and cleanimages to not get docker spam on command line."""
created_config = {}
if config.get(COMMAND) in ['cleancontainers', 'cleanimages']:
created_config = {'log.level': 'warning'}
return ExtensionConfig(created_config, priority=1, source='CleanDocker')
def get_config(self, config, requested_config_options,
requested_command_config_options):
application_context = config.get(APPLICATION_CONTEXT)
ignore_hidden = any_option_in_sys_argv(
FULL_HELP_OPTIONS) or IS_BASH_COMPLETION
main_options = prepare_config_options(
config,
None,
get_applicable_options(requested_config_options,
application_context),
ignore_hidden,
disable_required=self.try_to_parse)
main_defaults = {
translate_param_to_config(option.name): option.default
for option in main_options
}
prog_name = config.get(ENTRYPOINT_NAME, 'zaf')
version = config.get(APPLICATION_VERSION)
try:
main_command = ClickCommandWithConfigOptions(
config,
command=None,
all_commands=requested_command_config_options.keys(),
command_config_options=requested_command_config_options,
application_context=application_context,
ignore_hidden=ignore_hidden,
disable_required=self.try_to_parse,
name=prog_name,
params=main_options,
context_settings={'help_option_names': HELP_OPTIONS})
click.version_option(version)(main_command)
is_help_or_version = (any_option_in_sys_argv(HELP_OPTIONS)
or any_option_in_sys_argv(VERSION_OPTIONS))
if self.try_to_parse:
args = [
arg for arg in sys.argv
if arg not in HELP_OPTIONS and arg not in VERSION_OPTIONS
][1:]
try:
# Special call to main that tries to parse the command line
main_command.main(args=args,
prog_name=prog_name,
standalone_mode=False,
allow_extra_args=True,
ignore_unknown_options=True)
except click.exceptions.UsageError:
# Continuing and letting load order 100 parsing give a correct error message
# This can happen for example for zaf --help because there is no subcommand
return []
else:
main_command.main(standalone_mode=False,
prog_name=prog_name,
max_content_width=120)
if is_help_or_version:
if (any_option_in_sys_argv(HELP_OPTIONS)
and not any_option_in_sys_argv(FULL_HELP_OPTIONS)):
print()
print(
'To see hidden commands and options use --full-help.'
)
sys.exit(0)
click_config = main_command.created_config
defaults = main_defaults.copy()
command = main_command
while type(command) == ClickCommandWithConfigOptions:
defaults.update(command.command_defaults)
click_config.update(command.created_config)
command = command.executed_command
click_config[COMMAND.name] = command.name
filtered_config = filter_out_same_as_defaults(
click_config, defaults)
return ExtensionConfig(filtered_config,
priority=CLICK_CONFIG_PRIORITY)
except click.exceptions.ClickException as e:
logger.debug(e.format_message(), exc_info=True)
e.show(file=sys.stdout)
exit(2)
