def _validate_not_condition(dnf_result, definitions_index): """Not operator validation Not operator can appear only on edges. :param dnf_result: :param definitions_index: :return: """ if isinstance(dnf_result, Not): for arg in dnf_result.args: if isinstance(arg, Symbol): definition = definitions_index.get(str(arg), None) if not (definition and definition.get(EProps.RELATIONSHIP_TYPE)): msg = status_msgs[86] + ' template id: %s' % arg LOG.error('%s status code: %s' % (msg, 86)) return get_fault_result(RESULT_DESCRIPTION, 86, msg) else: res = _validate_not_condition(arg, definitions_index) if not res.is_valid_config: return res return get_correct_result(RESULT_DESCRIPTION) for arg in dnf_result.args: if not isinstance(arg, Symbol): res = _validate_not_condition(arg, definitions_index) if not res.is_valid_config: return res return get_correct_result(RESULT_DESCRIPTION)
def validate_template_id(definitions_index, id_to_check): if id_to_check not in definitions_index: msg = status_msgs[3] + ' template id: %s' % id_to_check LOG.error('%s status code: %s' % (msg, 3)) return get_fault_result(RESULT_DESCRIPTION, 3, msg) return get_correct_result(RESULT_DESCRIPTION)
def _validate_definitions_section(definitions, has_includes): # Entities are required if there are no relationships, or if there are # relationships and no imported entities from a definition template # (otherwise the template is empty) if TemplateFields.RELATIONSHIPS not in definitions \ or (definitions[TemplateFields.RELATIONSHIPS] and not has_includes): schema = Schema({ Required(TemplateFields.ENTITIES, msg=20): list, TemplateFields.RELATIONSHIPS: list }) result = _validate_dict_schema(schema, definitions) else: result = get_correct_result(RESULT_DESCRIPTION) if result.is_valid_config and TemplateFields.ENTITIES in definitions: entities = definitions[TemplateFields.ENTITIES] result = _validate_entities(entities, has_includes) relationships = definitions.get(TemplateFields.RELATIONSHIPS, None) if result.is_valid_config and relationships: return _validate_relationships(relationships) return result
def _validate_scenario_condition(condition, definitions_index): try: dnf_result = TemplateData.ScenarioData.convert_to_dnf_format(condition) except Exception: LOG.error('%s status code: %s' % (status_msgs[85], 85)) return get_fault_result(RESULT_DESCRIPTION, 85) # not condition validation not_condition_result = \ _validate_not_condition(dnf_result, definitions_index) if not not_condition_result.is_valid_config: return not_condition_result # template id validation values_to_replace = ' and ', ' or ', ' not ', 'not ', '(', ')' condition = reduce(lambda cond, v: cond.replace(v, ' '), values_to_replace, condition) for condition_var in condition.split(' '): if len(condition_var.strip()) == 0: continue result = _validate_template_id(definitions_index, condition_var) if not result.is_valid_config: return result return get_correct_result(RESULT_DESCRIPTION)
def validate_entity_definition(entity_dict, entities_index): template_id = entity_dict[TemplateFields.TEMPLATE_ID] if template_id in entities_index: LOG.error('%s status code: %s' % (status_msgs[2], 2)) return get_fault_result(RESULT_DESCRIPTION, 2) return get_correct_result(RESULT_DESCRIPTION)
def _validate_entity_definition(entity_dict, entities_index): template_id = entity_dict[TemplateFields.TEMPLATE_ID] if template_id in entities_index: LOG.error('%s status code: %s' % (status_msgs[2], 2)) return get_fault_result(RESULT_DESCRIPTION, 2) return get_correct_result(RESULT_DESCRIPTION)
def _validate_template_id(definitions_index, id_to_check): if id_to_check not in definitions_index: msg = status_msgs[3] + ' template id: %s' % id_to_check LOG.error('%s status code: %s' % (msg, 3)) return get_fault_result(RESULT_DESCRIPTION, 3, msg) return get_correct_result(RESULT_DESCRIPTION)
def _validate_scenario_actions(actions, definitions_index): for action in actions: result = _validate_scenario_action(action[TemplateFields.ACTION], definitions_index) if not result.is_valid_config: return result return get_correct_result(RESULT_DESCRIPTION)
def validate_scenario_actions(actions, definitions_index): for action in actions: result = validate_scenario_action(action[TemplateFields.ACTION], definitions_index) if not result.is_valid_config: return result return get_correct_result(RESULT_DESCRIPTION)
def _validate_entity_category(entity_to_check, category): if TemplateFields.CATEGORY not in entity_to_check \ or entity_to_check[TemplateFields.CATEGORY] != category: msg = status_msgs[132] + ' expect %s to be %s' \ % (entity_to_check, category) LOG.error('%s status code: %s' % (msg, 132)) return get_fault_result(RESULT_DESCRIPTION, 132, msg) return get_correct_result(RESULT_DESCRIPTION)
def _validate_dict_schema(schema, value): try: schema(value) except Error as e: status_code = get_status_code(e) msg = status_msgs[status_code] + str(e) LOG.error('%s status code: %s' % (msg, status_code)) return get_fault_result(RESULT_DESCRIPTION, status_code, msg) return get_correct_result(RESULT_DESCRIPTION)
def validate_entities_definition(entities, entities_index): for entity in entities: entity_dict = entity[TemplateFields.ENTITY] result = validate_entity_definition(entity_dict, entities_index) if not result.is_valid_config: return result entities_index[entity_dict[TemplateFields.TEMPLATE_ID]] = entity_dict return get_correct_result(RESULT_DESCRIPTION)
def _validate_entities_definition(entities, entities_index): for entity in entities: entity_dict = entity[TemplateFields.ENTITY] result = _validate_entity_definition(entity_dict, entities_index) if not result.is_valid_config: return result entities_index[entity_dict[TemplateFields.TEMPLATE_ID]] = entity_dict return get_correct_result(RESULT_DESCRIPTION)
def _validate_relationships_definitions(relationships, relationships_index, entities_index): for relationship in relationships: relationship_dict = relationship[TemplateFields.RELATIONSHIP] result = _validate_relationship(relationship_dict, relationships_index, entities_index) if not result.is_valid_config: return result template_id = relationship_dict[TemplateFields.TEMPLATE_ID] relationships_index[template_id] = relationship_dict return get_correct_result(RESULT_DESCRIPTION)
def validate_template(template, def_templates, params=None): result, template_schema = get_template_schema(template) if not result.is_valid_config: return result if template_schema.version() < '3': return _validate_template_v1_v2(template, def_templates, params) try: template_schema.validators[SYNTAX].validate(template) template_schema.validators[CONTENT].validate(template, params) except base.ValidationError as e: return base.get_custom_fault_result(e.code, e.details) except VoluptuousError as e: return base.get_custom_fault_result(base.get_status_code(e), str(e)) return base.get_correct_result()
def validate_relationships_definitions(relationships, relationships_index, entities_index): for relationship in relationships: relationship_dict = relationship[TemplateFields.RELATIONSHIP] result = validate_relationship(relationship_dict, relationships_index, entities_index) if not result.is_valid_config: return result template_id = relationship_dict[TemplateFields.TEMPLATE_ID] relationships_index[template_id] = relationship_dict return get_correct_result(RESULT_DESCRIPTION)
def _validate_name_schema(schema, name): try: schema(name) except Error as e: status_code = get_status_code(e) if status_code: msg = status_msgs[status_code] else: # General syntax error status_code = 4 msg = status_msgs[4] + str(e) LOG.error('%s status code: %s' % (msg, status_code)) return get_fault_result(RESULT_DESCRIPTION, status_code, msg) return get_correct_result(RESULT_DESCRIPTION)
def _validate_dict_schema(schema, value): try: schema(value) except Error as e: status_code = _get_status_code(e) if status_code: msg = status_msgs[status_code] else: # General syntax error status_code = 4 msg = status_msgs[4] + str(e) LOG.error('%s status code: %s' % (msg, status_code)) return get_fault_result(RESULT_DESCRIPTION, status_code, msg) return get_correct_result(RESULT_DESCRIPTION)
def _validate_scenarios(scenarios, definitions_index): for scenario in scenarios: scenario_values = scenario[TemplateFields.SCENARIO] condition = scenario_values[TemplateFields.CONDITION] result = _validate_scenario_condition(condition, definitions_index) if not result.is_valid_config: return result actions = scenario_values[TemplateFields.ACTIONS] result = _validate_scenario_actions(actions, definitions_index) if not result.is_valid_config: return result return get_correct_result(RESULT_DESCRIPTION)
def validate_scenarios(scenarios, definitions_index): for scenario in scenarios: scenario_values = scenario[TemplateFields.SCENARIO] condition = scenario_values[TemplateFields.CONDITION] result = validate_scenario_condition(condition, definitions_index) if not result.is_valid_config: return result actions = scenario_values[TemplateFields.ACTIONS] result = validate_scenario_actions(actions, definitions_index) if not result.is_valid_config: return result return get_correct_result(RESULT_DESCRIPTION)
def _validate_add_causal_relationship_action(action, definitions_index): action_target = action[TemplateFields.ACTION_TARGET] for key in [TemplateFields.TARGET, TemplateFields.SOURCE]: if key not in action_target: LOG.error('%s status code: %s' % (status_msgs[130], 130)) return get_fault_result(RESULT_DESCRIPTION, 130) template_id = action_target[key] result = _validate_template_id(definitions_index, template_id) if not result.is_valid_config: return result entity = definitions_index[template_id] result = _validate_entity_category(entity, EntityCategory.ALARM) if not result.is_valid_config: return result return get_correct_result(RESULT_DESCRIPTION)
def _validate_definitions_section(definitions, has_includes): if TemplateFields.RELATIONSHIPS not in definitions \ or definitions[TemplateFields.RELATIONSHIPS] != '': schema = Schema({ Required(TemplateFields.ENTITIES, msg=20): list, TemplateFields.RELATIONSHIPS: list }) result = _validate_dict_schema(schema, definitions) else: result = get_correct_result(RESULT_DESCRIPTION) if result.is_valid_config and TemplateFields.ENTITIES in definitions: entities = definitions[TemplateFields.ENTITIES] result = _validate_entities(entities, has_includes) relationships = definitions.get(TemplateFields.RELATIONSHIPS, None) if result.is_valid_config and relationships: return _validate_relationships(relationships) return result
def validate_add_causal_relationship_action(action, definitions_index): action_target = action[TemplateFields.ACTION_TARGET] for key in [TemplateFields.TARGET, TemplateFields.SOURCE]: if key not in action_target: LOG.error('%s status code: %s' % (status_msgs[130], 130)) return get_fault_result(RESULT_DESCRIPTION, 130) template_id = action_target[key] result = _validate_template_id(definitions_index, template_id) if not result.is_valid_config: return result entity = definitions_index[template_id] result = _validate_entity_category(entity, EntityCategory.ALARM) if not result.is_valid_config: return result return get_correct_result(RESULT_DESCRIPTION)
def validate_scenario_condition(condition, definitions_index): try: TemplateData.convert_to_dnf_format(condition) except Exception: LOG.error('%s status code: %s' % (status_msgs[85], 85)) return get_fault_result(RESULT_DESCRIPTION, 85) values_to_replace = ' and ', ' or ', ' not ', '(', ')' condition = reduce(lambda cond, v: cond.replace(v, ' '), values_to_replace, condition) for condition_var in condition.split(' '): if len(condition_var.strip()) == 0: continue result = _validate_template_id(definitions_index, condition_var) if not result.is_valid_config: return result return get_correct_result(RESULT_DESCRIPTION)
def get_content_correct_result(): return get_correct_result(RESULT_DESCRIPTION)