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)