def _create_vitrage_neighbors(self, event):
event_type = event[EVALUATOR_EVENT_TYPE]
timestamp = transformer_base.convert_timestamp_format(
'%Y-%m-%d %H:%M:%S.%f', event[VProps.UPDATE_TIMESTAMP])
if event_type in [ADD_EDGE, REMOVE_EDGE]:
relation_edge = graph_utils.create_edge(
source_id=event[TFields.SOURCE],
target_id=event[TFields.TARGET],
relationship_type=event[EProps.RELATIONSHIP_TYPE],
update_timestamp=timestamp)
return [Neighbor(None, relation_edge)]
if event_type == ADD_VERTEX:
result = []
relation_edge = graph_utils.create_edge(
source_id=TransformerBase.uuid_from_deprecated_vitrage_id(
self._create_entity_key(event)),
target_id=event[TFields.TARGET],
relationship_type=EdgeLabel.ON,
update_timestamp=timestamp)
neighbor_props = {
VProps.VITRAGE_IS_PLACEHOLDER:
True,
VProps.UPDATE_TIMESTAMP:
timestamp,
VProps.VITRAGE_SAMPLE_TIMESTAMP:
event[VProps.VITRAGE_SAMPLE_TIMESTAMP],
VProps.IS_REAL_VITRAGE_ID:
True,
VProps.VITRAGE_TYPE:
event.get(VProps.VITRAGE_RESOURCE_TYPE),
VProps.VITRAGE_CATEGORY:
EntityCategory.RESOURCE,
}
result.append(
Neighbor(Vertex(event[TFields.TARGET], neighbor_props),
relation_edge))
if event.get(TFields.CAUSING_ALARM):
relation_edge = graph_utils.create_edge(
source_id=event[TFields.CAUSING_ALARM],
target_id=TransformerBase.uuid_from_deprecated_vitrage_id(
self._create_entity_key(event)),
relationship_type=EdgeLabel.CAUSES,
update_timestamp=timestamp)
result.append(
Neighbor(
Vertex(
event[TFields.CAUSING_ALARM], {
VProps.UPDATE_TIMESTAMP: timestamp,
VProps.VITRAGE_IS_PLACEHOLDER: True,
}), relation_edge))
return result
return []
def test_scenario_0(self):
observed_scenarios = self._load_scenarios('valid_actions.yaml')
expected_scenario = Scenario(
'valid actions-scenario0',
'3',
None,
[
ActionSpecs(
'valid actions-scenario0-action0',
'set_state',
{'target': 'host'},
{'state': 'ERROR'}),
ActionSpecs(
'valid actions-scenario0-action1',
'raise_alarm',
{'target': 'host'},
{'severity': 'WARNING', 'alarm_name': 'ddd'}),
ActionSpecs(
'valid actions-scenario0-action2',
'mark_down',
{'target': 'host'},
{}),
ActionSpecs(
'valid actions-scenario0-action3',
'execute_mistral',
{'target': 'host'},
{'input': {'farewell': 'get_attr(host, name) bla bla'},
'workflow': 'wf_1234'}),
],
[
NXGraph(
vertices=[
Vertex('host_ssh_alarm',
{
'rawtext': 'host ssh is down',
'vitrage_is_placeholder': False,
'vitrage_type': 'zabbix',
'vitrage_is_deleted': False,
}),
Vertex('host',
{
'vitrage_is_placeholder': False,
'vitrage_type': 'nova.host',
'vitrage_is_deleted': False,
})
],
edges=[
Edge('host_ssh_alarm', 'host', 'on',
{
'vitrage_is_deleted': False,
'negative_condition': False
})
])
],
TemplateLoaderV3Test.expected_entities,
TemplateLoaderV3Test.expected_relationships)
self._assert_scenario_equal(
expected_scenario,
observed_scenarios[0])
def test_scenario_1(self):
observed_scenarios = self._load_scenarios('valid_actions.yaml')
expected_scenario = Scenario(
'valid actions-scenario1',
'3',
None,
[
ActionSpecs(
'valid actions-scenario1-action0',
'add_causal_relationship',
{
'target': 'host_ssh_alarm',
'source': 'host_network_alarm',
},
{}),
],
[
NXGraph(
vertices=[
Vertex('host_ssh_alarm',
{
'rawtext': 'host ssh is down',
'vitrage_is_placeholder': False,
'vitrage_type': 'zabbix',
'vitrage_is_deleted': False,
}),
Vertex('host_network_alarm',
{
'rawtext': 'host network interface is down',
'vitrage_is_placeholder': False,
'vitrage_type': 'zabbix',
'vitrage_is_deleted': False,
}),
Vertex('host',
{
'vitrage_is_placeholder': False,
'vitrage_type': 'nova.host',
'vitrage_is_deleted': False,
})
],
edges=[
Edge('host_ssh_alarm', 'host', 'on',
{
'vitrage_is_deleted': False,
'negative_condition': False
}),
Edge('host_network_alarm', 'host', 'on',
{
'vitrage_is_deleted': False,
'negative_condition': False
})
])
],
TemplateLoaderV3Test.expected_entities,
TemplateLoaderV3Test.expected_relationships)
self._assert_scenario_equal(
expected_scenario,
observed_scenarios[1])
def test_scenario_5(self):
observed_scenarios = self._load_scenarios('valid_actions.yaml')
expected_scenario = Scenario(
'valid actions-scenario5',
'3',
None,
[
ActionSpecs(
'valid actions-scenario5-action0',
'mark_down',
{'target': 'host'},
{}),
],
[
NXGraph(
vertices=[
Vertex('host_ssh_alarm',
{
'rawtext': 'host ssh is down',
'vitrage_is_placeholder': False,
'vitrage_type': 'zabbix',
'vitrage_is_deleted': False,
}),
Vertex('instance',
{
'vitrage_is_placeholder': False,
'vitrage_type': 'nova.instance',
'vitrage_is_deleted': False,
}),
Vertex('host',
{
'vitrage_is_placeholder': False,
'vitrage_type': 'nova.host',
'vitrage_is_deleted': False,
}),
],
edges=[
Edge('host_ssh_alarm', 'host', 'on',
{
'vitrage_is_deleted': True,
'negative_condition': True
}),
Edge('host', 'instance', 'contains',
{
'vitrage_is_deleted': True,
'negative_condition': True
})
]
),
],
TemplateLoaderV3Test.expected_entities,
TemplateLoaderV3Test.expected_relationships)
self._assert_scenario_equal(
expected_scenario,
observed_scenarios[5])
def setUpClass(cls):
cls.target_vertex = Vertex('RESOURCE:nova.host:test_target')
cls.source_vertex = Vertex('RESOURCE:nova.host:test_source')
targets = {
TField.TARGET: cls.target_vertex,
TField.SOURCE: cls.source_vertex
}
cls.action_spec = ActionSpecs(ActionType.ADD_CAUSAL_RELATIONSHIP,
targets, {})
def setUpClass(cls):
super(AddCausalRelationshipTest, cls).setUpClass()
cls.target_vertex = Vertex('RESOURCE:nova.host:test_target')
cls.source_vertex = Vertex('RESOURCE:nova.host:test_source')
targets = {
TField.TARGET: cls.target_vertex,
TField.SOURCE: cls.source_vertex
}
cls.action_spec = ActionSpecs(0, ActionType.ADD_CAUSAL_RELATIONSHIP,
targets, {})
def test_scenario_2(self):
observed_scenarios = self._load_scenarios('valid_actions.yaml')
expected_scenario = Scenario(
'valid actions-scenario2', '3', None, [
ActionSpecs(
'valid actions-scenario2-action0', 'raise_alarm',
{'target': 'instance'}, {
'severity': 'WARNING',
'alarm_name': 'instance is down',
'causing_alarm':
'get_attr(host_ssh_alarm, vitrage_id)',
}),
ActionSpecs('valid actions-scenario2-action1', 'set_state',
{'target': 'instance'}, {'state': 'SUBOPTIMAL'}),
], [
NXGraph(vertices=[
Vertex(
'host_ssh_alarm', {
'rawtext': 'host ssh is down',
'vitrage_is_placeholder': False,
'vitrage_type': 'zabbix',
'vitrage_is_deleted': False,
}),
Vertex(
'instance', {
'vitrage_is_placeholder': False,
'vitrage_type': 'nova.instance',
'vitrage_is_deleted': False,
}),
Vertex(
'host', {
'vitrage_is_placeholder': False,
'vitrage_type': 'nova.host',
'vitrage_is_deleted': False,
}),
],
edges=[
Edge(
'host_ssh_alarm', 'host', 'on', {
'vitrage_is_deleted': False,
'negative_condition': False
}),
Edge(
'host', 'instance', 'contains', {
'vitrage_is_deleted': False,
'negative_condition': False
})
])
], TemplateLoaderV3Test.expected_entities,
TemplateLoaderV3Test.expected_relationships)
self._assert_scenario_equal(expected_scenario, observed_scenarios[2])
def _build_equivalent_relationship(relationship, template_id, entity_props):
source = relationship.source
target = relationship.target
if relationship.edge.source_id == template_id:
source = Vertex(vertex_id=source.vertex_id,
properties={k: v
for k, v in entity_props})
elif relationship.edge.target_id == template_id:
target = Vertex(vertex_id=target.vertex_id,
properties={k: v
for k, v in entity_props})
return EdgeDescription(source=source,
target=target,
edge=relationship.edge)
def build_equivalent_scenario(cls, scenario, template_id,
entity_props):
entities = scenario.entities.copy()
entities[template_id] = Vertex(
vertex_id=entities[template_id].vertex_id,
properties={k: v
for k, v in entity_props})
relationships = {
rel_id:
cls.build_equivalent_relationship(rel, template_id,
entity_props)
for rel_id, rel in scenario.relationships.items()
}
def extract_var(symbol_name):
if symbol_name in entities:
return entities[symbol_name], ENTITY
elif symbol_name in relationships:
return relationships[symbol_name], RELATIONSHIP
else:
raise VitrageError(
'invalid symbol name: {}'.format(symbol_name))
subgraphs = TemplateData.SubGraph.from_condition(
scenario.condition, extract_var)
return Scenario(id=scenario.id + '_equivalence',
condition=scenario.condition,
actions=scenario.actions,
subgraphs=subgraphs,
entities=entities,
relationships=relationships)
def _file_to_vertex(self, filename, index=0):
props = self._load_resource_file(filename, 'vertices')
if props.get(VProps.ID):
props[VProps.ID] = self.generate_mock_uuid()
props[VProps.NAME] = "%s-%s" % (props[VProps.VITRAGE_TYPE], index)
props[VProps.VITRAGE_ID] = self.generate_mock_uuid()
return Vertex(props[VProps.VITRAGE_ID], props)
def _create_vertex(self, event):
event_type = event[EVALUATOR_EVENT_TYPE]
update_timestamp = transformer_base.convert_timestamp_format(
'%Y-%m-%d %H:%M:%S.%f', event[VProps.UPDATE_TIMESTAMP])
if event_type == UPDATE_VERTEX:
properties = {
VProps.VITRAGE_STATE: event[VProps.VITRAGE_STATE],
VProps.UPDATE_TIMESTAMP: update_timestamp,
VProps.SAMPLE_TIMESTAMP: event[VProps.SAMPLE_TIMESTAMP],
VProps.IS_PLACEHOLDER: False
}
return Vertex(event[VProps.VITRAGE_ID], properties)
if event_type in [ADD_VERTEX, REMOVE_VERTEX]:
metadata = {
VProps.NAME: event[TFields.ALARM_NAME],
VProps.SEVERITY: event[TFields.SEVERITY],
VProps.STATE: event[VProps.STATE]
}
return graph_utils.create_vertex(
self._create_entity_key(event),
entity_category=EntityCategory.ALARM,
entity_type=VITRAGE_TYPE,
sample_timestamp=event[VProps.SAMPLE_TIMESTAMP],
update_timestamp=update_timestamp,
metadata=metadata)
return None
def test_scenario_4(self):
observed_scenarios = self._load_scenarios('valid_actions.yaml')
expected_scenario = Scenario(
'valid actions-scenario4',
'3',
None,
[
ActionSpecs(
'valid actions-scenario4-action0',
'mark_down',
{'target': 'host'},
{}),
],
[
NXGraph(
vertices=[
Vertex('host',
{
'vitrage_is_placeholder': False,
'vitrage_type': 'nova.host',
'vitrage_is_deleted': False,
}),
]),
],
TemplateLoaderV3Test.expected_entities,
TemplateLoaderV3Test.expected_relationships)
self._assert_scenario_equal(
expected_scenario,
observed_scenarios[4])
def _create_neighbors(self, event):
event_type = event[EVALUATOR_EVENT_TYPE]
timestamp = transformer_base.convert_timestamp_format(
'%Y-%m-%d %H:%M:%S.%f', event[VProps.UPDATE_TIMESTAMP])
if event_type in [ADD_EDGE, REMOVE_EDGE]:
relation_edge = graph_utils.create_edge(
source_id=event[TFields.SOURCE],
target_id=event[TFields.TARGET],
relationship_type=event[EProps.RELATIONSHIP_TYPE],
update_timestamp=timestamp)
return [Neighbor(None, relation_edge)]
if event_type == ADD_VERTEX:
relation_edge = graph_utils.create_edge(
source_id=self._create_entity_key(event),
target_id=event[TFields.TARGET],
relationship_type=EdgeLabels.ON,
update_timestamp=timestamp)
neighbor_props = {
VProps.IS_PLACEHOLDER: True,
VProps.UPDATE_TIMESTAMP: timestamp,
VProps.SAMPLE_TIMESTAMP: event[VProps.SAMPLE_TIMESTAMP]
}
neighbor = Vertex(event[TFields.TARGET], neighbor_props)
return [Neighbor(neighbor, relation_edge)]
return []
def setUpClass(cls):
cls.target_vertex = Vertex('RESOURCE:nova.host:test1')
cls.targets = {TFields.TARGET: cls.target_vertex}
cls.props = {TFields.ALARM_NAME: 'VM_CPU_SUBOPTIMAL_PERFORMANCE'}
cls.action_spec = ActionSpecs(ActionType.SET_STATE, cls.targets,
cls.props)
def _file_to_vertex(self, relative_path, index=0):
full_path = RESOURCES_PATH + "/vertices/"
props = utils.load_specs(relative_path, full_path)
if props.get(VProps.ID):
props[VProps.ID] = uuidutils.generate_uuid()
props[VProps.NAME] = "%s-%s" % (props[VProps.VITRAGE_TYPE], str(index))
props[VProps.VITRAGE_ID] = uuidutils.generate_uuid()
return Vertex(props[VProps.VITRAGE_ID], props)
def setUpClass(cls):
cls.target_vertex = Vertex('RESOURCE:nova.host:test1')
targets = {TFields.TARGET: cls.target_vertex}
cls.props = {TFields.STATE: 'SUBOPTIMAL'}
cls.action_spec = ActionSpecs(ActionType.SET_STATE, targets, cls.props)
def setUpClass(cls):
super(SetStateRecipeTest, cls).setUpClass()
cls.target_vertex = Vertex('RESOURCE:nova.host:test1')
targets = {TFields.TARGET: cls.target_vertex}
cls.props = {TFields.STATE: OperationalResourceState.SUBOPTIMAL}
cls.action_spec = ActionSpecs(0, ActionType.SET_STATE, targets,
cls.props)
def setUpClass(cls):
super(RaiseAlarmRecipeTest, cls).setUpClass()
cls.target_props = {VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE}
cls.target_vertex = Vertex('RESOURCE:nova.host:test1',
cls.target_props)
cls.targets = {TFields.TARGET: cls.target_vertex}
cls.props = {TFields.ALARM_NAME: 'VM_CPU_SUBOPTIMAL_PERFORMANCE'}
cls.action_spec = ActionSpecs(
0, ActionType.SET_STATE, cls.targets, cls.props)
def _build_entities(self, entities_defs):
entities = {}
for entity_def in entities_defs:
entity_dict = entity_def[TFields.ENTITY]
template_id = entity_dict[TFields.TEMPLATE_ID]
properties = PropsConverter.convert_props_with_dictionary(
self._extract_properties(entity_dict))
entities[template_id] = Vertex(template_id, properties)
return entities
def topology_to_graph(topology):
graph = NXGraph()
nodes = topology['nodes']
for n in nodes:
graph.add_vertex(Vertex(n['vitrage_id'], n))
edges = topology['links']
for i in range(len(edges)):
s_id = nodes[edges[i]['source']]['vitrage_id']
t_id = nodes[edges[i]['target']]['vitrage_id']
graph.add_edge(Edge(s_id, t_id, edges[i]['relationship_type']))
return graph
def setUpClass(cls):
cls.resource_props = {
VProps.IS_DELETED: common.false_,
VProps.IS_PLACEHOLDER: common.false_
}
cls.props = {
VProps.IS_DELETED: common.false_,
VProps.NAME: common.name_,
VProps.RESOURCE: cls.resource_props,
VProps.CATEGORY: common.category_,
VProps.OPERATIONAL_SEVERITY: common.critical_
}
cls.alarm_vertex = Vertex('RESOURCE:nova.instance:test1', cls.props)
def _create_graph_from_graph_dictionary(api_graph):
graph = NXGraph()
nodes = api_graph['nodes']
for i in xrange(len(nodes)):
graph.add_vertex(Vertex(str(i), nodes[i]))
edges = api_graph['links']
for i in xrange(len(edges)):
graph.add_edge(
Edge(str(edges[i]['source']), str(edges[i]['target']),
edges[i]['relationship_type']))
return graph
def setUpClass(cls):
cls.resource_props = {
VProps.VITRAGE_IS_DELETED: common.false_,
VProps.VITRAGE_IS_PLACEHOLDER: common.false_
}
cls.props = {
VProps.VITRAGE_IS_DELETED: common.false_,
VProps.NAME: common.name_,
VProps.RESOURCE: cls.resource_props,
VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
VProps.VITRAGE_OPERATIONAL_SEVERITY:
OperationalAlarmSeverity.CRITICAL
}
cls.alarm_vertex = Vertex('RESOURCE:nova.instance:test1', cls.props)
def _create_graph_from_graph_dictionary(self, api_graph):
self.assertIsNotNone(api_graph)
graph = NXGraph()
nodes = api_graph['nodes']
for i in range(len(nodes)):
graph.add_vertex(Vertex(str(i), nodes[i]))
edges = api_graph['links']
for i in range(len(edges)):
graph.add_edge(Edge(str(edges[i]['source']),
str(edges[i]['target']),
edges[i][EdgeProperties.RELATIONSHIP_TYPE]))
return graph
def test_basic_regex_with_no_match(self):
event_properties = {
"time": 121354,
"vitrage_type": "zabbix",
"vitrage_category": "ALARM",
"rawtext": "No Match",
"host": "some_host_kukoo"
}
event_vertex = Vertex(vertex_id="test_vertex",
properties=event_properties)
relevant_scenarios = \
self.scenario_repository.get_scenarios_by_vertex(
event_vertex)
self.assertThat(relevant_scenarios, IsEmpty())
def test_regex_with_exact_match(self):
event_properties = {
"time": 121354,
"vitrage_type": "zabbix",
"vitrage_category": "ALARM",
"rawtext": "Public interface host43 down",
"host": "some_host_kukoo"
}
event_vertex = Vertex(vertex_id="test_vertex",
properties=event_properties)
relevant_scenarios = \
self.scenario_repository.get_scenarios_by_vertex(
event_vertex)
self.assertThat(relevant_scenarios, matchers.HasLength(1))
relevant_scenario = relevant_scenarios[0]
self.assertEqual("exact_match", relevant_scenario[0].vertex_id)
def test_basic_regex(self):
event_properties = {
"time": 121354,
"vitrage_type": "zabbix",
"vitrage_category": "ALARM",
"rawtext": "Interface virtual-0 down on {HOST.NAME}",
"host": "some_host_kukoo"
}
event_vertex = Vertex(vertex_id="test_vertex",
properties=event_properties)
relevant_scenarios = \
self.scenario_repository.get_scenarios_by_vertex(
event_vertex)
self.assertThat(relevant_scenarios, matchers.HasLength(1))
relevant_scenario = relevant_scenarios[0]
self.assertEqual("zabbix_alarm_pass", relevant_scenario[0].vertex_id)
def _create_vertex(self, event):
event_type = event[EVALUATOR_EVENT_TYPE]
update_timestamp = transformer_base.convert_timestamp_format(
'%Y-%m-%d %H:%M:%S.%f', event[VProps.UPDATE_TIMESTAMP])
if event_type == UPDATE_VERTEX:
properties = {
VProps.UPDATE_TIMESTAMP: update_timestamp,
VProps.VITRAGE_IS_PLACEHOLDER: False,
VProps.RESOURCE_ID: event.get(TFields.TARGET)
}
if VProps.IS_REAL_VITRAGE_ID in event:
properties[VProps.IS_REAL_VITRAGE_ID] = \
event.get(VProps.IS_REAL_VITRAGE_ID)
if VProps.VITRAGE_STATE in event:
properties[VProps.VITRAGE_STATE] = \
event.get(VProps.VITRAGE_STATE)
if VProps.IS_MARKED_DOWN in event:
properties[VProps.IS_MARKED_DOWN] = \
event.get(VProps.IS_MARKED_DOWN)
return Vertex(event[VProps.VITRAGE_ID], properties)
if event_type in [ADD_VERTEX, REMOVE_VERTEX]:
metadata = {
VProps.NAME: event[TFields.ALARM_NAME],
VProps.SEVERITY: event[TFields.SEVERITY],
VProps.STATE: event[VProps.STATE],
VProps.RESOURCE_ID: event.get(TFields.TARGET)
}
return graph_utils.create_vertex(
self._create_entity_key(event),
vitrage_category=EntityCategory.ALARM,
vitrage_type=VITRAGE_DATASOURCE,
vitrage_sample_timestamp=event[
VProps.VITRAGE_SAMPLE_TIMESTAMP],
update_timestamp=update_timestamp,
metadata=metadata)
return None
def do_replay_events(db, graph, event_id):
events = db.events.get_replay_events(event_id=event_id)
for event in events:
if event.is_vertex:
v_id = event.payload['vertex_id']
del event.payload['vertex_id']
v = Vertex(v_id, event.payload)
graph.update_vertex(v)
else:
source_id = event.payload['source_id']
target_id = event.payload['target_id']
label = event.payload['label']
del event.payload['source_id']
del event.payload['target_id']
del event.payload['label']
e = Edge(source_id, target_id, label, event.payload)
graph.update_edge(e)
return len(events)
def _build_entities_from_def_templates(self, includes, def_templates,
entities):
for def_template_dict in includes:
name = def_template_dict[TFields.NAME]
def_template = evaluator_utils.find_def_template(
name, def_templates)
defs = def_template[TFields.DEFINITIONS]
entities_defs = defs[TFields.ENTITIES]
for entity_def in entities_defs:
entity_dict = entity_def[TFields.ENTITY]
template_id = entity_dict[TFields.TEMPLATE_ID]
if template_id not in entities:
properties = self._convert_properties_with_dictionary(
self._extract_properties(entity_dict))
entities[template_id] = Vertex(template_id, properties)
