From 70763ca3e86461de4b464d4d649bcc6cac573384 Mon Sep 17 00:00:00 2001 From: Liat Har-Tal Date: Thu, 21 Jan 2016 13:32:18 +0000 Subject: [PATCH] nova transformer - splitting nova transformers to different files Change-Id: I1ccaeea1ac4567617c6e8d8f7328b09ff7bd3de0 --- .../transformer/host_transformer.py | 140 ++++++ .../transformer/instance_transformer.py | 200 ++++++++ .../transformer/nova_transformers.py | 449 ------------------ .../transformer/transformer_manager.py | 12 +- .../transformer/zone_transformer.py | 196 ++++++++ .../test_nova_host_transformer.py | 50 +- .../test_nova_instance_transformers.py | 69 +-- .../test_nova_zone_transformer.py | 47 +- .../transformers/test_transformer_manager.py | 24 +- 9 files changed, 645 insertions(+), 542 deletions(-) create mode 100644 vitrage/entity_graph/transformer/host_transformer.py create mode 100644 vitrage/entity_graph/transformer/instance_transformer.py delete mode 100644 vitrage/entity_graph/transformer/nova_transformers.py create mode 100644 vitrage/entity_graph/transformer/zone_transformer.py diff --git a/vitrage/entity_graph/transformer/host_transformer.py b/vitrage/entity_graph/transformer/host_transformer.py new file mode 100644 index 000000000..d278a89f9 --- /dev/null +++ b/vitrage/entity_graph/transformer/host_transformer.py @@ -0,0 +1,140 @@ +# Copyright 2016 - Alcatel-Lucent +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +from oslo_log import log as logging + +from vitrage.common.constants import EdgeLabels +from vitrage.common.constants import EntityTypes +from vitrage.common.constants import SyncMode +from vitrage.common.constants import VertexProperties +from vitrage.entity_graph.transformer import base +from vitrage.entity_graph.transformer.base import extract_field_value +import vitrage.graph.utils as graph_utils + + +LOG = logging.getLogger(__name__) + + +class HostTransformer(base.TransformerBase): + + HOST_TYPE = 'nova.host' + + # Fields returned from Nova Availability Zone snapshot + HOST_NAME = { + SyncMode.SNAPSHOT: ('host_name',), + SyncMode.INIT_SNAPSHOT: ('host_name',) + } + + ZONE_NAME = { + SyncMode.SNAPSHOT: ('zone',), + SyncMode.INIT_SNAPSHOT: ('zone',) + } + + TIMESTAMP = { + SyncMode.SNAPSHOT: ('sample_date',), + SyncMode.INIT_SNAPSHOT: ('sample_date',) + } + + def __init__(self, transformers): + self.transformers = transformers + + def transform(self, entity_event): + + sync_mode = entity_event['sync_mode'] + + host_name = extract_field_value( + entity_event, + self.HOST_NAME[sync_mode] + ) + metadata = { + VertexProperties.NAME: host_name + } + entity_key = self.extract_key(entity_event) + + timestamp = extract_field_value( + entity_event, + self.TIMESTAMP[sync_mode] + ) + + entity_vertex = graph_utils.create_vertex( + entity_key, + entity_id=host_name, + entity_category=EntityTypes.RESOURCE, + entity_type=self.HOST_TYPE, + update_timestamp=timestamp, + metadata=metadata + ) + + neighbors = [] + zone_transformer = self.transformers['nova.zone'] + + if zone_transformer: + zone_name = extract_field_value( + entity_event, + self.ZONE_NAME[sync_mode] + ) + zone_neighbor = self.create_zone_neighbor( + zone_name, + timestamp, + entity_key + ) + neighbors.append(zone_neighbor) + else: + LOG.warning('Cannot find zone transformer') + + return base.EntityWrapper( + entity_vertex, + neighbors, + self._extract_action_type(entity_event)) + + def create_zone_neighbor(self, zone_name, timestamp, host_vertex_id): + + zone_transformer = self.transformers['nova.zone'] + zone_neighbor = zone_transformer.create_placeholder_vertex( + zone_name, + timestamp + ) + relation_edge = graph_utils.create_edge( + source_id=zone_neighbor.vertex_id, + target_id=host_vertex_id, + relationship_type=EdgeLabels.CONTAINS + ) + return base.Neighbor(zone_neighbor, relation_edge) + + def _key_values(self, mutable_fields): + + fixed_fields = [EntityTypes.RESOURCE, self.HOST_TYPE] + return fixed_fields + mutable_fields + + def extract_key(self, entity_event): + + host_name = extract_field_value( + entity_event, + self.HOST_NAME[entity_event['sync_mode']] + ) + + key_fields = self._key_values([host_name]) + return base.build_key(key_fields) + + def create_placeholder_vertex(self, host_name, timestamp): + + key_fields = self._key_values([host_name]) + + return graph_utils.create_vertex( + base.build_key(key_fields), + entity_id=host_name, + entity_category=EntityTypes.RESOURCE, + entity_type=self.HOST_TYPE, + update_timestamp=timestamp, + is_placeholder=True + ) diff --git a/vitrage/entity_graph/transformer/instance_transformer.py b/vitrage/entity_graph/transformer/instance_transformer.py new file mode 100644 index 000000000..5e1069145 --- /dev/null +++ b/vitrage/entity_graph/transformer/instance_transformer.py @@ -0,0 +1,200 @@ +# Copyright 2016 - Alcatel-Lucent +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +from oslo_log import log as logging + +from vitrage.common.constants import EdgeLabels +from vitrage.common.constants import EntityTypes +from vitrage.common.constants import EventAction +from vitrage.common.constants import SyncMode +from vitrage.common.constants import VertexProperties +from vitrage.common.exception import VitrageTransformerError +from vitrage.entity_graph.transformer import base +from vitrage.entity_graph.transformer.base import extract_field_value +import vitrage.graph.utils as graph_utils + + +LOG = logging.getLogger(__name__) + + +class InstanceTransformer(base.TransformerBase): + + INSTANCE_TYPE = 'nova.instance' + + # Fields returned from Nova Instance snapshot + INSTANCE_ID = { + SyncMode.SNAPSHOT: ('id',), + SyncMode.INIT_SNAPSHOT: ('id',), + SyncMode.UPDATE: ('payload', 'instance_id') + } + + INSTANCE_STATE = { + SyncMode.SNAPSHOT: ('status',), + SyncMode.INIT_SNAPSHOT: ('status',), + SyncMode.UPDATE: ('payload', 'state') + } + + TIMESTAMP = { + SyncMode.SNAPSHOT: ('sample_date',), + SyncMode.INIT_SNAPSHOT: ('sample_date',), + SyncMode.UPDATE: ('metadata', 'timestamp') + } + + HOST_NAME = { + SyncMode.SNAPSHOT: ('OS-EXT-SRV-ATTR:host',), + SyncMode.INIT_SNAPSHOT: ('OS-EXT-SRV-ATTR:host',), + SyncMode.UPDATE: ('payload', 'host') + } + + PROJECT_ID = { + SyncMode.SNAPSHOT: ('tenant_id',), + SyncMode.INIT_SNAPSHOT: ('tenant_id',), + SyncMode.UPDATE: ('payload', 'tenant_id') + } + + INSTANCE_NAME = { + SyncMode.SNAPSHOT: ('name',), + SyncMode.INIT_SNAPSHOT: ('name',), + SyncMode.UPDATE: ('payload', 'hostname') + } + + UPDATE_EVENT_TYPE = 'event_type' + + # Event types which need to refer them differently + EVENT_TYPES = { + 'compute.instance.delete.end': EventAction.DELETE, + 'compute.instance.create.start': EventAction.CREATE + } + + def __init__(self, transformers): + self.transformers = transformers + + def transform(self, entity_event): + sync_mode = entity_event['sync_mode'] + + metadata = { + VertexProperties.NAME: extract_field_value( + entity_event, + self.INSTANCE_NAME[sync_mode] + ), + VertexProperties.IS_PLACEHOLDER: False + } + + entity_key = self.extract_key(entity_event) + + entity_id = extract_field_value( + entity_event, + self.INSTANCE_ID[sync_mode] + ) + project = extract_field_value(entity_event, self.PROJECT_ID[sync_mode]) + state = extract_field_value( + entity_event, + self.INSTANCE_STATE[sync_mode] + ) + update_timestamp = extract_field_value( + entity_event, + self.TIMESTAMP[sync_mode] + ) + + entity_vertex = graph_utils.create_vertex( + entity_key, + entity_id=entity_id, + entity_category=EntityTypes.RESOURCE, + entity_type=self.INSTANCE_TYPE, + entity_project=project, + entity_state=state, + update_timestamp=update_timestamp, + metadata=metadata + ) + + neighbors = [] + host_transformer = self.transformers['nova.host'] + + if host_transformer: + host_neighbor = self.create_host_neighbor( + entity_vertex.vertex_id, + extract_field_value(entity_event, self.HOST_NAME[sync_mode]), + update_timestamp, + host_transformer + ) + neighbors.append(host_neighbor) + else: + LOG.warning('Cannot find host transformer') + + return base.EntityWrapper( + entity_vertex, + neighbors, + self._extract_action_type(entity_event)) + + def _extract_action_type(self, entity_event): + + sync_mode = entity_event['sync_mode'] + + if SyncMode.UPDATE == sync_mode: + return self.EVENT_TYPES.get( + entity_event[self.UPDATE_EVENT_TYPE], + EventAction.UPDATE) + + if SyncMode.SNAPSHOT == sync_mode: + return EventAction.UPDATE + + if SyncMode.INIT_SNAPSHOT == sync_mode: + return EventAction.CREATE + + raise VitrageTransformerError( + 'Invalid sync mode: (%s)' % sync_mode) + + def extract_key(self, entity_event): + + instance_id = extract_field_value( + entity_event, + self.INSTANCE_ID[entity_event['sync_mode']]) + + key_fields = self._key_values([instance_id]) + return base.build_key(key_fields) + + def create_host_neighbor( + self, + vertex_id, + host_name, + timestamp, + host_transformer + ): + + host_vertex = host_transformer.create_placeholder_vertex( + host_name, + timestamp + ) + + relation_edge = graph_utils.create_edge( + source_id=host_vertex.vertex_id, + target_id=vertex_id, + relationship_type=EdgeLabels.CONTAINS + ) + return base.Neighbor(host_vertex, relation_edge) + + def create_placeholder_vertex(self, instance_id, timestamp): + + key_fields = self._key_values([instance_id]) + + return graph_utils.create_vertex( + base.build_key(key_fields), + entity_id=instance_id, + entity_category=EntityTypes.RESOURCE, + entity_type=self.INSTANCE_TYPE, + update_timestamp=timestamp, + is_placeholder=True + ) + + def _key_values(self, mutable_fields): + return [EntityTypes.RESOURCE, self.INSTANCE_TYPE] + mutable_fields diff --git a/vitrage/entity_graph/transformer/nova_transformers.py b/vitrage/entity_graph/transformer/nova_transformers.py deleted file mode 100644 index 28c6bc656..000000000 --- a/vitrage/entity_graph/transformer/nova_transformers.py +++ /dev/null @@ -1,449 +0,0 @@ -# Copyright 2016 - Alcatel-Lucent -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. -from oslo_log import log as logging - -from vitrage.common.constants import EdgeLabels -from vitrage.common.constants import EntityTypes -from vitrage.common.constants import EventAction -from vitrage.common.constants import SyncMode -from vitrage.common.constants import VertexProperties -from vitrage.common.exception import VitrageTransformerError -from vitrage.entity_graph.transformer import base -from vitrage.entity_graph.transformer.base import extract_field_value -import vitrage.graph.utils as graph_utils - - -LOG = logging.getLogger(__name__) - - -INSTANCE_TYPE = 'nova.instance' -HOST_TYPE = 'nova.host' -ZONE_TYPE = 'nova.zone' - - -class InstanceTransformer(base.TransformerBase): - - # Fields returned from Nova Instance snapshot - INSTANCE_ID = { - SyncMode.SNAPSHOT: ('id',), - SyncMode.INIT_SNAPSHOT: ('id',), - SyncMode.UPDATE: ('payload', 'instance_id') - } - - INSTANCE_STATE = { - SyncMode.SNAPSHOT: ('status',), - SyncMode.INIT_SNAPSHOT: ('status',), - SyncMode.UPDATE: ('payload', 'state') - } - - TIMESTAMP = { - SyncMode.SNAPSHOT: ('sample_date',), - SyncMode.INIT_SNAPSHOT: ('sample_date',), - SyncMode.UPDATE: ('metadata', 'timestamp') - } - - HOST_NAME = { - SyncMode.SNAPSHOT: ('OS-EXT-SRV-ATTR:host',), - SyncMode.INIT_SNAPSHOT: ('OS-EXT-SRV-ATTR:host',), - SyncMode.UPDATE: ('payload', 'host') - } - - PROJECT_ID = { - SyncMode.SNAPSHOT: ('tenant_id',), - SyncMode.INIT_SNAPSHOT: ('tenant_id',), - SyncMode.UPDATE: ('payload', 'tenant_id') - } - - INSTANCE_NAME = { - SyncMode.SNAPSHOT: ('name',), - SyncMode.INIT_SNAPSHOT: ('name',), - SyncMode.UPDATE: ('payload', 'hostname') - } - - UPDATE_EVENT_TYPE = 'event_type' - - # Event types which need to refer them differently - EVENT_TYPES = { - 'compute.instance.delete.end': EventAction.DELETE, - 'compute.instance.create.start': EventAction.CREATE - } - - def transform(self, entity_event): - sync_mode = entity_event['sync_mode'] - - metadata = { - VertexProperties.NAME: extract_field_value( - entity_event, - self.INSTANCE_NAME[sync_mode] - ), - VertexProperties.IS_PLACEHOLDER: False - } - - entity_key = self.extract_key(entity_event) - - entity_id = extract_field_value( - entity_event, - self.INSTANCE_ID[sync_mode] - ) - project = extract_field_value(entity_event, self.PROJECT_ID[sync_mode]) - state = extract_field_value( - entity_event, - self.INSTANCE_STATE[sync_mode] - ) - update_timestamp = extract_field_value( - entity_event, - self.TIMESTAMP[sync_mode] - ) - - entity_vertex = graph_utils.create_vertex( - entity_key, - entity_id=entity_id, - entity_category=EntityTypes.RESOURCE, - entity_type=INSTANCE_TYPE, - entity_project=project, - entity_state=state, - update_timestamp=update_timestamp, - metadata=metadata - ) - - host_neighbor = self.create_host_neighbor( - entity_vertex.vertex_id, - extract_field_value(entity_event, self.HOST_NAME[sync_mode]), - update_timestamp - ) - - return base.EntityWrapper( - entity_vertex, - [host_neighbor], - self._extract_action_type(entity_event)) - - def _extract_action_type(self, entity_event): - - sync_mode = entity_event['sync_mode'] - - if SyncMode.UPDATE == sync_mode: - return self.EVENT_TYPES.get( - entity_event[self.UPDATE_EVENT_TYPE], - EventAction.UPDATE) - - if SyncMode.SNAPSHOT == sync_mode: - return EventAction.UPDATE - - if SyncMode.INIT_SNAPSHOT == sync_mode: - return EventAction.CREATE - - raise VitrageTransformerError( - 'Invalid sync mode: (%s)' % sync_mode) - - def extract_key(self, entity_event): - - instance_id = extract_field_value( - entity_event, - self.INSTANCE_ID[entity_event['sync_mode']]) - - key_fields = self._key_values([instance_id]) - return base.build_key(key_fields) - - def create_host_neighbor(self, vertex_id, host_name, timestamp): - - ht = HostTransformer() - host_vertex = ht.create_placeholder_vertex(host_name, timestamp) - - relation_edge = graph_utils.create_edge( - source_id=host_vertex.vertex_id, - target_id=vertex_id, - relationship_type=EdgeLabels.CONTAINS - ) - return base.Neighbor(host_vertex, relation_edge) - - def create_placeholder_vertex(self, instance_id, timestamp): - - key_fields = self._key_values([instance_id]) - - return graph_utils.create_vertex( - base.build_key(key_fields), - entity_id=instance_id, - entity_category=EntityTypes.RESOURCE, - entity_type=INSTANCE_TYPE, - update_timestamp=timestamp, - is_placeholder=True - ) - - def _key_values(self, mutable_fields): - return [EntityTypes.RESOURCE, INSTANCE_TYPE] + mutable_fields - - -class HostTransformer(base.TransformerBase): - - # Fields returned from Nova Availability Zone snapshot - HOST_NAME = { - SyncMode.SNAPSHOT: ('host_name',), - SyncMode.INIT_SNAPSHOT: ('host_name',) - } - - ZONE_NAME = { - SyncMode.SNAPSHOT: ('zone',), - SyncMode.INIT_SNAPSHOT: ('zone',) - } - - TIMESTAMP = { - SyncMode.SNAPSHOT: ('sample_date',), - SyncMode.INIT_SNAPSHOT: ('sample_date',) - } - - def transform(self, entity_event): - - sync_mode = entity_event['sync_mode'] - - host_name = extract_field_value( - entity_event, - self.HOST_NAME[sync_mode] - ) - metadata = { - VertexProperties.NAME: host_name - } - entity_key = self.extract_key(entity_event) - - timestamp = extract_field_value( - entity_event, - self.TIMESTAMP[sync_mode] - ) - - entity_vertex = graph_utils.create_vertex( - entity_key, - entity_id=host_name, - entity_category=EntityTypes.RESOURCE, - entity_type=HOST_TYPE, - update_timestamp=timestamp, - metadata=metadata - ) - - zone_name = extract_field_value( - entity_event, - self.ZONE_NAME[sync_mode] - ) - zone_neighbor = self.create_zone_neighbor( - zone_name, - timestamp, - entity_key - ) - - return base.EntityWrapper( - entity_vertex, - [zone_neighbor], - self._extract_action_type(entity_event)) - - def create_zone_neighbor(self, zone_name, timestamp, host_vertex_id): - - zone_neighbor = ZoneTransformer().create_placeholder_vertex( - zone_name, - timestamp - ) - relation_edge = graph_utils.create_edge( - source_id=zone_neighbor.vertex_id, - target_id=host_vertex_id, - relationship_type=EdgeLabels.CONTAINS - ) - return base.Neighbor(zone_neighbor, relation_edge) - - def _key_values(self, mutable_fields): - - fixed_fields = [EntityTypes.RESOURCE, HOST_TYPE] - return fixed_fields + mutable_fields - - def extract_key(self, entity_event): - - host_name = extract_field_value( - entity_event, - self.HOST_NAME[entity_event['sync_mode']] - ) - - key_fields = self._key_values([host_name]) - return base.build_key(key_fields) - - def create_placeholder_vertex(self, host_name, timestamp): - - key_fields = self._key_values([host_name]) - - return graph_utils.create_vertex( - base.build_key(key_fields), - entity_id=host_name, - entity_category=EntityTypes.RESOURCE, - entity_type=HOST_TYPE, - update_timestamp=timestamp, - is_placeholder=True - ) - - -class ZoneTransformer(base.TransformerBase): - - STATE_AVAILABLE = 'available' - STATE_UNAVAILABLE = 'unavailable' - - # Fields returned from Nova Availability Zone snapshot - ZONE_NAME = { - SyncMode.SNAPSHOT: ('zoneName',), - SyncMode.INIT_SNAPSHOT: ('zoneName',) - } - - ZONE_STATE = { - SyncMode.SNAPSHOT: ('zoneState', 'available',), - SyncMode.INIT_SNAPSHOT: ('zoneState', 'available',) - } - - TIMESTAMP = { - SyncMode.SNAPSHOT: ('sample_date',), - SyncMode.INIT_SNAPSHOT: ('sample_date',) - } - - HOSTS = { - SyncMode.SNAPSHOT: ('hosts',), - SyncMode.INIT_SNAPSHOT: ('hosts',) - } - - HOST_ACTIVE = { - # The path is relative to specific host and not the whole event - SyncMode.SNAPSHOT: ('nova-compute', 'active',), - SyncMode.INIT_SNAPSHOT: ('nova-compute', 'active',) - } - - HOST_AVAILABLE = { - # The path is relative to specific host and not the whole event - SyncMode.SNAPSHOT: ('nova-compute', 'available',), - SyncMode.INIT_SNAPSHOT: ('nova-compute', 'available',) - } - - def transform(self, entity_event): - sync_mode = entity_event['sync_mode'] - - zone_name = extract_field_value( - entity_event, - self.ZONE_NAME[sync_mode] - ) - - metadata = { - VertexProperties.NAME: zone_name - } - - entity_key = self.extract_key(entity_event) - is_available = extract_field_value( - entity_event, - self.ZONE_STATE[sync_mode] - ) - state = self.STATE_AVAILABLE if is_available \ - else self.STATE_UNAVAILABLE - - timestamp = extract_field_value( - entity_event, - self.TIMESTAMP[sync_mode] - ) - - entity_vertex = graph_utils.create_vertex( - entity_key, - entity_id=zone_name, - entity_category=EntityTypes.RESOURCE, - entity_type=ZONE_TYPE, - entity_state=state, - update_timestamp=timestamp, - metadata=metadata - ) - - neighbors = [self._create_node_neighbor(entity_vertex)] - - hosts = extract_field_value(entity_event, self.HOSTS[sync_mode]) - - for key in hosts: - - host_available = extract_field_value( - hosts[key], - self.HOST_AVAILABLE[sync_mode] - ) - host_active = extract_field_value( - hosts[key], - self.HOST_ACTIVE[sync_mode] - ) - - if host_available and host_active: - host_state = self.STATE_AVAILABLE - else: - host_state = self.STATE_UNAVAILABLE - - host_neighbor = self._create_host_neighbor( - entity_vertex.vertex_id, - key, - host_state, - timestamp - ) - neighbors.append(host_neighbor) - - return base.EntityWrapper( - entity_vertex, - neighbors, - self._extract_action_type(entity_event)) - - def _create_node_neighbor(self, zone_vertex): - - node_vertex = base.create_node_placeholder_vertex() - - relation_edge = graph_utils.create_edge( - source_id=node_vertex.vertex_id, - target_id=zone_vertex.vertex_id, - relationship_type=EdgeLabels.CONTAINS - ) - return base.Neighbor(node_vertex, relation_edge) - - def _create_host_neighbor(self, zone_id, host_name, host_state, timestamp): - - host_vertex = graph_utils.create_vertex( - base.build_key(HostTransformer()._key_values([host_name])), - entity_id=host_name, - entity_category=EntityTypes.RESOURCE, - entity_type=ZONE_TYPE, - entity_state=host_state, - update_timestamp=timestamp, - ) - - relation_edge = graph_utils.create_edge( - source_id=zone_id, - target_id=host_vertex.vertex_id, - relationship_type=EdgeLabels.CONTAINS - ) - return base.Neighbor(host_vertex, relation_edge) - - def extract_key(self, entity_event): - - zone_name = extract_field_value( - entity_event, - self.ZONE_NAME[entity_event['sync_mode']] - ) - - key_fields = self._key_values([zone_name]) - return base.build_key(key_fields) - - def _key_values(self, mutable_fields): - - fixed_fields = [EntityTypes.RESOURCE, ZONE_TYPE] - return fixed_fields + mutable_fields - - def create_placeholder_vertex(self, zone_name, timestamp): - key = base.build_key(self._key_values([zone_name])) - - return graph_utils.create_vertex( - key, - entity_id=zone_name, - entity_category=EntityTypes.RESOURCE, - entity_type=ZONE_TYPE, - update_timestamp=timestamp, - is_placeholder=True - ) diff --git a/vitrage/entity_graph/transformer/transformer_manager.py b/vitrage/entity_graph/transformer/transformer_manager.py index 333daac97..177d3d173 100644 --- a/vitrage/entity_graph/transformer/transformer_manager.py +++ b/vitrage/entity_graph/transformer/transformer_manager.py @@ -30,16 +30,16 @@ class TransformerManager(object): transformers = {} transformers['nova.instance'] = importutils.import_object( - 'vitrage.entity_graph.transformer.nova_transformers.' - + 'InstanceTransformer') + 'vitrage.entity_graph.transformer.instance_transformer.' + + 'InstanceTransformer', transformers) transformers['nova.host'] = importutils.import_object( - 'vitrage.entity_graph.transformer.nova_transformers.' - + 'HostTransformer') + 'vitrage.entity_graph.transformer.host_transformer.' + + 'HostTransformer', transformers) transformers['nova.zone'] = importutils.import_object( - 'vitrage.entity_graph.transformer.nova_transformers.' - + 'ZoneTransformer') + 'vitrage.entity_graph.transformer.zone_transformer.' + + 'ZoneTransformer', transformers) return transformers diff --git a/vitrage/entity_graph/transformer/zone_transformer.py b/vitrage/entity_graph/transformer/zone_transformer.py new file mode 100644 index 000000000..17fa52eff --- /dev/null +++ b/vitrage/entity_graph/transformer/zone_transformer.py @@ -0,0 +1,196 @@ +# Copyright 2016 - Alcatel-Lucent +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +from oslo_log import log as logging + +from vitrage.common.constants import EdgeLabels +from vitrage.common.constants import EntityTypes +from vitrage.common.constants import SyncMode +from vitrage.common.constants import VertexProperties +from vitrage.entity_graph.transformer import base +from vitrage.entity_graph.transformer.base import extract_field_value +import vitrage.graph.utils as graph_utils + + +LOG = logging.getLogger(__name__) + + +class ZoneTransformer(base.TransformerBase): + + ZONE_TYPE = 'nova.zone' + + STATE_AVAILABLE = 'available' + STATE_UNAVAILABLE = 'unavailable' + + # Fields returned from Nova Availability Zone snapshot + ZONE_NAME = { + SyncMode.SNAPSHOT: ('zoneName',), + SyncMode.INIT_SNAPSHOT: ('zoneName',) + } + + ZONE_STATE = { + SyncMode.SNAPSHOT: ('zoneState', 'available',), + SyncMode.INIT_SNAPSHOT: ('zoneState', 'available',) + } + + TIMESTAMP = { + SyncMode.SNAPSHOT: ('sample_date',), + SyncMode.INIT_SNAPSHOT: ('sample_date',) + } + + HOSTS = { + SyncMode.SNAPSHOT: ('hosts',), + SyncMode.INIT_SNAPSHOT: ('hosts',) + } + + HOST_ACTIVE = { + # The path is relative to specific host and not the whole event + SyncMode.SNAPSHOT: ('nova-compute', 'active',), + SyncMode.INIT_SNAPSHOT: ('nova-compute', 'active',) + } + + HOST_AVAILABLE = { + # The path is relative to specific host and not the whole event + SyncMode.SNAPSHOT: ('nova-compute', 'available',), + SyncMode.INIT_SNAPSHOT: ('nova-compute', 'available',) + } + + def __init__(self, transformers): + self.transformers = transformers + + def transform(self, entity_event): + sync_mode = entity_event['sync_mode'] + + zone_name = extract_field_value( + entity_event, + self.ZONE_NAME[sync_mode] + ) + + metadata = { + VertexProperties.NAME: zone_name + } + + entity_key = self.extract_key(entity_event) + is_available = extract_field_value( + entity_event, + self.ZONE_STATE[sync_mode] + ) + state = self.STATE_AVAILABLE if is_available \ + else self.STATE_UNAVAILABLE + + timestamp = extract_field_value( + entity_event, + self.TIMESTAMP[sync_mode] + ) + + entity_vertex = graph_utils.create_vertex( + entity_key, + entity_id=zone_name, + entity_category=EntityTypes.RESOURCE, + entity_type=self.ZONE_TYPE, + entity_state=state, + update_timestamp=timestamp, + metadata=metadata + ) + + neighbors = [self._create_node_neighbor(entity_vertex)] + + hosts = extract_field_value(entity_event, self.HOSTS[sync_mode]) + host_transformer = self.transformers['nova.host'] + if host_transformer: + for key in hosts: + + host_available = extract_field_value( + hosts[key], + self.HOST_AVAILABLE[sync_mode] + ) + host_active = extract_field_value( + hosts[key], + self.HOST_ACTIVE[sync_mode] + ) + + if host_available and host_active: + host_state = self.STATE_AVAILABLE + else: + host_state = self.STATE_UNAVAILABLE + + host_neighbor = self._create_host_neighbor( + entity_vertex.vertex_id, + key, + host_state, + timestamp + ) + neighbors.append(host_neighbor) + + return base.EntityWrapper( + entity_vertex, + neighbors, + self._extract_action_type(entity_event)) + + def _create_node_neighbor(self, zone_vertex): + + node_vertex = base.create_node_placeholder_vertex() + + relation_edge = graph_utils.create_edge( + source_id=node_vertex.vertex_id, + target_id=zone_vertex.vertex_id, + relationship_type=EdgeLabels.CONTAINS + ) + return base.Neighbor(node_vertex, relation_edge) + + def _create_host_neighbor(self, zone_id, host_name, host_state, timestamp): + + host_transformer = self.transformers['nova.host'] + + host_vertex = graph_utils.create_vertex( + base.build_key(host_transformer._key_values([host_name])), + entity_id=host_name, + entity_category=EntityTypes.RESOURCE, + entity_type=self.ZONE_TYPE, + entity_state=host_state, + update_timestamp=timestamp, + ) + + relation_edge = graph_utils.create_edge( + source_id=zone_id, + target_id=host_vertex.vertex_id, + relationship_type=EdgeLabels.CONTAINS + ) + return base.Neighbor(host_vertex, relation_edge) + + def extract_key(self, entity_event): + + zone_name = extract_field_value( + entity_event, + self.ZONE_NAME[entity_event['sync_mode']] + ) + + key_fields = self._key_values([zone_name]) + return base.build_key(key_fields) + + def _key_values(self, mutable_fields): + + fixed_fields = [EntityTypes.RESOURCE, self.ZONE_TYPE] + return fixed_fields + mutable_fields + + def create_placeholder_vertex(self, zone_name, timestamp): + key = base.build_key(self._key_values([zone_name])) + + return graph_utils.create_vertex( + key, + entity_id=zone_name, + entity_category=EntityTypes.RESOURCE, + entity_type=self.ZONE_TYPE, + update_timestamp=timestamp, + is_placeholder=True + ) diff --git a/vitrage/tests/unit/transformers/test_nova_host_transformer.py b/vitrage/tests/unit/transformers/test_nova_host_transformer.py index da02f8e26..aac68f2e0 100644 --- a/vitrage/tests/unit/transformers/test_nova_host_transformer.py +++ b/vitrage/tests/unit/transformers/test_nova_host_transformer.py @@ -22,8 +22,8 @@ from vitrage.common.constants import SyncMode from vitrage.common.constants import VertexProperties from vitrage.entity_graph.transformer import base as tbase from vitrage.entity_graph.transformer.base import TransformerBase -from vitrage.entity_graph.transformer import nova_transformers -from vitrage.entity_graph.transformer.nova_transformers import HostTransformer +from vitrage.entity_graph.transformer.host_transformer import HostTransformer +from vitrage.entity_graph.transformer.zone_transformer import ZoneTransformer from vitrage.tests.mocks import mock_syncronizer as mock_sync from vitrage.tests.unit import base @@ -33,15 +33,23 @@ LOG = logging.getLogger(__name__) class NovaHostTransformerTest(base.BaseTest): + def setUp(self): + super(NovaHostTransformerTest, self).setUp() + + self.transformers = {} + zone_transformer = ZoneTransformer(self.transformers) + self.transformers['nova.zone'] = zone_transformer + def test_create_placeholder_vertex(self): LOG.debug('Nova host transformer test: Test create placeholder vertex') # Test setup host_name = 'host123' timestamp = datetime.datetime.utcnow() + host_transformer = HostTransformer(self.transformers) # Test action - placeholder = HostTransformer().create_placeholder_vertex( + placeholder = host_transformer.create_placeholder_vertex( host_name, timestamp ) @@ -49,14 +57,14 @@ class NovaHostTransformerTest(base.BaseTest): # Test assertions observed_id_values = placeholder.vertex_id.split( TransformerBase.KEY_SEPARATOR) - expected_id_values = HostTransformer()._key_values([host_name]) + expected_id_values = host_transformer._key_values([host_name]) self.assertEqual(observed_id_values, expected_id_values) observed_time = placeholder.get(VertexProperties.UPDATE_TIMESTAMP) self.assertEqual(observed_time, timestamp) observed_subtype = placeholder.get(VertexProperties.TYPE) - self.assertEqual(observed_subtype, nova_transformers.HOST_TYPE) + self.assertEqual(observed_subtype, host_transformer.HOST_TYPE) observed_entity_id = placeholder.get(VertexProperties.ID) self.assertEqual(observed_entity_id, host_name) @@ -71,21 +79,23 @@ class NovaHostTransformerTest(base.BaseTest): LOG.debug('Test key values') + # Test setup host_name = 'host123456' - observed_key_fields = HostTransformer()._key_values( + host_transformer = HostTransformer(self.transformers) + + # Test action + observed_key_fields = host_transformer._key_values( [host_name] ) + # Test assertions self.assertEqual(EntityTypes.RESOURCE, observed_key_fields[0]) self.assertEqual( - nova_transformers.HOST_TYPE, + host_transformer.HOST_TYPE, observed_key_fields[1] ) self.assertEqual(host_name, observed_key_fields[2]) - def test_extract_key(self): - pass - def test_snapshot_transform(self): LOG.debug('Nova host transformer test: transform entity event') @@ -99,7 +109,7 @@ class NovaHostTransformerTest(base.BaseTest): for event in host_events: # Test action - wrapper = HostTransformer().transform(event) + wrapper = HostTransformer(self.transformers).transform(event) # Test assertions self._validate_vertex_props(wrapper.vertex, event) @@ -118,14 +128,14 @@ class NovaHostTransformerTest(base.BaseTest): sync_mode = event['sync_mode'] zone_name = tbase.extract_field_value( event, - HostTransformer().ZONE_NAME[sync_mode] + HostTransformer(self.transformers).ZONE_NAME[sync_mode] ) time = tbase.extract_field_value( event, - HostTransformer().TIMESTAMP[sync_mode] + HostTransformer(self.transformers).TIMESTAMP[sync_mode] ) - zt = nova_transformers.ZoneTransformer() + zt = self.transformers['nova.zone'] expected_neighbor = zt.create_placeholder_vertex(zone_name, time) self.assertEqual(expected_neighbor, zone.vertex) @@ -134,7 +144,7 @@ class NovaHostTransformerTest(base.BaseTest): self.assertEqual(edge.source_id, zone.vertex.vertex_id) self.assertEqual( edge.target_id, - HostTransformer().extract_key(event) + HostTransformer(self.transformers).extract_key(event) ) self.assertEqual(edge.label, EdgeLabels.CONTAINS) @@ -145,7 +155,7 @@ class NovaHostTransformerTest(base.BaseTest): expected_id = extract_value( event, - HostTransformer().HOST_NAME[sync_mode] + HostTransformer(self.transformers).HOST_NAME[sync_mode] ) observed_id = vertex[VertexProperties.ID] self.assertEqual(expected_id, observed_id) @@ -155,7 +165,7 @@ class NovaHostTransformerTest(base.BaseTest): ) self.assertEqual( - nova_transformers.HOST_TYPE, + HostTransformer(self.transformers).HOST_TYPE, vertex[VertexProperties.TYPE] ) @@ -190,9 +200,10 @@ class NovaHostTransformerTest(base.BaseTest): snap_vals={'sync_mode': SyncMode.SNAPSHOT}) hosts_events = mock_sync.generate_random_events_list(spec_list) + host_transformer = HostTransformer(self.transformers) # Test action - action = HostTransformer()._extract_action_type(hosts_events[0]) + action = host_transformer._extract_action_type(hosts_events[0]) # Test assertion self.assertEqual(EventAction.UPDATE, action) @@ -204,9 +215,10 @@ class NovaHostTransformerTest(base.BaseTest): snapshot_events=1, snap_vals={'sync_mode': SyncMode.INIT_SNAPSHOT}) hosts_events = mock_sync.generate_random_events_list(spec_list) + host_transformer = HostTransformer(self.transformers) # Test action - action = HostTransformer()._extract_action_type(hosts_events[0]) + action = host_transformer._extract_action_type(hosts_events[0]) # Test assertions self.assertEqual(EventAction.CREATE, action) diff --git a/vitrage/tests/unit/transformers/test_nova_instance_transformers.py b/vitrage/tests/unit/transformers/test_nova_instance_transformers.py index b0d96a8e8..bb59ac349 100644 --- a/vitrage/tests/unit/transformers/test_nova_instance_transformers.py +++ b/vitrage/tests/unit/transformers/test_nova_instance_transformers.py @@ -23,19 +23,25 @@ from vitrage.common.constants import SyncMode from vitrage.common.constants import VertexProperties from vitrage.entity_graph.transformer import base as tbase from vitrage.entity_graph.transformer.base import TransformerBase -from vitrage.entity_graph.transformer import nova_transformers -from vitrage.entity_graph.transformer.nova_transformers import \ +from vitrage.entity_graph.transformer.host_transformer import HostTransformer +from vitrage.entity_graph.transformer.instance_transformer import \ InstanceTransformer from vitrage.tests.mocks import mock_syncronizer as mock_sync from vitrage.tests.unit import base - LOG = logging.getLogger(__name__) class NovaInstanceTransformerTest(base.BaseTest): + def setUp(self): + super(NovaInstanceTransformerTest, self).setUp() + + self.transformers = {} + host_transformer = HostTransformer(self.transformers) + self.transformers['nova.host'] = host_transformer + def test_create_placeholder_vertex(self): LOG.debug('Test create placeholder vertex') @@ -44,7 +50,8 @@ class NovaInstanceTransformerTest(base.BaseTest): timestamp = datetime.datetime.utcnow() # Test action - placeholder = InstanceTransformer().create_placeholder_vertex( + instance_transformer = InstanceTransformer(self.transformers) + placeholder = instance_transformer.create_placeholder_vertex( instance_id, timestamp ) @@ -52,7 +59,7 @@ class NovaInstanceTransformerTest(base.BaseTest): # Test assertions observed_id_values = placeholder.vertex_id.split( TransformerBase.KEY_SEPARATOR) - expected_id_values = InstanceTransformer()._key_values( + expected_id_values = instance_transformer._key_values( [instance_id] ) self.assertEqual(observed_id_values, expected_id_values) @@ -61,7 +68,7 @@ class NovaInstanceTransformerTest(base.BaseTest): self.assertEqual(observed_time, timestamp) observed_type = placeholder.get(VertexProperties.TYPE) - self.assertEqual(observed_type, nova_transformers.INSTANCE_TYPE) + self.assertEqual(observed_type, InstanceTransformer.INSTANCE_TYPE) observed_entity_id = placeholder.get(VertexProperties.ID) self.assertEqual(observed_entity_id, instance_id) @@ -87,7 +94,8 @@ class NovaInstanceTransformerTest(base.BaseTest): for event in instance_events: # Test action - wrapper = nova_transformers.InstanceTransformer().transform(event) + instance_transformer = InstanceTransformer(self.transformers) + wrapper = instance_transformer.transform(event) # Test assertions self._validate_vertex_props(wrapper.vertex, event) @@ -122,7 +130,8 @@ class NovaInstanceTransformerTest(base.BaseTest): for event in instance_events: # Test action - wrapper = nova_transformers.InstanceTransformer().transform(event) + instance_transformer = InstanceTransformer(self.transformers) + wrapper = instance_transformer.transform(event) # Test assertions self._validate_vertex_props(wrapper.vertex, event) @@ -153,7 +162,7 @@ class NovaInstanceTransformerTest(base.BaseTest): extract_value = tbase.extract_field_value expected_id = extract_value( event, - nova_transformers.InstanceTransformer.INSTANCE_ID[sync_mode] + InstanceTransformer.INSTANCE_ID[sync_mode] ) observed_id = vertex[VertexProperties.ID] self.assertEqual(expected_id, observed_id) @@ -164,34 +173,34 @@ class NovaInstanceTransformerTest(base.BaseTest): ) self.assertEqual( - nova_transformers.INSTANCE_TYPE, + InstanceTransformer.INSTANCE_TYPE, vertex[VertexProperties.TYPE] ) expected_project = extract_value( event, - nova_transformers.InstanceTransformer.PROJECT_ID[sync_mode] + InstanceTransformer.PROJECT_ID[sync_mode] ) observed_project = vertex[VertexProperties.PROJECT_ID] self.assertEqual(expected_project, observed_project) expected_state = extract_value( event, - nova_transformers.InstanceTransformer.INSTANCE_STATE[sync_mode] + InstanceTransformer.INSTANCE_STATE[sync_mode] ) observed_state = vertex[VertexProperties.STATE] self.assertEqual(expected_state, observed_state) expected_timestamp = extract_value( event, - nova_transformers.InstanceTransformer.TIMESTAMP[sync_mode] + InstanceTransformer.TIMESTAMP[sync_mode] ) observed_timestamp = vertex[VertexProperties.UPDATE_TIMESTAMP] self.assertEqual(expected_timestamp, observed_timestamp) expected_name = extract_value( event, - nova_transformers.InstanceTransformer.INSTANCE_NAME[sync_mode] + InstanceTransformer.INSTANCE_NAME[sync_mode] ) observed_name = vertex[VertexProperties.NAME] self.assertEqual(expected_name, observed_name) @@ -204,18 +213,13 @@ class NovaInstanceTransformerTest(base.BaseTest): def _validate_host_neighbor(self, h_neighbor, event): - it = nova_transformers.InstanceTransformer() + it = InstanceTransformer(self.transformers) sync_mode = event['sync_mode'] - host_name = tbase.extract_field_value( - event, - it.HOST_NAME[sync_mode] - ) - time = tbase.extract_field_value( - event, - it.TIMESTAMP[sync_mode] - ) - ht = nova_transformers.HostTransformer() + host_name = tbase.extract_field_value(event, it.HOST_NAME[sync_mode]) + time = tbase.extract_field_value(event, it.TIMESTAMP[sync_mode]) + + ht = self.transformers['nova.host'] expected_neighbor = ht.create_placeholder_vertex(host_name, time) self.assertEqual(expected_neighbor, h_neighbor.vertex) @@ -237,9 +241,10 @@ class NovaInstanceTransformerTest(base.BaseTest): ) instance_events = mock_sync.generate_random_events_list(spec_list) + instance_transformer = InstanceTransformer(self.transformers) for event in instance_events: # Test action - observed_key = InstanceTransformer().extract_key(event) + observed_key = instance_transformer.extract_key(event) # Test assertions observed_key_fields = observed_key.split( @@ -247,18 +252,18 @@ class NovaInstanceTransformerTest(base.BaseTest): self.assertEqual(EntityTypes.RESOURCE, observed_key_fields[0]) self.assertEqual( - nova_transformers.INSTANCE_TYPE, + InstanceTransformer.INSTANCE_TYPE, observed_key_fields[1] ) instance_id = tbase.extract_field_value( event, - InstanceTransformer().INSTANCE_ID[event['sync_mode']] + instance_transformer.INSTANCE_ID[event['sync_mode']] ) self.assertEqual(instance_id, observed_key_fields[2]) - key_values = InstanceTransformer()._key_values([instance_id]) + key_values = instance_transformer._key_values([instance_id]) expected_key = tbase.build_key(key_values) self.assertEqual(expected_key, observed_key) @@ -270,8 +275,9 @@ class NovaInstanceTransformerTest(base.BaseTest): instance_id = '456' expected_key = 'RESOURCE:nova.instance:%s' % instance_id + instance_transformer = InstanceTransformer(self.transformers) # Test action - key_fields = InstanceTransformer()._key_values([instance_id]) + key_fields = instance_transformer._key_values([instance_id]) # Test assertions observed_key = tbase.build_key(key_fields) @@ -286,10 +292,11 @@ class NovaInstanceTransformerTest(base.BaseTest): time = datetime.datetime.utcnow() # Test action - neighbor = InstanceTransformer().create_host_neighbor( + neighbor = InstanceTransformer(self.transformers).create_host_neighbor( vertex_id, host_name, - time + time, + self.transformers['nova.host'] ) # Test assertions diff --git a/vitrage/tests/unit/transformers/test_nova_zone_transformer.py b/vitrage/tests/unit/transformers/test_nova_zone_transformer.py index bfe036dd6..748453cca 100644 --- a/vitrage/tests/unit/transformers/test_nova_zone_transformer.py +++ b/vitrage/tests/unit/transformers/test_nova_zone_transformer.py @@ -20,8 +20,8 @@ from vitrage.common.constants import EntityTypes from vitrage.common.constants import VertexProperties from vitrage.entity_graph.transformer import base as tbase from vitrage.entity_graph.transformer.base import TransformerBase -from vitrage.entity_graph.transformer import nova_transformers -from vitrage.entity_graph.transformer.nova_transformers import ZoneTransformer +from vitrage.entity_graph.transformer.host_transformer import HostTransformer +from vitrage.entity_graph.transformer.zone_transformer import ZoneTransformer from vitrage.tests.mocks import mock_syncronizer as mock_sync from vitrage.tests.unit import base @@ -30,6 +30,13 @@ LOG = logging.getLogger(__name__) class NovaZoneTransformerTest(base.BaseTest): + def setUp(self): + super(NovaZoneTransformerTest, self).setUp() + + self.transformers = {} + host_transformer = HostTransformer(self.transformers) + self.transformers['nova.host'] = host_transformer + def test_create_placeholder_vertex(self): LOG.debug('Zone transformer test: create placeholder vertex') @@ -37,9 +44,10 @@ class NovaZoneTransformerTest(base.BaseTest): # Test setup zone_name = 'zone123' timestamp = datetime.datetime.utcnow() + zone_transformer = ZoneTransformer(self.transformers) # Test action - placeholder = ZoneTransformer().create_placeholder_vertex( + placeholder = zone_transformer.create_placeholder_vertex( zone_name, timestamp ) @@ -47,14 +55,16 @@ class NovaZoneTransformerTest(base.BaseTest): # Test assertions observed_id_values = placeholder.vertex_id.split( TransformerBase.KEY_SEPARATOR) - expected_id_values = ZoneTransformer()._key_values([zone_name]) + expected_id_values = ZoneTransformer(self.transformers)._key_values( + [zone_name] + ) self.assertEqual(observed_id_values, expected_id_values) observed_time = placeholder.get(VertexProperties.UPDATE_TIMESTAMP) self.assertEqual(observed_time, timestamp) observed_subtype = placeholder.get(VertexProperties.TYPE) - self.assertEqual(observed_subtype, nova_transformers.ZONE_TYPE) + self.assertEqual(observed_subtype, zone_transformer.ZONE_TYPE) observed_entity_id = placeholder.get(VertexProperties.ID) self.assertEqual(observed_entity_id, zone_name) @@ -70,14 +80,15 @@ class NovaZoneTransformerTest(base.BaseTest): # Test setup zone_name = 'zone123' + zone_transformer = ZoneTransformer(self.transformers) # Test action - observed_key_fields = ZoneTransformer()._key_values([zone_name]) + observed_key_fields = zone_transformer._key_values([zone_name]) # Test assertions self.assertEqual(EntityTypes.RESOURCE, observed_key_fields[0]) self.assertEqual( - nova_transformers.ZONE_TYPE, + ZoneTransformer(self.transformers).ZONE_TYPE, observed_key_fields[1] ) self.assertEqual(zone_name, observed_key_fields[2]) @@ -98,7 +109,7 @@ class NovaZoneTransformerTest(base.BaseTest): for event in zone_events: # Test action - wrapper = ZoneTransformer().transform(event) + wrapper = ZoneTransformer(self.transformers).transform(event) # Test assertions vertex = wrapper.vertex @@ -183,15 +194,13 @@ class NovaZoneTransformerTest(base.BaseTest): def _validate_vertex_props(self, vertex, event): - # zt = nova_transformers.ZoneTransformer + zone_transform = ZoneTransformer(self.transformers) sync_mode = event['sync_mode'] extract_value = tbase.extract_field_value - expected_id = extract_value( - event, - ZoneTransformer().ZONE_NAME[sync_mode] - ) + expected_id = extract_value(event, zone_transform.ZONE_NAME[sync_mode]) + observed_id = vertex[VertexProperties.ID] self.assertEqual(expected_id, observed_id) @@ -201,33 +210,33 @@ class NovaZoneTransformerTest(base.BaseTest): ) self.assertEqual( - nova_transformers.ZONE_TYPE, + zone_transform.ZONE_TYPE, vertex[VertexProperties.TYPE] ) expected_timestamp = extract_value( event, - ZoneTransformer().TIMESTAMP[sync_mode] + zone_transform.TIMESTAMP[sync_mode] ) observed_timestamp = vertex[VertexProperties.UPDATE_TIMESTAMP] self.assertEqual(expected_timestamp, observed_timestamp) expected_name = extract_value( event, - ZoneTransformer().ZONE_NAME[sync_mode] + zone_transform.ZONE_NAME[sync_mode] ) observed_name = vertex[VertexProperties.NAME] self.assertEqual(expected_name, observed_name) is_zone_available = extract_value( event, - ZoneTransformer().ZONE_STATE[sync_mode] + zone_transform.ZONE_STATE[sync_mode] ) if is_zone_available: - expected_state = ZoneTransformer.STATE_AVAILABLE + expected_state = zone_transform.STATE_AVAILABLE else: - expected_state = ZoneTransformer.STATE_UNAVAILABLE + expected_state = zone_transform.STATE_UNAVAILABLE observed_state = vertex[VertexProperties.STATE] self.assertEqual(expected_state, observed_state) diff --git a/vitrage/tests/unit/transformers/test_transformer_manager.py b/vitrage/tests/unit/transformers/test_transformer_manager.py index 76f236760..bcade259e 100644 --- a/vitrage/tests/unit/transformers/test_transformer_manager.py +++ b/vitrage/tests/unit/transformers/test_transformer_manager.py @@ -13,27 +13,15 @@ # under the License. from oslo_log import log as logging -from vitrage.entity_graph.transformer.base import TransformerBase -import vitrage.graph.utils as graph_utils +# from vitrage.entity_graph.transformer.transformer_manager import \ +# TransformerManager from vitrage.tests.unit import base LOG = logging.getLogger(__name__) -def create_vertex(entity_id, entity_type, entity_subtype=None): - - """returns placeholder vertex""" - - vertex_id = TransformerBase.KEY_SEPARATOR.join( - [entity_type, entity_subtype, entity_id]) - - return graph_utils.create_vertex( - vertex_id, - entity_id=entity_id, - entity_category=entity_type, - entity_type=entity_subtype - ) - - class TransformerManagerTest(base.BaseTest): - pass + + def test_register_transformer_classes(self): + # manager = TransformerManager() + pass