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)
