def _create_entity_key(self, entity_event):
if _is_vitrage_alarm(entity_event):
return entity_event.get(AodhProps.VITRAGE_ID)
sync_type = entity_event[DSProps.SYNC_TYPE]
alarm_id = entity_event[AodhProps.ALARM_ID]
resource_id = entity_event[AodhProps.RESOURCE_ID]
return (tbase.build_key(
self._key_values(sync_type, resource_id, alarm_id)) if resource_id
else tbase.build_key(self._key_values(sync_type, alarm_id)))
def _create_entity_key(self, entity_event):
if _is_vitrage_alarm(entity_event):
return entity_event.get(AodhProps.VITRAGE_ID)
sync_type = entity_event[DSProps.SYNC_TYPE]
alarm_name = entity_event[AodhProps.NAME]
resource_id = entity_event[AodhProps.RESOURCE_ID]
return (tbase.build_key(self._key_values(sync_type,
resource_id,
alarm_name)) if resource_id
else tbase.build_key(self._key_values(sync_type, alarm_name)))
def _create_entity_key(self, entity_event):
network_id = 'network_id' if tbase.is_update_event(entity_event) \
else 'id'
key_fields = self._key_values(
NEUTRON_NETWORK_DATASOURCE,
extract_field_value(entity_event, network_id))
return tbase.build_key(key_fields)
def _create_entity_key(self, event):
instance_id = 'instance_id' if tbase.is_update_event(event) else 'id'
key_fields = self._key_values(NOVA_INSTANCE_DATASOURCE,
extract_field_value(event,
instance_id))
return tbase.build_key(key_fields)
def _create_entity_key(self, entity_event):
entity_type = entity_event[DSProps.ENTITY_TYPE]
alarm_id = entity_event[CProps.ID]
resource_name = entity_event[CProps.RESOURCE_NAME]
return tbase.build_key(
self._key_values(entity_type, resource_name, alarm_id))
def test_create_entity_key(self):
LOG.debug('Test get key from kubernetes transformer')
# Test setup
spec_list = mock_sync.simple_k8s_nodes_generators(nodes_num=1,
snapshot_events=1)
nodes_events = mock_sync.generate_random_events_list(spec_list)
kubernetes_transformer = self.transformers[KUBERNETES_DATASOURCE]
for event in nodes_events:
# Test action
observed_key = kubernetes_transformer._create_entity_key(event)
# Test assertions
observed_key_fields = observed_key.split(
TransformerBase.KEY_SEPARATOR)
self.assertEqual(EntityCategory.RESOURCE, observed_key_fields[0])
self.assertEqual(
KUBERNETES_DATASOURCE,
observed_key_fields[1]
)
key_values = kubernetes_transformer._key_values(
KUBERNETES_DATASOURCE,
cluster_name)
expected_key = tbase.build_key(key_values)
self.assertEqual(expected_key, observed_key)
def _create_entity_key(self, entity_event):
network_id = 'network_id' if tbase.is_update_event(entity_event) \
else 'id'
key_fields = self._key_values(NEUTRON_NETWORK_DATASOURCE,
extract_field_value(entity_event,
network_id))
return tbase.build_key(key_fields)
def _create_entity_key(self, entity_event):
return tbase.build_key((ECategory.ALARM,
entity_event[DSProps.ENTITY_TYPE],
get_label(entity_event,
PAlertLabels.ALERT_NAME),
str(entity_event.get(
PDProps.ENTITY_UNIQUE_PROPS))))
def _create_entity_key(self, event):
instance_id = 'instance_id' if tbase.is_update_event(event) else 'id'
key_fields = self._key_values(NOVA_INSTANCE_DATASOURCE,
extract_field_value(event,
instance_id))
return tbase.build_key(key_fields)
def _create_entity_key(self, entity_event):
if _is_vitrage_alarm(entity_event):
return entity_event.get(AodhProps.VITRAGE_ID)
entity_type = entity_event[DSProps.ENTITY_TYPE]
alarm_id = entity_event[AodhProps.ALARM_ID]
return tbase.build_key(self._key_values(entity_type, alarm_id))
def _create_entity_key(self, entity_event):
event_type = entity_event.get(DSProps.EVENT_TYPE, None)
network_id = extract_field_value(entity_event,
*self.UPDATE_ID_PROPERTY[event_type])
key_fields = self._key_values(NEUTRON_NETWORK_DATASOURCE, network_id)
return tbase.build_key(key_fields)
def _create_entity_key(self, entity_event):
if _is_vitrage_alarm(entity_event):
return entity_event.get(AodhProps.VITRAGE_ID)
entity_type = entity_event[DSProps.ENTITY_TYPE]
alarm_id = entity_event[AodhProps.ALARM_ID]
return tbase.build_key((EntityCategory.ALARM, entity_type, alarm_id))
def _create_entity_key(self, entity_event):
"""the unique key of this entity"""
entity_type = entity_event[DSProps.ENTITY_TYPE]
alarm_id = entity_event[KProps.ID]
resource_name = entity_event[KProps.RESOURCE_NAME]
return tbase.build_key(
(EntityCategory.ALARM, entity_type, resource_name, alarm_id))
def _create_entity_key(self, entity_event):
sync_type = entity_event[DSProps.SYNC_TYPE]
alarm_name = entity_event[NagiosProperties.SERVICE]
resource_name = entity_event[NagiosProperties.RESOURCE_NAME]
return tbase.build_key(
self._key_values(sync_type, resource_name, alarm_name))
def _validate_host_neighbor(self, neighbor, event):
host_vertex = neighbor.vertex
observed_key = host_vertex.vertex_id
expected_key = tbase.build_key(
(EntityCategory.RESOURCE, NOVA_HOST_DATASOURCE,
event[ZabbixProps.RESOURCE_NAME]))
expected_uuid = \
TransformerBase.uuid_from_deprecated_vitrage_id(expected_key)
self.assertEqual(expected_uuid, observed_key)
self.assertEqual(expected_uuid,
host_vertex.properties.get(VProps.VITRAGE_ID))
self.assertFalse(host_vertex[VProps.VITRAGE_IS_DELETED])
self.assertTrue(host_vertex[VProps.VITRAGE_IS_PLACEHOLDER])
self.assertEqual(EntityCategory.RESOURCE,
host_vertex[VProps.VITRAGE_CATEGORY])
self.assertEqual(event[ZabbixProps.RESOURCE_NAME],
host_vertex[VProps.ID])
self.assertEqual(NOVA_HOST_DATASOURCE,
host_vertex[VProps.VITRAGE_TYPE])
edge = neighbor.edge
self.assertEqual(EdgeLabel.ON, edge.label)
alarm_key = ZabbixTransformer(self.transformers, self.conf).\
_create_entity_key(event)
alarm_uuid = TransformerBase.uuid_from_deprecated_vitrage_id(alarm_key)
self.assertEqual(alarm_uuid, edge.source_id)
self.assertEqual(host_vertex.vertex_id, edge.target_id)
def _create_entity_key(self, entity_event):
entity_type = entity_event[DSProps.ENTITY_TYPE]
alarm_id = entity_event[ZProps.TRIGGER_ID]
resource_name = entity_event[ZProps.RESOURCE_NAME]
return tbase.build_key(
(EntityCategory.ALARM, entity_type, resource_name, alarm_id))
def test_create_entity_key(self):
LOG.debug('Test get key from nova instance transformer')
# Test setup
spec_list = mock_sync.simple_instance_generators(host_num=1,
vm_num=1,
snapshot_events=1,
update_events=0)
instance_events = mock_sync.generate_random_events_list(spec_list)
instance_transformer = self.transformers[NOVA_INSTANCE_DATASOURCE]
for event in instance_events:
# Test action
observed_key = instance_transformer._create_entity_key(event)
# Test assertions
observed_key_fields = observed_key.split(
TransformerBase.KEY_SEPARATOR)
self.assertEqual(EntityCategory.RESOURCE, observed_key_fields[0])
self.assertEqual(NOVA_INSTANCE_DATASOURCE, observed_key_fields[1])
instance_id = tbase.extract_field_value(event, 'id')
self.assertEqual(instance_id, observed_key_fields[2])
key_values = instance_transformer._key_values(
NOVA_INSTANCE_DATASOURCE, instance_id)
expected_key = tbase.build_key(key_values)
self.assertEqual(expected_key, observed_key)
def _topology_for_unrooted_graph(self, ga, subgraph, root):
"""Finds topology for unrooted subgraph
1. Finds all the connected component subgraphs in subgraph.
2. For each component, finds the path from one of the VMs (if exists)
to the root entity.
3. Unify all the entities found and return them
:type ga: NXAlgorithm
:type subgraph: networkx graph
:type root: string
:rtype: list
"""
entities = []
if not root:
root = build_key([EntityCategory.RESOURCE, OPENSTACK_CLUSTER])
root_vertex = \
self.entity_graph.get_vertex(root)
local_connected_component_subgraphs = \
ga.connected_component_subgraphs(subgraph)
for component_subgraph in local_connected_component_subgraphs:
entities += component_subgraph.nodes()
instance_in_component_subgraph = \
self._find_instance_in_graph(component_subgraph)
if instance_in_component_subgraph:
paths = ga.all_simple_paths(root_vertex.vertex_id,
instance_in_component_subgraph)
for path in paths:
entities += path
return set(entities)
def _create_entity_key(self, entity_event):
sync_type = entity_event[DSProps.SYNC_TYPE]
alarm_id = entity_event[ZProps.TRIGGER_ID]
resource_name = entity_event[ZProps.RESOURCE_NAME]
return tbase.build_key(
self._key_values(sync_type, resource_name, alarm_id))
def _create_entity_key(self, entity_event):
is_update_event = tbase.is_update_event(entity_event)
id_field_path = 'volume_id' if is_update_event else 'id'
volume_id = extract_field_value(entity_event, id_field_path)
key_fields = self._key_values(CINDER_VOLUME_DATASOURCE, volume_id)
return build_key(key_fields)
def _create_entity_key(self, entity_event):
is_update_event = tbase.is_update_event(entity_event)
id_field_path = 'volume_id' if is_update_event else 'id'
volume_id = extract_field_value(entity_event, id_field_path)
key_fields = self._key_values(CINDER_VOLUME_DATASOURCE, volume_id)
return build_key(key_fields)
def _create_entity_key(self, entity_event):
is_update_event = tbase.is_update_event(entity_event)
id_field_path = 'stack_identity' if is_update_event else 'id'
volume_id = extract_field_value(entity_event, id_field_path)
key_fields = self._key_values(HEAT_STACK_DATASOURCE, volume_id)
return build_key(key_fields)
def _create_entity_key(self, entity_event):
sync_type = entity_event[DSProps.SYNC_TYPE]
alarm_name = entity_event[NagiosProperties.SERVICE]
resource_name = entity_event[NagiosProperties.RESOURCE_NAME]
return tbase.build_key(self._key_values(sync_type,
resource_name,
alarm_name))
def _create_entity_key(self, entity_event):
entity_type = entity_event[DSProps.ENTITY_TYPE]
alarm_id = entity_event[ZProps.TRIGGER_ID]
resource_name = entity_event[ZProps.RESOURCE_NAME]
return tbase.build_key(self._key_values(entity_type,
resource_name,
alarm_id))
def _create_entity_key(self, entity_event):
is_update_event = tbase.is_update_event(entity_event)
id_field_path = 'stack_identity' if is_update_event else 'id'
volume_id = extract_field_value(entity_event, id_field_path)
key_fields = self._key_values(HEAT_STACK_DATASOURCE, volume_id)
return build_key(key_fields)
def _create_entity_key(self, entity_event):
is_update_event = tbase.is_update_event(entity_event)
id_field_path = StackProps.STACK_IDENTITY\
if is_update_event else StackProps.ID
volume_id = extract_field_value(entity_event, id_field_path)
key_fields = self._key_values(HEAT_STACK_DATASOURCE, volume_id)
return build_key(key_fields)
def _create_entity_key(self, entity_event):
entity_type = entity_event[DSProps.ENTITY_TYPE]
alarm_name = entity_event[NagiosProperties.SERVICE]
resource_name = entity_event[NagiosProperties.RESOURCE_NAME]
return tbase.build_key((EntityCategory.ALARM,
entity_type,
resource_name,
alarm_name))
def _create_entity_key(self, event):
LOG.debug('Creating key for instance event: %s', event)
instance_id = self._get_field_extractor(event).entity_id(event)
key_fields = self._key_values(NOVA_INSTANCE_DATASOURCE, instance_id)
key = tbase.build_key(key_fields)
LOG.debug('Created key: %s', key)
return key
def test_build_cluster_key(self):
LOG.debug('Test build cluster key')
# Test setup
expected_key = 'RESOURCE:kubernetes:kubernetes'
instance_transformer = self.transformers[NOVA_INSTANCE_DATASOURCE]
# Test action
key_fields = instance_transformer._key_values(KUBERNETES_DATASOURCE,
cluster_name)
# Test assertions
observed_key = tbase.build_key(key_fields)
self.assertEqual(expected_key, observed_key)
def test_build_instance_key(self):
LOG.debug('Test build instance key')
# Test setup
instance_id = '456'
expected_key = 'RESOURCE:nova.instance:%s' % instance_id
instance_transformer = self.transformers[NOVA_INSTANCE_DATASOURCE]
# Test action
key_fields = instance_transformer._key_values(NOVA_INSTANCE_DATASOURCE,
instance_id)
# Test assertions
observed_key = tbase.build_key(key_fields)
self.assertEqual(expected_key, observed_key)
def test_build_instance_key(self):
LOG.debug('Test build instance key')
# Test setup
instance_id = '456'
expected_key = 'RESOURCE:nova.instance:%s' % instance_id
instance_transformer = self.transformers[NOVA_INSTANCE_DATASOURCE]
# Test action
key_fields = instance_transformer._key_values(
NOVA_INSTANCE_DATASOURCE,
instance_id)
# Test assertions
observed_key = tbase.build_key(key_fields)
self.assertEqual(expected_key, observed_key)
def create_placeholder_vertex(self, **kwargs):
if VProps.TYPE not in kwargs:
LOG.error("Can't create placeholder vertex. Missing property TYPE")
raise ValueError('Missing property TYPE')
if VProps.ID not in kwargs:
LOG.error("Can't create placeholder vertex. Missing property ID")
raise ValueError('Missing property ID')
key_fields = self._key_values(kwargs[VProps.TYPE], kwargs[VProps.ID])
return graph_utils.create_vertex(
tbase.build_key(key_fields),
entity_id=kwargs[VProps.ID],
entity_category=EntityCategory.RESOURCE,
entity_type=kwargs[VProps.TYPE],
sample_timestamp=kwargs[VProps.SAMPLE_TIMESTAMP],
is_placeholder=True)
def test_create_placeholder_vertex(self):
LOG.debug('Static Physical transformer test: Create placeholder '
'vertex')
# Test setup
switch_type = STATIC_PHYSICAL_DATASOURCE
switch_name = 'switch-1'
timestamp = datetime.datetime.utcnow()
static_transformer = self.transformers[STATIC_PHYSICAL_DATASOURCE]
# Test action
properties = {
VProps.VITRAGE_TYPE: switch_type,
VProps.ID: switch_name,
VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE,
VProps.VITRAGE_SAMPLE_TIMESTAMP: timestamp
}
placeholder = \
static_transformer.create_neighbor_placeholder_vertex(**properties)
# Test assertions
observed_uuid = placeholder.vertex_id
expected_key = tbase.build_key(static_transformer._key_values(
switch_type, switch_name))
expected_uuid = \
TransformerBase.uuid_from_deprecated_vitrage_id(expected_key)
self.assertEqual(expected_uuid, observed_uuid)
observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP)
self.assertEqual(timestamp, observed_time)
observed_subtype = placeholder.get(VProps.VITRAGE_TYPE)
self.assertEqual(switch_type, observed_subtype)
observed_entity_id = placeholder.get(VProps.ID)
self.assertEqual(switch_name, observed_entity_id)
observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY)
self.assertEqual(EntityCategory.RESOURCE, observed_vitrage_category)
vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER)
self.assertTrue(vitrage_is_placeholder)
def test_create_placeholder_vertex(self):
LOG.debug('Zone transformer test: create placeholder vertex')
# Test setup
zone_name = 'zone123'
timestamp = datetime.datetime.utcnow()
zone_transformer = self.transformers[NOVA_ZONE_DATASOURCE]
# Test action
properties = {
VProps.ID: zone_name,
VProps.VITRAGE_TYPE: NOVA_ZONE_DATASOURCE,
VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE,
VProps.VITRAGE_SAMPLE_TIMESTAMP: timestamp
}
placeholder = \
zone_transformer.create_neighbor_placeholder_vertex(**properties)
# Test assertions
observed_uuid = placeholder.vertex_id
expected_key = tbase.build_key(zone_transformer._key_values(
NOVA_ZONE_DATASOURCE,
zone_name))
expected_uuid = \
zone_transformer.uuid_from_deprecated_vitrage_id(expected_key)
self.assertEqual(expected_uuid, observed_uuid)
observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP)
self.assertEqual(timestamp, observed_time)
observed_subtype = placeholder.get(VProps.VITRAGE_TYPE)
self.assertEqual(NOVA_ZONE_DATASOURCE, observed_subtype)
observed_entity_id = placeholder.get(VProps.ID)
self.assertEqual(zone_name, observed_entity_id)
observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY)
self.assertEqual(EntityCategory.RESOURCE, observed_vitrage_category)
vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER)
self.assertTrue(vitrage_is_placeholder)
def test_create_placeholder_vertex(self):
LOG.debug('Cetus pod transformer test: Test create placeholder '
'vertex')
# Test setup
pod_id = "pod123"
timestamp = datetime.datetime.utcnow()
pod_transformer = self.transformers[CETUS_POD_DATASOURCE]
# Test action
properties = {
VProps.ID: pod_id,
VProps.VITRAGE_TYPE: CETUS_POD_DATASOURCE,
VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE,
VProps.VITRAGE_SAMPLE_TIMESTAMP: timestamp
}
placeholder = \
pod_transformer.create_neighbor_placeholder_vertex(**properties)
# Test assertions
observed_uuid = placeholder.vertex_id
expected_key = tbase.build_key(
pod_transformer._key_values(CETUS_POD_DATASOURCE, pod_id))
expected_uuid = \
TransformerBase.uuid_from_deprecated_vitrage_id(expected_key)
self.assertEqual(expected_uuid, observed_uuid)
observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP)
self.assertEqual(timestamp, observed_time)
observed_subtype = placeholder.get(VProps.VITRAGE_TYPE)
self.assertEqual(CETUS_POD_DATASOURCE, observed_subtype)
observed_entity_id = placeholder.get(VProps.ID)
self.assertEqual(pod_id, observed_entity_id)
observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY)
self.assertEqual(EntityCategory.RESOURCE, observed_vitrage_category)
vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER)
self.assertTrue(vitrage_is_placeholder)
def test_create_placeholder_vertex(self):
LOG.debug('Cinder Volume transformer test: Create placeholder '
'vertex')
# Tests setup
volume_id = 'Instance123'
timestamp = datetime.datetime.utcnow()
properties = {
VProps.ID: volume_id,
VProps.VITRAGE_TYPE: CINDER_VOLUME_DATASOURCE,
VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE,
VProps.VITRAGE_SAMPLE_TIMESTAMP: timestamp
}
transformer = self.transformers[CINDER_VOLUME_DATASOURCE]
# Test action
placeholder = \
transformer.create_neighbor_placeholder_vertex(**properties)
# Test assertions)
expected_key = \
tbase.build_key(transformer._key_values(CINDER_VOLUME_DATASOURCE,
volume_id))
expected_uuid = \
TransformerBase.uuid_from_deprecated_vitrage_id(expected_key)
self.assertEqual(expected_uuid, placeholder.vertex_id)
observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP)
self.assertEqual(timestamp, observed_time)
observed_type = placeholder.get(VProps.VITRAGE_TYPE)
self.assertEqual(CINDER_VOLUME_DATASOURCE, observed_type)
observed_entity_id = placeholder.get(VProps.ID)
self.assertEqual(volume_id, observed_entity_id)
observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY)
self.assertEqual(EntityCategory.RESOURCE, observed_vitrage_category)
vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER)
self.assertTrue(vitrage_is_placeholder)
def test_create_placeholder_vertex(self):
LOG.debug('Heat Stack transformer test: Create placeholder vertex')
# Tests setup
stack_id = 'Stack123'
timestamp = datetime.datetime.utcnow()
properties = {
VProps.ID: stack_id,
VProps.VITRAGE_TYPE: HEAT_STACK_DATASOURCE,
VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE,
VProps.VITRAGE_SAMPLE_TIMESTAMP: timestamp
}
transformer = self.transformers[HEAT_STACK_DATASOURCE]
# Test action
placeholder = \
transformer.create_neighbor_placeholder_vertex(**properties)
# Test assertions
observed_uuid = placeholder.vertex_id
expected_key = tbase.build_key(
transformer._key_values(HEAT_STACK_DATASOURCE, stack_id))
expected_uuid = \
TransformerBase.uuid_from_deprecated_vitrage_id(expected_key)
self.assertEqual(expected_uuid, observed_uuid)
observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP)
self.assertEqual(timestamp, observed_time)
observed_type = placeholder.get(VProps.VITRAGE_TYPE)
self.assertEqual(HEAT_STACK_DATASOURCE, observed_type)
observed_entity_id = placeholder.get(VProps.ID)
self.assertEqual(stack_id, observed_entity_id)
observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY)
self.assertEqual(EntityCategory.RESOURCE, observed_vitrage_category)
vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER)
self.assertTrue(vitrage_is_placeholder)
def test_extract_key(self):
LOG.debug('Test get key from nova instance transformer')
# Test setup
spec_list = mock_sync.simple_instance_generators(
host_num=1,
vm_num=1,
snapshot_events=1,
update_events=0
)
instance_events = mock_sync.generate_random_events_list(spec_list)
instance_transformer = self.transformers[NOVA_INSTANCE_DATASOURCE]
for event in instance_events:
# Test action
observed_key = instance_transformer._create_entity_key(event)
# Test assertions
observed_key_fields = observed_key.split(
TransformerBase.KEY_SEPARATOR)
self.assertEqual(EntityCategory.RESOURCE, observed_key_fields[0])
self.assertEqual(
NOVA_INSTANCE_DATASOURCE,
observed_key_fields[1]
)
instance_id = tbase.extract_field_value(event, 'id')
self.assertEqual(instance_id, observed_key_fields[2])
key_values = instance_transformer._key_values(
NOVA_INSTANCE_DATASOURCE,
instance_id)
expected_key = tbase.build_key(key_values)
self.assertEqual(expected_key, observed_key)
def test_create_placeholder_vertex(self):
# Tests setup
cluster_id = 'tr-cluster-0'
timestamp = datetime.datetime.utcnow()
properties = {
VProps.ID: cluster_id,
VProps.VITRAGE_TYPE: TROVE_CLUSTER_DATASOURCE,
VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE,
VProps.VITRAGE_SAMPLE_TIMESTAMP: timestamp
}
transformer = self.transformers[TROVE_CLUSTER_DATASOURCE]
# Test action
placeholder = transformer.create_neighbor_placeholder_vertex(
**properties)
# Test assertions
expected_key = tb.build_key(
transformer._key_values(TROVE_CLUSTER_DATASOURCE, cluster_id))
expected_uuid = TransformerBase.uuid_from_deprecated_vitrage_id(
expected_key)
self.assertEqual(expected_uuid, placeholder.vertex_id)
self.assertEqual(timestamp,
placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP))
self.assertEqual(TROVE_CLUSTER_DATASOURCE,
placeholder.get(VProps.VITRAGE_TYPE))
self.assertEqual(cluster_id, placeholder.get(VProps.ID))
self.assertEqual(EntityCategory.RESOURCE,
placeholder.get(VProps.VITRAGE_CATEGORY))
self.assertTrue(placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER))
def _create_entity_key(self, entity_event):
return tbase.build_key(
(EntityCategory.ALARM, entity_event[DSProps.ENTITY_TYPE],
entity_event[EventProps.TYPE],
get_detail(entity_event, DoctorDetails.HOSTNAME)))
def _create_entity_key(self, entity_event):
key_fields = self._key_values(NEUTRON_PORT_DATASOURCE,
extract_field_value(entity_event, 'id'))
return tbase.build_key(key_fields)
def _create_entity_key(self, entity_event):
entity_id = entity_event[VProps.ID]
sync_type = entity_event[VProps.TYPE]
key_fields = self._key_values(sync_type, entity_id)
return transformer_base.build_key(key_fields)
def _create_entity_key(self, entity_event):
host_name = extract_field_value(entity_event, '_info', 'host_name')
key_fields = self._key_values(NOVA_HOST_DATASOURCE, host_name)
return transformer_base.build_key(key_fields)
def _create_entity_key(self, event):
key_fields = self._key_values(event[TFields.ALARM_NAME],
event[TFields.TARGET])
return transformer_base.build_key(key_fields)
def _create_entity_key(self, entity_event):
zone_name = extract_field_value(entity_event, 'zoneName')
key_fields = self._key_values(NOVA_ZONE_DATASOURCE, zone_name)
return tbase.build_key(key_fields)
