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(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]
if TemplateFields.TARGET not in action_target:
LOG.error('%s status code: %s' % (status_msgs[131], 131))
return get_content_fault_result(131)
target = action_target[TemplateFields.TARGET]
return validate_template_id(definitions_index, target)
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(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(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_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_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(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_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_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):
if TemplateFields.ACTION_TARGET not in action:
LOG.error('%s status code: %s' % (status_msgs[124], 124))
return get_content_fault_result(124)
properties = action[TemplateFields.PROPERTIES]
if TemplateFields.STATE not in properties:
LOG.error('%s status code: %s' % (status_msgs[128], 128))
return get_content_fault_result(128)
action_target = action[TemplateFields.ACTION_TARGET]
if TemplateFields.TARGET not in action_target:
LOG.error('%s status code: %s' % (status_msgs[129], 129))
return get_content_fault_result(129)
target = action_target[TemplateFields.TARGET]
return validate_template_id(definitions_index, target)
def _validate_scenario_action(template_schema, def_index, action):
action_type = action[TemplateFields.ACTION_TYPE]
action_validator = template_schema.validators.get(action_type)
if not action_validator:
LOG.error('%s status code: %s' % (status_msgs[120], 120))
return get_content_fault_result(120)
return action_validator.validate(action, def_index)
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_templates(db, templates, cli_type, params):
results = list()
for template in templates:
final_type = template[METADATA].get(TFields.TYPE, cli_type)
if not final_type or (cli_type and cli_type != final_type):
results.append(
get_content_fault_result(66, "Unknown template type"))
else:
results.append(_validate_template(db, template, final_type,
params))
return results
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_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(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)
properties = action[TemplateFields.PROPERTIES]
if TemplateFields.ALARM_NAME not in properties:
LOG.error('%s status code: %s' % (status_msgs[125], 125))
return get_content_fault_result(125)
if TemplateFields.SEVERITY not in properties:
LOG.error('%s status code: %s' % (status_msgs[126], 126))
return get_content_fault_result(126)
action_target = action[TemplateFields.ACTION_TARGET]
if TemplateFields.TARGET not in action_target:
LOG.error('%s status code: %s' % (status_msgs[127], 127))
return get_content_fault_result(127)
target = action_target[TemplateFields.TARGET]
return validate_template_id(definitions_index, target)
def _validate_relationship(relationship, relationships_index, entities_index):
template_id = relationship[TemplateFields.TEMPLATE_ID]
if template_id in relationships_index or template_id in entities_index:
LOG.error('%s status code: %s' % (status_msgs[2], 2))
return get_content_fault_result(2)
target = relationship[TemplateFields.TARGET]
result = validate_template_id(entities_index, target)
if result.is_valid_config:
source = relationship[TemplateFields.SOURCE]
result = validate_template_id(entities_index, source)
return result
def _validate_scenario_action(action, definitions_index):
action_type = action[TemplateFields.ACTION_TYPE]
action_validators = {
ActionType.RAISE_ALARM: RaiseAlarmValidator(),
ActionType.SET_STATE: SetStateValidator(),
ActionType.ADD_CAUSAL_RELATIONSHIP: AddCausalRelationshipValidator(),
ActionType.MARK_DOWN: MarkDownValidator(),
ActionType.EXECUTE_MISTRAL: ExecuteMistralValidator(),
}
if action_type not in action_validators:
LOG.error('%s status code: %s' % (status_msgs[120], 120))
return get_content_fault_result(120)
return action_validators[action_type].validate(action, definitions_index)
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)
