def test_not_operator(self): basic_correct_not_condition_path = \ '%s/templates/not_operator/basic_correct_not_condition.yaml' % \ utils.get_resources_dir() basic_correct_not_condition_template = \ file_utils.load_yaml_file(basic_correct_not_condition_path) self._execute_and_assert_with_correct_result( basic_correct_not_condition_template) basic_incorrect_not_condition_path = \ '%s/templates/not_operator/basic_incorrect_not_condition.yaml' % \ utils.get_resources_dir() basic_incorrect_not_condition_template = \ file_utils.load_yaml_file(basic_incorrect_not_condition_path) self._execute_and_assert_with_fault_result( basic_incorrect_not_condition_template, 86) complicated_correct_not_condition_path = \ '%s/templates/not_operator/' \ 'complicated_correct_not_condition.yaml' % \ utils.get_resources_dir() complicated_correct_not_condition_template = \ file_utils.load_yaml_file(complicated_correct_not_condition_path) self._execute_and_assert_with_correct_result( complicated_correct_not_condition_template) complicated_incorrect_not_condition_path = \ '%s/templates/not_operator/' \ 'complicated_incorrect_not_condition.yaml' % \ utils.get_resources_dir() complicated_incorrect_not_condition_template = \ file_utils.load_yaml_file(complicated_incorrect_not_condition_path) self._execute_and_assert_with_fault_result( complicated_incorrect_not_condition_template, 86)
def __init__(self, conf): super(SnmpSender, self).__init__(conf) self.hosts = load_yaml_file(self.conf.snmp.consumers, True) self.oid_tree = load_yaml_file(self.conf.snmp.oid_tree, True) self.alarm_mapping = \ load_yaml_file(self.conf.snmp.alarm_oid_mapping, True) self.oids, self.var_fields = self._build_oids()
def _get_cluster_name(self): kubeconf = file_utils.load_yaml_file(self.conf.kubernetes.config_file) contexts = kubeconf['contexts'] for context in contexts: if context['name'] == kubeconf['current-context']: cluster_name = context['context']['cluster'] return cluster_name
def test_basic_regex(self): basic_regex_path = \ REGEX_TEMPLATE_DIR % (utils.get_resources_dir(), "basic_regex.yaml") basic_regex_template = \ file_utils.load_yaml_file(basic_regex_path) self._execute_and_assert_with_correct_result(basic_regex_template)
def test_template_with_no_defs_only_includes(self): template_path = '/templates/only_using_def_template_definitions.yaml' template = file_utils.load_yaml_file(self.def_templates_tests_path + template_path) self._execute_and_assert_with_correct_result(template, self.def_templates)
def test_def_template_with_scenario_section(self): def_template_path = self.def_template_dir_path + \ '/definition_templates/with_scenarios.yaml' def_template = file_utils.load_yaml_file(def_template_path) self._test_execution_with_fault_result_for_def_template( def_template, 143)
def test_template_with_include(self): template_path = '/templates/basic_with_include.yaml' template = file_utils.load_yaml_file(self.def_templates_tests_path + template_path) self._execute_and_assert_with_correct_result(template, self.def_templates)
def test_faulty_regex(self): faulty_regex_path = \ REGEX_TEMPLATE_DIR % (utils.get_resources_dir(), "faulty_regex.yaml") faulty_regex_template = \ file_utils.load_yaml_file(faulty_regex_path) self._execute_and_assert_with_fault_result(faulty_regex_template, 47)
def __init__(self, worker_id, conf): super(SnmpParsingService, self).__init__(worker_id, conf) self.conf = conf self.listening_port = conf.snmp_parsing.snmp_listening_port self.oid_mapping = \ load_yaml_file(self.conf.snmp_parsing.oid_mapping) self._init_oslo_notifier()
def test_template_with_conflicting_include_entities(self): template_path = '/templates/with_conflicting_include_entities.yaml' template = file_utils.load_yaml_file(self.def_templates_tests_path + template_path) self._execute_and_assert_with_fault_result(template, 2, self.def_templates)
def _execute_condition_template_with_fault_result(self, template_name, status_code): template_path = CONDITION_TEMPLATES_DIR % (utils.get_resources_dir(), template_name) template_definition = file_utils.load_yaml_file(template_path, True) self._execute_and_assert_with_fault_result(template_definition, status_code)
def __init__(self): try: tmfapi639_config_file = CONF.tmfapi639[DSOpts.CONFIG_FILE] tmfapi639_config = file_utils.load_yaml_file(tmfapi639_config_file) self.endpoints = self._create_mapping(tmfapi639_config) except Exception as e: LOG.error("Failed initialization: " + str(e)) self.endpoints = []
def _load_template_file(file_name): try: config = file_utils.load_yaml_file(file_name, with_exception=True) if config: return config except Exception as e: return {TemplateFields.METADATA: {TemplateFields.NAME: file_name}, EXCEPTION: str(e)}
def _configuration_mapping(): prometheus_config_file = CONF.prometheus[DSOpts.CONFIG_FILE] try: prometheus_config = \ file_utils.load_yaml_file(prometheus_config_file) return prometheus_config[PCFProps.ALERTS] except Exception: LOG.exception('Failed in init the configuration file: %s', prometheus_config_file) return {}
def __init__(self, conf): try: nagios_config_file = conf.nagios[DSOpts.CONFIG_FILE] nagios_config = file_utils.load_yaml_file(nagios_config_file) nagios = nagios_config[NAGIOS] # nagios root in the yaml file self.mappings = [self._create_mapping(config) for config in nagios] except Exception as e: LOG.exception('failed in init %s ', e) self.mappings = []
def __init__(self, conf): try: nagios_config_file = conf.nagios['config_file'] nagios_config = file_utils.load_yaml_file(nagios_config_file) nagios = nagios_config[NAGIOS] # nagios root in the yaml file self.mappings = [self._create_mapping(config) for config in nagios] except Exception as e: LOG.exception('failed in init %s ', e) self.mappings = []
def _get_entities_from_file(self, file_, path): static_entities = [] config = file_utils.load_yaml_file(path) for entity in config[self.ENTITIES_SECTION]: static_entities.append(entity.copy()) self.cache[file_] = config return static_entities
def __init__(self): try: kapacitor_config_file = CONF.kapacitor[DSOpts.CONFIG_FILE] kapacitor_config = file_utils.load_yaml_file(kapacitor_config_file) kapacitor = kapacitor_config[KAPACITOR] self.mappings = [self._create_mapping(config) for config in kapacitor] except Exception: LOG.exception('Failed in init.') self.mappings = []
def test_standard_template(self): template_path = '%s/templates/version/v2/%s' % \ (utils.get_resources_dir(), self.STANDARD_TEMPLATE) template_definition = file_utils.load_yaml_file(template_path, True) template_data = get_template_data(template_definition) self.assertIsNotNone(template_data) template_type = template_data.template_type self.assertIsNotNone(template_type, 'v2 template must include a type') self.assertEqual(TemplateTypes.STANDARD, template_type, 'template_type should be ' + TemplateTypes.STANDARD)
def _get_entities_from_file(cls, path): config = file_utils.load_yaml_file(path) if not cls._is_valid_config(config, path): return [] definitions = config[StaticFields.DEFINITIONS] entities = definitions[StaticFields.ENTITIES] relationships = definitions[StaticFields.RELATIONSHIPS] return cls._pack(entities, relationships)
def _get_entities_from_file(cls, path): config = file_utils.load_yaml_file(path) if not cls.is_valid_config(config): LOG.warning("Skipped invalid config (possible obsoleted): {}".format(path)) return [] definitions = config[TopologyFields.DEFINITIONS] entities = definitions[TopologyFields.ENTITIES] relationships = definitions[TopologyFields.RELATIONSHIPS] return cls._pack(entities, relationships)
def _get_entities_from_file(cls, path): config = file_utils.load_yaml_file(path) if not cls._is_valid_config(config): LOG.warning("Skipped invalid config (possible obsoleted): {}" .format(path)) return [] definitions = config[StaticFields.DEFINITIONS] entities = definitions[StaticFields.ENTITIES] relationships = definitions[StaticFields.RELATIONSHIPS] return cls._pack(entities, relationships)
def _get_template_single_action(self, template_file): template_path = '%s/templates/version/%s' % (utils.get_resources_dir(), template_file) template_definition = file_utils.load_yaml_file(template_path, True) template_data = TemplateLoader().load(template_definition) scenarios = template_data.scenarios self.assertIsNotNone(scenarios, 'Template should include a scenario') self.assertThat(scenarios, matchers.HasLength(1), 'Template should include a single scenario') actions = scenarios[0].actions self.assertIsNotNone(actions, 'Scenario should include an action') self.assertThat(actions, matchers.HasLength(1), 'Scenario should include a single action') return actions[0]
def _get_changes_entities(self): entities_updates = [] files = file_utils.list_files( self.cfg.static_physical.directory, '.yaml') for file_ in files: full_path = self.cfg.static_physical.directory +\ '/' + file_ config = file_utils.load_yaml_file(full_path) if StaticDriver.is_valid_config(config): LOG.warning("Skipped config of new static datasource: {}" .format(file_)) return [] if config: if file_ in self.cache: if str(config) != str(self.cache[file_]): # TODO(alexey_weyl): need also to remove deleted # files from cache old_config = copy.deepcopy(config) self._update_on_existing_entities( self.cache[file_][self.ENTITIES_SECTION], config[self.ENTITIES_SECTION], entities_updates) self._update_on_new_entities( config[self.ENTITIES_SECTION], self.cache[file_][self.ENTITIES_SECTION], entities_updates) self.cache[file_] = old_config else: self.cache[file_] = config entities_updates += \ self._get_entities_from_file(file_, full_path) # iterate over deleted files deleted_files = set(self.cache.keys()) - set(files) for file_ in deleted_files: self._update_on_existing_entities( self.cache[file_][self.ENTITIES_SECTION], {}, entities_updates) del self.cache[file_] return entities_updates
def _get_changes_entities(self): entities_updates = [] files = file_utils.list_files( self.cfg.static_physical.directory, '.yaml') for file_ in files: full_path = self.cfg.static_physical.directory +\ '/' + file_ config = file_utils.load_yaml_file(full_path) if StaticDriver._is_valid_config(config): LOG.warning("Skipped config of new static datasource: {}" .format(file_)) return [] if config: if file_ in self.cache: if str(config) != str(self.cache[file_]): # TODO(alexey_weyl): need also to remove deleted # files from cache old_config = copy.deepcopy(config) self._update_on_existing_entities( self.cache[file_][self.ENTITIES_SECTION], config[self.ENTITIES_SECTION], entities_updates) self._update_on_new_entities( config[self.ENTITIES_SECTION], self.cache[file_][self.ENTITIES_SECTION], entities_updates) self.cache[file_] = old_config else: self.cache[file_] = config entities_updates += \ self._get_entities_from_file(file_, full_path) # iterate over deleted files deleted_files = set(self.cache.keys()) - set(files) for file_ in deleted_files: self._update_on_existing_entities( self.cache[file_][self.ENTITIES_SECTION], {}, entities_updates) del self.cache[file_] return entities_updates
def _get_entities_from_file(self, file_, path): static_entities = [] config = file_utils.load_yaml_file(path) if StaticDriver.is_valid_config(config): LOG.warning("Skipped config of new static datasource: {}" .format(file_)) return [] for entity in config[self.ENTITIES_SECTION]: static_entities.append(entity.copy()) self.cache[file_] = config return static_entities
def _get_entities_from_file(self, file_, path): static_entities = [] config = file_utils.load_yaml_file(path) if StaticDriver._is_valid_config(config): LOG.warning("Skipped config of new static datasource: {}" .format(file_)) return [] for entity in config[self.ENTITIES_SECTION]: static_entities.append(entity.copy()) self.cache[file_] = config return static_entities
def _get_event_type(self, snmp_trap): yaml_file_content = load_yaml_file(self.conf.snmp_parsing.oid_mapping) if not yaml_file_content: LOG.warning('No snmp trap is configured!') return None for mapping_info in yaml_file_content: system_oid = extract_field_value(mapping_info, SEProps.SYSTEM_OID) conf_system = extract_field_value(mapping_info, SEProps.SYSTEM) if conf_system == extract_field_value(snmp_trap, system_oid): LOG.debug('snmp trap mapped the system: %s.' % conf_system) return extract_field_value(mapping_info, SEProps.EVENT_TYPE) LOG.error("Snmp trap does not contain system info!") return None
def _check_get_condition_common_targets(self, template_name, valid_targets): template_path = CONDITION_TEMPLATES_DIR % (utils.get_resources_dir(), template_name) template_definition = file_utils.load_yaml_file(template_path, True) template_data = TemplateLoader().load(template_definition) definitions_index = template_data.entities.copy() definitions_index.update(template_data.relationships) common_targets = get_condition_common_targets( template_data.scenarios[0].condition, definitions_index, self.ConditionSymbolResolver()) self.assertIsNotNone(common_targets) self.assertTrue(common_targets == set(valid_targets))
def _configuration_mapping(conf): try: zabbix_config_file = conf.zabbix[DSOpts.CONFIG_FILE] zabbix_config = file_utils.load_yaml_file(zabbix_config_file) zabbix_config_elements = zabbix_config[ZABBIX_DATASOURCE] mappings = {} for element_config in zabbix_config_elements: mappings[element_config['zabbix_host']] = { ZProps.RESOURCE_TYPE: element_config['type'], ZProps.RESOURCE_NAME: element_config['name'] } return mappings except Exception: LOG.exception('Failed in init.') return {}
def _configuration_mapping(conf): try: collectd_config_file = conf.collectd[DSOpts.CONFIG_FILE] collectd_config = file_utils.load_yaml_file(collectd_config_file) collectd_config_elements = collectd_config[COLLECTD_DATASOURCE] mappings = {} for element_config in collectd_config_elements: mappings[element_config['collectd_host']] = { CProps.RESOURCE_TYPE: element_config['type'], CProps.RESOURCE_NAME: element_config['name'] } return mappings except Exception as e: LOG.exception('failed in init %s ', e) return {}
def _configuration_mapping(conf): try: kapacitor_config_file = conf.kapacitor[DSOpts.CONFIG_FILE] kapacitor_config = file_utils.load_yaml_file(kapacitor_config_file) kapacitor_config_elements = kapacitor_config[KAPACITOR_DATASOURCE] mappings = {} for element_config in kapacitor_config_elements: mappings[element_config['kapacitor_host']] = { KProps.RESOURCE_TYPE: element_config['type'], KProps.RESOURCE_NAME: element_config['name'] } return mappings except Exception as e: LOG.exception('failed in init %s ', e) return {}
def _configuration_mapping(conf): try: zabbix_config_file = conf.zabbix['config_file'] zabbix_config = file_utils.load_yaml_file(zabbix_config_file) zabbix_config_elements = zabbix_config['zabbix'] mappings = {} for element_config in zabbix_config_elements: mappings[element_config['zabbix_host']] = { ZProps.RESOURCE_TYPE: element_config['type'], ZProps.RESOURCE_NAME: element_config['name'] } return mappings except Exception as e: LOG.exception('failed in init %s ', e) return {}
def test_basic_template(self): # Test setup template_path = "%s/templates/general/%s" % (utils.get_resources_dir(), self.BASIC_TEMPLATE) template_definition = file_utils.load_yaml_file(template_path, True) template_data = TemplateData(template_definition) entities = template_data.entities relationships = template_data.relationships scenarios = template_data.scenarios definitions = template_definition[TFields.DEFINITIONS] # Assertions entities_definition = definitions[TFields.ENTITIES] self._validate_entities(entities, entities_definition) relate_def = definitions[TFields.RELATIONSHIPS] self._validate_relationships(relationships, relate_def, entities) self._validate_scenarios(scenarios, entities)
def test_template_show(self): """Compare template content from file to DB""" try: # add standard template template_path = \ g_utils.tempest_resources_dir() + '/templates/api/'\ + STANDARD_TEMPLATE v_utils.add_template(STANDARD_TEMPLATE, template_type=TTypes.STANDARD) db_row = v_utils.get_first_template( name='host_high_memory_usage_scenarios', type=TTypes.STANDARD, status=TemplateStatus.ACTIVE) payload_from_db = self.client.template.show(db_row['uuid']) payload_from_file = file.load_yaml_file(template_path) self.assertEqual(payload_from_file, payload_from_db, "Template content doesn't match") v_utils.delete_template(db_row['uuid']) except Exception as e: self._handle_exception(e) raise
def test_equivalence_template(self): equivalence_path = '%s/templates/general/equivalences/%s' % ( utils.get_resources_dir(), self.BASIC_TEMPLATE) equivalence_definition = file_utils.load_yaml_file( equivalence_path, True) equivalence_data = EquivalenceData(equivalence_definition) equivalences = equivalence_data.equivalences expected = [ frozenset([ frozenset([('category', 'ALARM'), ('type', 'nagios'), ('name', 'host_problem')]), frozenset([('category', 'ALARM'), ('type', 'zabbix'), ('name', 'host_fail')]), frozenset([('category', 'ALARM'), ('type', 'vitrage'), ('name', 'host_down')]) ]), ] self.assertEqual(expected, equivalences)
def _retrieve_states_and_priorities_from_file(self, full_path): states = {} priorities = {} config = file_utils.load_yaml_file(full_path, with_exception=True) category = config['category'] for item in config['values']: aggregated_values = item['aggregated values'] priority_value = int(aggregated_values['priority']) # original to operational value for original_state in aggregated_values['original values']: original_value = original_state['name'] operational_value = original_state['operational_value'] states[original_value.upper()] = operational_value priorities[original_value.upper()] = priority_value self._check_validity(category, states, priorities, full_path) self._add_default_states(states, priorities, category) return states, priorities
def _retrieve_values_and_priorities_from_file(self, full_path): values = {} priorities = {} config = file_utils.load_yaml_file(full_path, with_exception=True) vitrage_category = config['category'] for item in config['values']: aggregated_values = item['aggregated values'] priority_value = int(aggregated_values['priority']) # original to operational value for value_map in aggregated_values['original values']: name = value_map['name'] operational_value = value_map['operational_value'] values[name.upper()] = operational_value priorities[name.upper()] = priority_value self._check_validity(vitrage_category, values, priorities, full_path) self._add_default_values(values, priorities, vitrage_category) return values, priorities