def test_process_event(self):
# check create instance event
processor = proc.Processor(self.conf, InitializationStatus())
event = self._create_event(spec_type=self.INSTANCE_SPEC,
sync_mode=SyncMode.INIT_SNAPSHOT)
processor.process_event(event)
self._check_graph(processor, self.NUM_VERTICES_AFTER_CREATION,
self.NUM_EDGES_AFTER_CREATION)
# check update instance even
event[DSProps.SYNC_MODE] = SyncMode.UPDATE
event[DSProps.EVENT_TYPE] = 'compute.instance.volume.attach'
event['hostname'] = 'new_host'
event['instance_id'] = event['id']
event['state'] = event['status']
event['host'] = event['OS-EXT-SRV-ATTR:host']
processor.process_event(event)
self._check_graph(processor, self.NUM_VERTICES_AFTER_CREATION,
self.NUM_EDGES_AFTER_CREATION)
# check delete instance event
event[DSProps.SYNC_MODE] = SyncMode.UPDATE
event[DSProps.EVENT_TYPE] = 'compute.instance.delete.end'
processor.process_event(event)
self._check_graph(processor, self.NUM_VERTICES_AFTER_DELETION,
self.NUM_EDGES_AFTER_DELETION)
def main():
"""Starts all the Entity graph services
1. Starts the Entity graph service
2. Starts the api_handler service
3. Starts the datasource service
4. Starts the Consistency service
"""
conf = service.prepare_service()
init_status = InitializationStatus()
mp_queue, evaluator_queue, evaluator, e_graph = init(conf)
launcher = os_service.ServiceLauncher(conf)
datasources = datasource_launcher.Launcher(
conf, datasource_launcher.create_send_to_queue_callback(mp_queue))
launcher.launch_service(
entity_graph_svc.VitrageGraphService(conf, mp_queue, evaluator_queue,
evaluator, e_graph, init_status))
launcher.launch_service(
api_handler_svc.VitrageApiHandlerService(conf, e_graph,
evaluator.scenario_repo))
datasources.launch()
launcher.launch_service(
consistency_svc.VitrageGraphConsistencyService(conf, evaluator_queue,
evaluator, e_graph,
init_status))
launcher.wait()
def create_processor_with_graph(self):
conf = cfg.ConfigOpts()
conf.register_opts(self.PROCESSOR_OPTS, group='entity_graph')
events = self._create_mock_events()
processor = proc.Processor(conf, InitializationStatus())
for event in events:
processor.process_event(event)
return processor
def _create_processor_with_graph(self, conf, processor=None):
events = self._create_mock_events()
if not processor:
processor = proc.Processor(conf, InitializationStatus())
for event in events:
processor.process_event(event)
return processor
def init():
conf = service.prepare_service()
event_queue = multiprocessing.Queue()
e_graph = entity_graph.EntityGraph(
'Entity Graph', '%s:%s' % (EntityCategory.RESOURCE, OPENSTACK_CLUSTER))
scenario_repo = ScenarioRepository(conf)
evaluator = ScenarioEvaluator(conf, e_graph, scenario_repo, event_queue)
initialization_status = InitializationStatus()
return conf, event_queue, evaluator, e_graph, initialization_status
def test_state_on_update(self):
# setup
processor = proc.Processor(self.conf, InitializationStatus())
event = self._create_event(spec_type='INSTANCE_SPEC',
sync_mode=SyncMode.INIT_SNAPSHOT)
# action
processor.process_event(event)
# test assertions
instance_transformer = InstanceTransformer({})
vitrage_id = instance_transformer._create_entity_key(event)
vertex = processor.entity_graph.get_vertex(vitrage_id)
self.assertEqual(NormalizedResourceState.RUNNING,
vertex[VProps.AGGREGATED_STATE])
def test_state_on_update(self):
# setup
processor = proc.Processor(self.conf,
InitializationStatus(),
uuid=True)
event = self._create_event(spec_type='INSTANCE_SPEC',
datasource_action=DSAction.INIT_SNAPSHOT)
# action
processor.process_event(event)
# test assertions
entity = processor.transformer_manager.transform(event)
processor._find_and_fix_graph_vertex(entity.vertex, [])
vertex = processor.entity_graph.get_vertex(entity.vertex.vertex_id)
self.assertEqual('ACTIVE', vertex[VProps.AGGREGATED_STATE])
self.assertEqual(OperationalResourceState.OK,
vertex[VProps.OPERATIONAL_STATE])
def setUpClass(cls):
super(TestConsistencyFunctional, cls).setUpClass()
cls.initialization_status = InitializationStatus()
cls.conf = cfg.ConfigOpts()
cls.conf.register_opts(cls.CONSISTENCY_OPTS, group='consistency')
cls.conf.register_opts(cls.PROCESSOR_OPTS, group='entity_graph')
cls.conf.register_opts(cls.EVALUATOR_OPTS, group='evaluator')
cls.conf.register_opts(cls.DATASOURCES_OPTS, group='datasources')
cls.load_datasources(cls.conf)
cls.processor = Processor(cls.conf, cls.initialization_status)
cls.event_queue = queue.Queue()
scenario_repo = ScenarioRepository(cls.conf)
cls.evaluator = ScenarioEvaluator(cls.conf, cls.processor.entity_graph,
scenario_repo, cls.event_queue)
cls.consistency_enforcer = ConsistencyEnforcer(
cls.conf, cls.event_queue, cls.evaluator,
cls.processor.entity_graph, cls.initialization_status)
def _create_entity(self,
processor=None,
spec_type=None,
sync_mode=None,
event_type=None,
properties=None):
# create instance event with host neighbor
event = self._create_event(spec_type=spec_type,
sync_mode=sync_mode,
event_type=event_type,
properties=properties)
# add instance entity with host
if processor is None:
processor = proc.Processor(self.conf, InitializationStatus())
vertex, neighbors, event_type = processor.transformer_manager\
.transform(event)
processor.create_entity(vertex, neighbors)
return vertex, neighbors, processor
