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_content_fault_result(86, msg) else: res = _validate_not_condition(arg, definitions_index) if not res.is_valid_config: return res return get_content_correct_result() 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_content_correct_result()
def validate_relationships_definitions_with_includes( cls, template_includes, def_templates, entities_index, relationships_index): for include in template_includes: name = include[TemplateFields.NAME] def_template = \ evaluator_utils.find_def_template(name, def_templates) if def_template: defs = def_template[TemplateFields.DEFINITIONS] relationships = defs[TemplateFields.RELATIONSHIPS] for relationship in relationships: relationship_dict = \ relationship[TemplateFields.RELATIONSHIP] template_id = relationship_dict[TemplateFields.TEMPLATE_ID] if template_id not in relationships_index: result = cls._validate_def_template_relationship( relationship_dict, entities_index) if not result.is_valid_config: return result relationships_index[template_id] = relationship_dict return get_content_correct_result()
def _validate_scenario_condition(condition, definitions_index): try: dnf_result = convert_to_dnf_format(condition) except Exception: LOG.error('%s status code: %s' % (status_msgs[85], 85)) return get_content_fault_result(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_vars = reduce(lambda cond, v: cond.replace(v, ' '), values_to_replace, condition) for condition_var in condition_vars.split(' '): if len(condition_var.strip()) == 0: continue result = validate_template_id(definitions_index, condition_var) if not result.is_valid_config: return result # condition structure validation condition_structure_result = \ validate_condition_structure(parse_condition(condition), definitions_index) if not condition_structure_result.is_valid_config: return condition_structure_result return get_content_correct_result()
def validate(action, definitions_index): if TemplateFields.ACTION_TARGET not in action: LOG.error('%s status code: %s' % (status_msgs[124], 124)) return get_content_fault_result(124) 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_content_fault_result(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 = AddCausalRelationshipValidator._validate_entity_category( entity, EntityCategory.ALARM) if not result.is_valid_config: return result return get_content_correct_result()
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_content_fault_result(2) return get_content_correct_result()
def validate(action, definitions_index): properties = action[TemplateFields.PROPERTIES] if WORKFLOW not in properties or not properties[WORKFLOW]: LOG.error('%s status code: %s' % (status_msgs[133], 133)) return get_content_fault_result(133) return get_content_correct_result()
def validate(cls, template, actual_params): try: function_resolver.validate_function(function_resolver.FuncInfo( name=GET_PARAM, func=get_param, error_code=0), template, actual_params=actual_params) except ValidationError as e: return get_custom_fault_result(e.code, e.details) return get_content_correct_result()
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_content_correct_result()
def _validate_scenario_actions(self, actions): for action in actions: result = \ self._validate_scenario_action(action[TemplateFields.ACTION]) if not result.is_valid_config: return result return get_content_correct_result()
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_content_fault_result(132, msg) return get_content_correct_result()
def validate_condition_structure(condition_dnf, definitions_index): result = validate_condition_includes_positive_clause(condition_dnf) if not result.is_valid_config: return result common_targets = get_condition_common_targets(condition_dnf, definitions_index, TemplateSymbolResolver()) return get_content_correct_result() if common_targets \ else get_content_fault_result(135)
def _validate_scenario_actions(cls, template_schema, def_index, actions): for action in actions: result = \ cls._validate_scenario_action(template_schema, def_index, action[TemplateFields.ACTION]) if not result.is_valid_config: return result return get_content_correct_result()
def validate(cls, template, actual_params): # if there is a get_param in the template, an error message will be # returned since func is None try: function_resolver.validate_function( func_info=function_resolver.FuncInfo( name=GET_PARAM, func=None, error_code=160), template=template, actual_params=actual_params) except ValidationError as e: return get_custom_fault_result(e.code, e.details) return get_content_correct_result()
def validate(action, definitions_index): properties = action[TemplateFields.PROPERTIES] if WORKFLOW not in properties or not properties[WORKFLOW]: LOG.error('%s status code: %s' % (status_msgs[133], 133)) return get_content_fault_result(133) for key, value in properties.items(): if not isinstance(value, dict) and is_function(value): LOG.error('%s status code: %s' % (status_msgs[137], 137)) return get_content_fault_result(137) return get_content_correct_result()
def validate_entities_definition(cls, entities, entities_index): for entity in entities: entity_dict = entity[TemplateFields.ENTITY] result = \ cls._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_content_correct_result()
def _validate_version(template): metadata = template.get(TemplateFields.METADATA) if metadata is None: LOG.error('%s status code: %s' % (status_msgs[62], 62)) return get_content_fault_result(62) version = metadata.get(TemplateFields.VERSION, DEFAULT_VERSION) if version in SUPPORTED_VERSIONS: return get_content_correct_result() else: LOG.error('%s status code: %s' % (status_msgs[63], 63)) return get_content_fault_result(63)
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_content_correct_result()
def validate(self, metadata): if not metadata: return get_content_fault_result(62) type = metadata.get(TemplateFields.TYPE) if not type: LOG.error('%s status code: %s' % (status_msgs[64], 64)) return get_content_fault_result(64) if type not in TemplateTypes.types(): LOG.error('%s status code: %s' % (status_msgs[65], 65)) return get_content_fault_result(65) return get_content_correct_result()
def _validate_include_entities_definition(def_template_entities, entities_index): for entity in def_template_entities: entity_dict = entity[TemplateFields.ENTITY] result = _validate_entity_definition(entity_dict, entities_index) if not result.is_valid_config: return result if entity_dict[TemplateFields.TEMPLATE_ID] not in entities_index: id = entity_dict[TemplateFields.TEMPLATE_ID] entities_index[id] = entity_dict return get_content_correct_result()
def _validate_entity_definition(cls, 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_content_fault_result(2) for key, value in entity_dict.items(): if key.lower().endswith(TemplateFields.REGEX): try: re.compile(value) except Exception: LOG.error('%s %s status code: %s' % (status_msgs[47], str(key), 47)) return get_content_fault_result(47) return get_content_correct_result()
def validate(self, scenarios): for scenario in scenarios: scenario_values = scenario[TemplateFields.SCENARIO] condition = scenario_values[TemplateFields.CONDITION] result = self._validate_scenario_condition(condition) if not result.is_valid_config: return result actions = scenario_values[TemplateFields.ACTIONS] result = self._validate_scenario_actions(actions) if not result.is_valid_config: return result return get_content_correct_result()
def content_validation(template, def_templates={}): result = get_content_correct_result() entities_index = {} template_definitions = {} if TemplateFields.DEFINITIONS in template: template_definitions = template[TemplateFields.DEFINITIONS] if TemplateFields.ENTITIES in template_definitions: entities = template_definitions[TemplateFields.ENTITIES] result = _validate_entities_definition(entities, entities_index) # If there are duplicate definitions in several includes under the same # name, will regard the first one if result.is_valid_config and TemplateFields.INCLUDES in template: template_includes = template[TemplateFields.INCLUDES] result = _validate_definitions_with_includes(template_includes, def_templates, entities_index) relationships_index = {} if result.is_valid_config and \ TemplateFields.RELATIONSHIPS in template_definitions: relationships = template_definitions[TemplateFields.RELATIONSHIPS] result = _validate_relationships_definitions(relationships, relationships_index, entities_index) if result.is_valid_config and TemplateFields.INCLUDES in template: template_includes = template[TemplateFields.INCLUDES] result = _validate_relationships_definitions_with_includes( template_includes, def_templates, entities_index, relationships_index) if result.is_valid_config: scenarios = template[TemplateFields.SCENARIOS] definitions_index = entities_index.copy() definitions_index.update(relationships_index) result = _validate_scenarios(scenarios, definitions_index) return result
def resolve_parameters(template_def, params=None): result, template_schema = get_template_schema(template_def) if not result.is_valid_config: return result get_param = template_schema.functions.get(GET_PARAM) try: function_resolver.resolve_function( func_info=function_resolver.FuncInfo(name=GET_PARAM, func=get_param, error_code=0), template=template_def, actual_params=params) except ValidationError as e: return get_custom_fault_result(e.code, e.details) return get_content_correct_result()
def validate(cls, template_schema, def_index, scenarios): for scenario in scenarios: scenario_values = scenario[TemplateFields.SCENARIO] condition = scenario_values[TemplateFields.CONDITION] result = cls._validate_scenario_condition(def_index, condition) if not result.is_valid_config: return result actions = scenario_values[TemplateFields.ACTIONS] result = cls._validate_scenario_actions(template_schema, def_index, actions) if not result.is_valid_config: return result return get_content_correct_result()
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_content_correct_result()
def validate(action, definitions_index): properties = action[TemplateFields.PROPERTIES] if WORKFLOW not in properties or not properties[WORKFLOW]: LOG.error('%s status code: %s' % (status_msgs[133], 133)) return get_content_fault_result(133) for prop in properties: if prop not in {WORKFLOW, INPUT}: LOG.error('%s status code: %s' % (status_msgs[136], 136)) return get_content_fault_result(136) inputs = properties[INPUT] if INPUT in properties else {} for key, value in inputs.items(): if re.findall('[(),]', value) and not is_function(value): LOG.error('%s status code: %s' % (status_msgs[138], 138)) return get_content_warning_result(138) return get_content_correct_result()
def _validate_definitions_with_includes(template_includes, def_templates, entities_index): for include in template_includes: name = include[TemplateFields.NAME] def_template = evaluator_utils.find_def_template(name, def_templates) if not def_template: LOG.error('%s status code: %s' % (status_msgs[142], 142)) return get_content_fault_result(142) def_template_definitions = def_template[TemplateFields.DEFINITIONS] def_template_entities = \ def_template_definitions[TemplateFields.ENTITIES] result = _validate_include_entities_definition(def_template_entities, entities_index) if not result.is_valid_config: return result return get_content_correct_result()
def validate_condition_includes_positive_clause(condition): return get_content_correct_result() if \ is_condition_include_positive_clause(condition) \ else get_content_fault_result(134)