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_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)
