def __init__(self, conf, e_graph=None):
super(Processor, self).__init__()
self.conf = conf
self.transformer_manager = TransformerManager(self.conf)
self.info_mapper = DatasourceInfoMapper(self.conf)
self._initialize_events_actions()
self.entity_graph = e_graph
def test_vitrage_aggregated_value(self):
# setup
info_mapper = DatasourceInfoMapper(self.conf)
metadata1 = {VProps.VITRAGE_STATE: 'SUSPENDED'}
new_vertex1 = create_vertex('12345',
vitrage_category=EntityCategory.RESOURCE,
vitrage_type=NOVA_INSTANCE_DATASOURCE,
entity_state='ACTIVE',
metadata=metadata1)
metadata2 = {VProps.VITRAGE_STATE: 'ACTIVE'}
new_vertex2 = create_vertex('23456',
vitrage_category=EntityCategory.RESOURCE,
vitrage_type=NOVA_INSTANCE_DATASOURCE,
entity_state='SUSPENDED',
metadata=metadata2)
# action
info_mapper.vitrage_aggregate_values(new_vertex1, None)
info_mapper.vitrage_aggregate_values(new_vertex2, None)
# test assertions
self.assertEqual('SUSPENDED',
new_vertex1[VProps.VITRAGE_AGGREGATED_STATE])
self.assertEqual(OperationalResourceState.SUBOPTIMAL,
new_vertex1[VProps.VITRAGE_OPERATIONAL_STATE])
self.assertEqual('SUSPENDED',
new_vertex2[VProps.VITRAGE_AGGREGATED_STATE])
self.assertEqual(OperationalResourceState.SUBOPTIMAL,
new_vertex2[VProps.VITRAGE_OPERATIONAL_STATE])
def __init__(self, conf, initialization_status, e_graph):
super(Processor, self).__init__()
self.conf = conf
self.transformer_manager = TransformerManager(self.conf)
self.state_manager = DatasourceInfoMapper(self.conf)
self._initialize_events_actions()
self.initialization_status = initialization_status
self.entity_graph = e_graph
self._notifier = GraphNotifier(conf)
def test_load_datasource_value_without_errors(self):
# action
info_mapper = DatasourceInfoMapper(self.conf)
# test assertions
# Total datasources plus the evaluator which is not definable
total_datasources = len(self.conf.datasources.types) + 1
self.assertThat(info_mapper.datasources_value_confs,
matchers.HasLength(total_datasources))
def __init__(self, conf, initialization_status, e_graph=None, uuid=False):
super(Processor, self).__init__()
self.conf = conf
self.transformer_manager = TransformerManager(self.conf)
self.state_manager = DatasourceInfoMapper(self.conf)
self._initialize_events_actions()
self.initialization_status = initialization_status
self.entity_graph = e_graph if e_graph is not None\
else NXGraph("Entity Graph", uuid=uuid)
self._notifier = GraphNotifier(conf)
def test_load_datasource_state_without_errors(self):
# action
state_manager = DatasourceInfoMapper(self.conf)
# test assertions
# Total datasources plus the evaluator which is not definable
total_datasources = len(self.conf.datasources.types) + 1
self.assertEqual(total_datasources,
len(state_manager.datasources_state_confs))
def __init__(self, conf, initialization_status, e_graph=None):
super(Processor, self).__init__()
self.conf = conf
self.transformer_manager = TransformerManager(self.conf)
self.state_manager = DatasourceInfoMapper(self.conf)
self._initialize_events_actions()
self.initialization_status = initialization_status
self.entity_graph = entity_graph.EntityGraph("Entity Graph") if \
e_graph is None else e_graph
self._notifier = DeducedAlarmNotifier(conf)
def test_value_priority(self):
# setup
info_mapper = DatasourceInfoMapper(self.conf)
# action
value_priority = \
info_mapper.value_priority(NOVA_INSTANCE_DATASOURCE, 'ACTIVE')
# test assertions
self.assertEqual(10, value_priority)
def test_operational_state_exists(self):
# setup
state_manager = DatasourceInfoMapper(self.conf)
# action
operational_state = \
state_manager.operational_state(NOVA_INSTANCE_DATASOURCE,
'BUILDING')
# test assertions
self.assertEqual(OperationalResourceState.TRANSIENT, operational_state)
def test_operational_state_not_exists(self):
# setup
state_manager = DatasourceInfoMapper(self.conf)
# action
operational_state = \
state_manager.operational_state(NOVA_INSTANCE_DATASOURCE,
'NON EXISTING STATE')
# test assertions
self.assertEqual(OperationalResourceState.NA, operational_state)
def test_state_priority_datasource_not_exists(self):
# setup
state_manager = DatasourceInfoMapper(self.conf)
# action
state_priority = \
state_manager.state_priority('NON EXISTING DATASOURCE',
'ACTIVE')
# test assertions
self.assertEqual(10, state_priority)
def test_state_priority_not_exists(self):
# setup
state_manager = DatasourceInfoMapper(self.conf)
# action
state_priority = \
state_manager.state_priority(NOVA_INSTANCE_DATASOURCE,
'NON EXISTING STATE')
# test assertions
self.assertEqual(0, state_priority)
def test_state_priority(self):
# setup
state_manager = DatasourceInfoMapper(self.conf)
# action
state_priority = \
state_manager.state_priority(NOVA_INSTANCE_DATASOURCE,
'ACTIVE')
# test assertions
self.assertEqual(10, state_priority)
def test_value_priority_not_exists(self):
# setup
info_mapper = DatasourceInfoMapper(self.conf)
# action
value_priority = \
info_mapper.value_priority(NOVA_INSTANCE_DATASOURCE,
'NON EXISTING STATE')
# test assertions
self.assertEqual(0, value_priority)
def test_value_priority_datasource_not_exists(self):
# setup
info_mapper = DatasourceInfoMapper(self.conf)
# action
value_priority = \
info_mapper.value_priority('NON EXISTING DATASOURCE',
'ACTIVE')
# test assertions
self.assertEqual(10, value_priority)
def test_operational_state_datasource_not_exists_and_state_exist(self):
# setup
state_manager = DatasourceInfoMapper(self.conf)
# action
operational_state = \
state_manager.operational_state('NON EXISTING DATASOURCE',
'AVAILABLE')
# test assertions
self.assertEqual(OperationalResourceState.OK,
operational_state)
def test_vitrage_operational_state_DS_not_exists_and_state_not_exist(self):
# setup
state_manager = DatasourceInfoMapper(self.conf)
# action
vitrage_operational_state = \
state_manager.vitrage_operational_state('NON EXISTING DATASOURCE',
'BUILDING')
# test assertions
self.assertEqual(OperationalResourceState.NA,
vitrage_operational_state)
def test_operational_state_datasource_not_exists(self):
# setup
state_manager = DatasourceInfoMapper(self.conf)
# action
operational_state = \
state_manager.operational_state('NON EXISTING DATASOURCE',
'BUILDING')
# test assertions
self.assertEqual(DatasourceInfoMapper.UNDEFINED_DATASOURCE,
operational_state)
def __init__(self, conf, db_connection):
info_mapper = DatasourceInfoMapper(conf)
self._db = db_connection
alarms_score = info_mapper.get_datasource_priorities('vitrage')
all_scores = info_mapper.get_datasource_priorities()
self._action_tools = {
ActionType.SET_STATE: pt.SetStateTools(all_scores),
ActionType.RAISE_ALARM: pt.RaiseAlarmTools(alarms_score),
ActionType.ADD_CAUSAL_RELATIONSHIP: pt.BaselineTools,
ActionType.MARK_DOWN: pt.BaselineTools,
ActionType.EXECUTE_MISTRAL: pt.BaselineTools
}
def test_vitrage_operational_value_DS_not_exists_and_value_exist(self):
# setup
info_mapper = DatasourceInfoMapper(self.conf)
# action
vitrage_operational_value = \
info_mapper.vitrage_operational_value('NON EXISTING DATASOURCE',
'AVAILABLE')
# test assertions
self.assertEqual(OperationalResourceState.OK,
vitrage_operational_value)
def test_vitrage_operational_value_not_exists(self):
# setup
info_mapper = DatasourceInfoMapper(self.conf)
# action
vitrage_operational_value = \
info_mapper.vitrage_operational_value(NOVA_INSTANCE_DATASOURCE,
'NON EXISTING STATE')
# test assertions
self.assertEqual(OperationalResourceState.NA,
vitrage_operational_value)
def test_vitrage_operational_value_exists(self):
# setup
info_mapper = DatasourceInfoMapper(self.conf)
# action
vitrage_operational_value = \
info_mapper.vitrage_operational_value(NOVA_INSTANCE_DATASOURCE,
'BUILDING')
# test assertions
self.assertEqual(OperationalResourceState.TRANSIENT,
vitrage_operational_value)
def _init_action_tools(cls, conf):
if cls.action_tools:
return
info_mapper = DatasourceInfoMapper(conf)
alarms_score = info_mapper.get_datasource_priorities('vitrage')
all_scores = info_mapper.get_datasource_priorities()
cls.action_tools = {
ActionType.SET_STATE: pt.SetStateTools(all_scores),
ActionType.RAISE_ALARM: pt.RaiseAlarmTools(alarms_score),
ActionType.ADD_CAUSAL_RELATIONSHIP: pt.BaselineTools,
ActionType.MARK_DOWN: pt.BaselineTools,
ActionType.EXECUTE_MISTRAL: pt.BaselineTools
}
def __init__(self,
conf,
entity_graph,
scenario_repo,
event_queue,
enabled=False):
self.conf = conf
self._scenario_repo = scenario_repo
self._entity_graph = entity_graph
self._action_executor = ActionExecutor(event_queue)
self._entity_graph.subscribe(self.process_event)
self._action_tracker = ActionTracker(DatasourceInfoMapper(self.conf))
self.enabled = enabled
self.connected_component_cache = defaultdict(dict)
def __init__(self,
conf,
entity_graph,
scenario_repo,
event_queue,
enabled=False):
self.conf = conf
self._scenario_repo = scenario_repo
self._entity_graph = entity_graph
self._graph_algs = create_algorithm(entity_graph)
self._action_executor = ActionExecutor(event_queue)
self._entity_graph.subscribe(self.process_event)
self._action_tracker = ActionTracker(DatasourceInfoMapper(self.conf))
self.enabled = enabled
def test_vitrage_aggregated_value_datasource_not_exists(self):
# setup
info_mapper = DatasourceInfoMapper(self.conf)
metadata = {VProps.VITRAGE_STATE: 'SUSPENDED'}
new_vertex = create_vertex('12345',
vitrage_category=EntityCategory.RESOURCE,
vitrage_type='NON EXISTING DATASOURCE',
entity_state='ACTIVE',
metadata=metadata)
# action
info_mapper.vitrage_aggregate_values(new_vertex, None)
# test assertions
self.assertEqual('ACTIVE', new_vertex[VProps.VITRAGE_AGGREGATED_STATE])
self.assertEqual(OperationalResourceState.OK,
new_vertex[VProps.VITRAGE_OPERATIONAL_STATE])
def test_load_datasources_value_with_errors(self):
# setup
self.cfg_fixture.config(
group='entity_graph',
datasources_values_dir=utils.get_resources_dir() +
'/datasources_values/erroneous_values')
self._load_datasources()
# action
info_mapper = DatasourceInfoMapper()
# test assertions
missing_values = 1
erroneous_values = 1
num_valid_datasources = len(info_mapper.datasources_value_confs) + \
missing_values + erroneous_values
self.assertThat(self.conf.datasources.types,
matchers.HasLength(num_valid_datasources))
def test_aggregated_state_datasource_not_exists(self):
# setup
state_manager = DatasourceInfoMapper(self.conf)
metadata = {VProps.VITRAGE_STATE: 'SUSPENDED'}
new_vertex = create_vertex('12345',
entity_state='ACTIVE',
entity_category=EntityCategory.RESOURCE,
entity_type='NON EXISTING DATASOURCE',
metadata=metadata)
# action
state_manager.aggregated_state(new_vertex, None)
# test assertions
self.assertEqual(DatasourceInfoMapper.UNDEFINED_DATASOURCE,
new_vertex[VProps.AGGREGATED_STATE])
self.assertEqual(DatasourceInfoMapper.UNDEFINED_DATASOURCE,
new_vertex[VProps.OPERATIONAL_STATE])
def test_vitrage_aggregated_state_functionalities(self):
# setup
state_manager = DatasourceInfoMapper(self.conf)
new_vertex1 = create_vertex('12345',
vitrage_category=EntityCategory.RESOURCE,
vitrage_type=NOVA_INSTANCE_DATASOURCE,
entity_state='ACTIVE')
metadata2 = {VProps.VITRAGE_STATE: OperationalResourceState.SUBOPTIMAL}
new_vertex2 = create_vertex('23456',
vitrage_category=EntityCategory.RESOURCE,
vitrage_type=NOVA_INSTANCE_DATASOURCE,
metadata=metadata2)
metadata3 = {VProps.VITRAGE_STATE: OperationalResourceState.SUBOPTIMAL}
new_vertex3 = create_vertex('34567',
vitrage_category=EntityCategory.RESOURCE,
vitrage_type=NOVA_INSTANCE_DATASOURCE,
entity_state='ACTIVE')
graph_vertex3 = create_vertex('34567',
vitrage_category=EntityCategory.RESOURCE,
vitrage_type=NOVA_INSTANCE_DATASOURCE,
entity_state='SUSPENDED',
metadata=metadata3)
# action
state_manager.vitrage_aggregated_state(new_vertex1, None)
state_manager.vitrage_aggregated_state(new_vertex2, None)
state_manager.vitrage_aggregated_state(new_vertex3, graph_vertex3)
# test assertions
self.assertEqual('ACTIVE',
new_vertex1[VProps.VITRAGE_AGGREGATED_STATE])
self.assertEqual(OperationalResourceState.OK,
new_vertex1[VProps.VITRAGE_OPERATIONAL_STATE])
self.assertEqual(OperationalResourceState.SUBOPTIMAL,
new_vertex2[VProps.VITRAGE_AGGREGATED_STATE])
self.assertEqual(OperationalResourceState.SUBOPTIMAL,
new_vertex2[VProps.VITRAGE_OPERATIONAL_STATE])
self.assertEqual(OperationalResourceState.SUBOPTIMAL,
new_vertex3[VProps.VITRAGE_AGGREGATED_STATE])
self.assertEqual(OperationalResourceState.SUBOPTIMAL,
new_vertex3[VProps.VITRAGE_OPERATIONAL_STATE])
def test_load_datasources_state_with_errors(self):
# setup
entity_graph_opts = [
cfg.StrOpt('datasources_values_dir',
default=utils.get_resources_dir() +
'/datasources_values/erroneous_values'),
]
conf = cfg.ConfigOpts()
conf.register_opts(entity_graph_opts, group='entity_graph')
conf.register_opts(self.DATASOURCES_OPTS, group='datasources')
self._load_datasources(conf)
# action
state_manager = DatasourceInfoMapper(conf)
# test assertions
missing_states = 1
erroneous_values = 1
num_valid_datasources = len(state_manager.datasources_state_confs) + \
missing_states + erroneous_values
self.assertEqual(num_valid_datasources, len(conf.datasources.types))
