def test_persist_two_graphs(self):
g1 = GraphGenerator().create_graph()
current_time1 = utcnow()
self.graph_persistor.last_event_timestamp = current_time1
self.graph_persistor.store_graph(g1)
graph_snapshot1 = self.graph_persistor.load_graph(current_time1)
g2 = GraphGenerator(5).create_graph()
current_time2 = utcnow()
self.graph_persistor.last_event_timestamp = current_time2
self.graph_persistor.store_graph(g2)
graph_snapshot2 = self.graph_persistor.load_graph(current_time2)
self.assert_graph_equal(g1, graph_snapshot1)
self.assert_graph_equal(g2, graph_snapshot2)
self.graph_persistor.delete_graph_snapshots(utcnow())
def test_load_last_graph_snapshot_until_timestamp(self):
g1 = GraphGenerator().create_graph()
self.graph_persistor.last_event_timestamp = utcnow()
self.graph_persistor.store_graph(g1)
time.sleep(1)
time_in_between = utcnow()
time.sleep(1)
g2 = GraphGenerator(5).create_graph()
self.graph_persistor.last_event_timestamp = utcnow()
self.graph_persistor.store_graph(g2)
graph_snapshot = self.graph_persistor.load_graph(time_in_between)
self.assert_graph_equal(g1, graph_snapshot)
self.graph_persistor.delete_graph_snapshots(utcnow())
def test_graph_store_and_query_recent_snapshot(self):
g = GraphGenerator().create_graph()
graph_persistor = graph_persistency.GraphPersistency(self._db, g)
graph_persistor.store_graph()
recovered_data = graph_persistor.query_recent_snapshot()
recovered_graph = self.load_snapshot(recovered_data)
self.assert_graph_equal(g, recovered_graph)
def test_persist_graph(self):
g = GraphGenerator().create_graph()
current_time = utcnow()
self.graph_persistor.last_event_timestamp = current_time
self.graph_persistor.store_graph(g)
graph_snapshot = self.graph_persistor.load_graph(current_time)
self.assert_graph_equal(g, graph_snapshot)
self.graph_persistor.delete_graph_snapshots(utcnow())
def __init__(self, conf):
super(StaticDriver, self).__init__()
mock_cfg = conf.mock_graph_datasource
e_graph = GraphGenerator(
networks=mock_cfg.networks,
zones_per_cluster=mock_cfg.zones_per_cluster,
hosts_per_zone=mock_cfg.hosts_per_zone,
zabbix_alarms_per_host=mock_cfg.zabbix_alarms_per_host,
instances_per_host=mock_cfg.instances_per_host,
ports_per_instance=mock_cfg.ports_per_instance,
volumes_per_instance=mock_cfg.volumes_per_instance,
vitrage_alarms_per_instance=mock_cfg.vitrage_alarms_per_instance,
tripleo_controllers=mock_cfg.tripleo_controllers,
zabbix_alarms_per_controller=mock_cfg.zabbix_alarms_per_controller
).create_graph()
definitions = e_graph.json_output_graph(raw=True)
self.mock_entities = self._get_mock_entities(definitions)
def test_event_store_and_replay_events(self):
g = GraphGenerator().create_graph()
vertices = g.get_vertices()
graph_persistor = graph_persistency.GraphPersistency(
self.conf, self._db, g)
self.fail_msg = None
self.event_id = 1
def callback(pre_item, current_item, is_vertex, graph):
try:
graph_persistor.persist_event(pre_item, current_item,
is_vertex, graph, self.event_id)
except Exception as e:
self.fail_msg = 'persist_event failed with exception %s' % e
self.event_id = self.event_id + 1
# Subscribe graph changes to callback, so events are written to db
# after each update_vertex and update_edge callback will be called
g.subscribe(callback)
vertices[0][VertexProperties.VITRAGE_IS_DELETED] = True
g.update_vertex(vertices[0])
vertices[1][VertexProperties.VITRAGE_IS_DELETED] = True
g.update_vertex(vertices[1])
edge = g.get_edges(vertices[0].vertex_id).pop()
edge[EdgeProperties.VITRAGE_IS_DELETED] = True
g.update_edge(edge)
graph_persistor.flush_events()
# Store graph:
graph_persistor.store_graph()
# Create more events:
vertices[2][VertexProperties.VITRAGE_IS_DELETED] = True
g.update_vertex(vertices[2])
vertices[3][VertexProperties.VITRAGE_IS_DELETED] = True
g.update_vertex(vertices[3])
edge = g.get_edges(vertices[2].vertex_id).pop()
edge[EdgeProperties.RELATIONSHIP_TYPE] = 'kuku'
g.update_edge(edge)
graph_persistor.flush_events()
self.assertIsNone(self.fail_msg, 'callback failed')
# Reload snapshot
recovered_data = graph_persistor.query_recent_snapshot()
recovered_graph = self.load_snapshot(recovered_data)
# Replay events:
self.assertEqual(3, recovered_data.event_id, 'graph snapshot event_id')
graph_persistor.replay_events(recovered_graph, recovered_data.event_id)
self.assert_graph_equal(g, recovered_graph)
class MockDriver(StaticDriver):
def __init__(self, conf):
super(StaticDriver, self).__init__()
mock_cfg = conf.mock_graph_datasource
self.e_graph = GraphGenerator(
networks=mock_cfg.networks,
zones_per_cluster=mock_cfg.zones_per_cluster,
hosts_per_zone=mock_cfg.hosts_per_zone,
zabbix_alarms_per_host=mock_cfg.zabbix_alarms_per_host,
instances_per_host=mock_cfg.instances_per_host,
ports_per_instance=mock_cfg.ports_per_instance,
volumes_per_instance=mock_cfg.volumes_per_instance,
vitrage_alarms_per_instance=mock_cfg.vitrage_alarms_per_instance,
tripleo_controllers=mock_cfg.tripleo_controllers,
zabbix_alarms_per_controller=mock_cfg.zabbix_alarms_per_controller
).create_graph()
def get_all(self, datasource_action):
return self.make_pickleable(self._get_mock_entities(), MOCK_DATASOURCE,
datasource_action)
def get_changes(self, datasource_action):
return self.make_pickleable([], MOCK_DATASOURCE, datasource_action)
def _get_mock_entities(self):
definitions = json.loads(self.e_graph.json_output_graph())
for node in definitions['nodes']:
node[StaticFields.STATIC_ID] = str(node[VProps.GRAPH_INDEX])
node[StaticFields.TYPE] = node[VProps.VITRAGE_TYPE]
node[StaticFields.CATEGORY] = node[VProps.VITRAGE_CATEGORY]
self.delete_fields(node)
for link in definitions['links']:
link['source'] = str(link['source'])
link['target'] = str(link['target'])
entities = definitions['nodes']
relationships = definitions['links']
return self._pack(entities, relationships)
@staticmethod
def delete_fields(node):
if VProps.VITRAGE_ID in node:
del node[VProps.VITRAGE_ID]
if VProps.UPDATE_TIMESTAMP in node:
del node[VProps.UPDATE_TIMESTAMP]
if VProps.VITRAGE_CATEGORY in node:
del node[VProps.VITRAGE_CATEGORY]
if VProps.VITRAGE_OPERATIONAL_STATE in node:
del node[VProps.VITRAGE_OPERATIONAL_STATE]
if VProps.VITRAGE_SAMPLE_TIMESTAMP in node:
del node[VProps.VITRAGE_SAMPLE_TIMESTAMP]
if VProps.VITRAGE_AGGREGATED_STATE in node:
del node[VProps.VITRAGE_AGGREGATED_STATE]
if VProps.VITRAGE_IS_PLACEHOLDER in node:
del node[VProps.VITRAGE_IS_PLACEHOLDER]
if VProps.IS_REAL_VITRAGE_ID in node:
del node[VProps.IS_REAL_VITRAGE_ID]
if VProps.VITRAGE_IS_DELETED in node:
del node[VProps.VITRAGE_IS_DELETED]
if VProps.GRAPH_INDEX in node:
del node[VProps.GRAPH_INDEX]
if VProps.VITRAGE_TYPE in node:
del node[VProps.VITRAGE_TYPE]