openstack/vitrage
Code Issues Proposed changes

Cosmetic changes

Browse Source 
Change-Id: If8f1b2da42ccd7851be92c418191bd4a920c2412
This commit is contained in:
Alexey Weyl 2016-04-12 11:45:58 +03:00
parent 4ba74f4689
commit 03fc7d1fe7
28 changed files with 93 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
doc/source/vitrage-api.rst
View File

@ -102,7 +102,7 @@ Response Examples
Get topology
^^^^^^^^^^^^^
Get the topology for the node.
Get the topology for the cluster.
Its possible to filter the edges vertices and depth of the
graph
@ -463,10 +463,10 @@ Response Examples
"category": "RESOURCE",
"is_placeholder": false,
"is_deleted": false,
"name": "openstack.node",
"type": "openstack.node",
"id": "openstack.node",
"vitrage_id": "RESOURCE:openstack.node"
"name": "openstack.cluster",
"type": "openstack.cluster",
"id": "openstack.cluster",
"vitrage_id": "RESOURCE:openstack.cluster"
}
],
"links": [

0
etc/vitrage/datasources_states/cinder.volume.yaml → etc/vitrage/datasources_values/cinder.volume.yaml
View File

0
etc/vitrage/datasources_states/nagios.yaml → etc/vitrage/datasources_values/nagios.yaml
View File

0
etc/vitrage/datasources_states/nova.host.yaml → etc/vitrage/datasources_values/nova.host.yaml
View File

0
etc/vitrage/datasources_states/nova.instance.yaml → etc/vitrage/datasources_values/nova.instance.yaml
View File

0
etc/vitrage/datasources_states/nova.zone.yaml → etc/vitrage/datasources_values/nova.zone.yaml
View File

0
etc/vitrage/datasources_states/openstack.node.yaml → etc/vitrage/datasources_values/openstack.node.yaml
View File

2
etc/vitrage/datasources_states/static_physical.yaml → etc/vitrage/datasources_values/static_physical.yaml
View File

@ -3,4 +3,4 @@ values:
- normalized value:
name: UNRECOGNIZED
priority: 10
original values:
original values:

0
etc/vitrage/datasources_states/switch.yaml → etc/vitrage/datasources_values/switch.yaml
View File

0
etc/vitrage/datasources_states/vitrage.yaml → etc/vitrage/datasources_values/vitrage.yaml
View File

8
etc/vitrage/graph.sample.json
View File

@ -273,10 +273,10 @@
"category": "RESOURCE",
"is_placeholder": false,
"is_deleted": false,
"name": "openstack.node",
"type": "openstack.node",
"id": "openstack.node",
"vitrage_id": "RESOURCE:openstack.node",
"name": "openstack.cluster",
"type": "openstack.cluster",
"id": "openstack.cluster",
"vitrage_id": "RESOURCE:openstack.cluster",
"state": "available",
"aggregated_state": "RUNNING"
}

4
vitrage/api/controllers/rest.py
View File

@ -20,7 +20,7 @@ import pecan as pecan
from pecan import abort
from pecan import rest
from vitrage.datasources import OPENSTACK_NODE
from vitrage.datasources import OPENSTACK_CLUSTER
LOG = log.getLogger(__name__)
@ -28,7 +28,7 @@ LOG = log.getLogger(__name__)
class RootRestController(rest.RestController):
@staticmethod
def as_tree(graph, root=OPENSTACK_NODE, reverse=False):
def as_tree(graph, root=OPENSTACK_CLUSTER, reverse=False):
linked_graph = json_graph.node_link_graph(graph)
if reverse:
linked_graph = linked_graph.reverse()

4
vitrage/cmd/graph.py
View File

@ -20,7 +20,7 @@ from oslo_service import service as os_service
from vitrage.common.constants import EntityCategory
from vitrage.datasources import launcher as datasource_launcher
from vitrage.datasources import OPENSTACK_NODE
from vitrage.datasources import OPENSTACK_CLUSTER
from vitrage.entity_graph.api_handler import service as api_handler_svc
from vitrage.entity_graph.consistency import service as consistency_svc
from vitrage.entity_graph.initialization_status import InitializationStatus
@ -65,7 +65,7 @@ def init():
event_queue = multiprocessing.Queue()
e_graph = entity_graph.EntityGraph(
'Entity Graph',
'%s:%s' % (EntityCategory.RESOURCE, OPENSTACK_NODE))
'%s:%s' % (EntityCategory.RESOURCE, OPENSTACK_CLUSTER))
scenario_repo = ScenarioRepository(conf)
evaluator = ScenarioEvaluator(conf, e_graph, scenario_repo, event_queue)
initialization_status = InitializationStatus()

2
vitrage/datasources/__init__.py
View File

@ -23,7 +23,7 @@ from vitrage.datasources.nova.instance import NOVA_INSTANCE_DATASOURCE
from vitrage.datasources.nova.zone import NOVA_ZONE_DATASOURCE
from vitrage.datasources.static_physical import STATIC_PHYSICAL_DATASOURCE
OPENSTACK_NODE = 'openstack.node'
OPENSTACK_CLUSTER = 'openstack.cluster'
# Register options for the service
OPTS = [

10
vitrage/datasources/nova/zone/transformer.py
View File

@ -76,7 +76,7 @@ class ZoneTransformer(ResourceTransformerBase):
def _create_neighbors(self, entity_event):
zone_vertex_id = self._create_entity_key(entity_event)
neighbors = [self._create_node_neighbor(zone_vertex_id)]
neighbors = [self._create_cluster_neighbor(zone_vertex_id)]
hosts = extract_field_value(entity_event, 'hosts')
host_transformer = self.transformers[NOVA_HOST_DATASOURCE]
@ -107,15 +107,15 @@ class ZoneTransformer(ResourceTransformerBase):
return neighbors
@staticmethod
def _create_node_neighbor(zone_vertex_id):
def _create_cluster_neighbor(zone_vertex_id):
node_vertex = tbase.create_node_placeholder_vertex()
cluster_vertex = tbase.create_cluster_placeholder_vertex()
relation_edge = graph_utils.create_edge(
source_id=node_vertex.vertex_id,
source_id=cluster_vertex.vertex_id,
target_id=zone_vertex_id,
relationship_type=EdgeLabels.CONTAINS)
return tbase.Neighbor(node_vertex, relation_edge)
return tbase.Neighbor(cluster_vertex, relation_edge)
def _create_host_neighbor(self, zone_id, host_name,
host_state, sample_timestamp):

12
vitrage/datasources/transformer_base.py
View File

@ -25,7 +25,7 @@ from vitrage.common.constants import DatasourceProperties as DSProps
from vitrage.common.constants import EventAction
from vitrage.common.constants import SyncMode
from vitrage.common.exception import VitrageTransformerError
from vitrage.datasources import OPENSTACK_NODE
from vitrage.datasources import OPENSTACK_CLUSTER
import vitrage.graph.utils as graph_utils
LOG = logging.getLogger(__name__)
@ -55,19 +55,19 @@ def build_key(key_values):
return TransformerBase.KEY_SEPARATOR.join(map(str, key_values))
def create_node_placeholder_vertex():
def create_cluster_placeholder_vertex():
key = build_key([cons.EntityCategory.RESOURCE,
OPENSTACK_NODE])
OPENSTACK_CLUSTER])
metadata = {
cons.VertexProperties.NAME: OPENSTACK_NODE
cons.VertexProperties.NAME: OPENSTACK_CLUSTER
}
return graph_utils.create_vertex(
key,
entity_id=OPENSTACK_NODE,
entity_id=OPENSTACK_CLUSTER,
entity_category=cons.EntityCategory.RESOURCE,
entity_type=OPENSTACK_NODE,
entity_type=OPENSTACK_CLUSTER,
entity_state=AVAILABLE,
metadata=metadata
)

4
vitrage/entity_graph/api_handler/entity_graph_api.py
View File

@ -22,7 +22,7 @@ from vitrage.common.constants import VertexProperties as VProps
from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE
from vitrage.datasources.nova.instance import NOVA_INSTANCE_DATASOURCE
from vitrage.datasources.nova.zone import NOVA_ZONE_DATASOURCE
from vitrage.datasources import OPENSTACK_NODE
from vitrage.datasources import OPENSTACK_CLUSTER
from vitrage.graph import create_algorithm
from vitrage.graph import Direction
@ -36,7 +36,7 @@ TREE_TOPOLOGY_QUERY = {
{'==': {VProps.IS_PLACEHOLDER: False}},
{
'or': [
{'==': {VProps.TYPE: OPENSTACK_NODE}},
{'==': {VProps.TYPE: OPENSTACK_CLUSTER}},
{'==': {VProps.TYPE: NOVA_INSTANCE_DATASOURCE}},
{'==': {VProps.TYPE: NOVA_HOST_DATASOURCE}},
{'==': {VProps.TYPE: NOVA_ZONE_DATASOURCE}}

4
vitrage/entity_graph/consistency/consistency_enforcer.py
View File

@ -20,7 +20,7 @@ from oslo_log import log
from vitrage.common.constants import EntityCategory
from vitrage.common.constants import VertexProperties as VProps
from vitrage.common.datetime_utils import utcnow
from vitrage.datasources import OPENSTACK_NODE
from vitrage.datasources import OPENSTACK_CLUSTER
from vitrage.evaluator.actions.evaluator_event_transformer import VITRAGE_TYPE
LOG = log.getLogger(__name__)
@ -152,7 +152,7 @@ class ConsistencyEnforcer(object):
return filter(
lambda ver:
not (ver[VProps.CATEGORY] == EntityCategory.RESOURCE and
ver[VProps.TYPE] == OPENSTACK_NODE), vertices)
ver[VProps.TYPE] == OPENSTACK_CLUSTER), vertices)
def _wait_for_action(self, function):
count_retries = 0

3
vitrage/tests/mocks/mock_transformer.py
View File

@ -116,7 +116,8 @@ def simple_zone_generators(zone_num, snapshot_events=0, snap_vals=None):
:return: generators for vm_num vms as specified
"""
mapping = [('zone-{0}'.format(ind), 'node-0') for ind in range(zone_num)]
mapping = [('zone-{0}'.format(ind), 'cluster-0')
for ind in range(zone_num)]
test_entity_spec_list = [
{tg.DYNAMIC_INFO_FKEY: tg.TRANS_ZONE_SNAPSHOT_D,

4
vitrage/tests/mocks/trace_generator.py
View File

@ -450,12 +450,12 @@ def _get_trans_zone_snapshot_values(spec):
:rtype: list
"""
zone_node_mapping = spec[MAPPING_KEY]
zone_cluster_mapping = spec[MAPPING_KEY]
static_info_re = None
if spec[STATIC_INFO_FKEY] is not None:
static_info_re = utils.load_specs(spec[STATIC_INFO_FKEY])
static_values = []
for zone_name, node_name in zone_node_mapping:
for zone_name, cluster_name in zone_cluster_mapping:
mapping = {'name': zone_name,
'id': zone_name}
static_values.append(combine_data(

24
vitrage/tests/unit/datasources/nova/test_nova_zone_transformer.py
View File

@ -24,7 +24,7 @@ from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE
from vitrage.datasources.nova.host.transformer import HostTransformer
from vitrage.datasources.nova.zone import NOVA_ZONE_DATASOURCE
from vitrage.datasources.nova.zone.transformer import ZoneTransformer
from vitrage.datasources import OPENSTACK_NODE
from vitrage.datasources import OPENSTACK_CLUSTER
from vitrage.datasources import transformer_base as tbase
from vitrage.datasources.transformer_base import TransformerBase
from vitrage.tests import base
@ -130,14 +130,14 @@ class NovaZoneTransformerTest(base.BaseTest):
def _validate_neighbors(self, neighbors, zone_vertex_id, event):
node_neighbors_counter = 0
cluster_neighbors_counter = 0
for neighbor in neighbors:
vertex_type = neighbor.vertex.get(VertexProperties.TYPE)
if OPENSTACK_NODE == vertex_type:
node_neighbors_counter += 1
self._validate_node_neighbor(neighbor, zone_vertex_id)
if OPENSTACK_CLUSTER == vertex_type:
cluster_neighbors_counter += 1
self._validate_cluster_neighbor(neighbor, zone_vertex_id)
else:
hosts = tbase.extract_field_value(event, 'hosts')
self._validate_host_neighbor(neighbor,
@ -146,8 +146,8 @@ class NovaZoneTransformerTest(base.BaseTest):
event[DSProps.SYNC_MODE])
self.assertEqual(1,
node_neighbors_counter,
'Zone can belongs to only one Node')
cluster_neighbors_counter,
'Zone can belongs to only one Cluster')
def _validate_host_neighbor(self,
host_neighbor,
@ -191,14 +191,14 @@ class NovaZoneTransformerTest(base.BaseTest):
self.assertEqual(edge.source_id, zone_vertex_id)
self.assertEqual(edge.label, EdgeLabels.CONTAINS)
def _validate_node_neighbor(self, node_neighbor, zone_vertex_id):
def _validate_cluster_neighbor(self, cluster_neighbor, zone_vertex_id):
expected_node_neighbor = tbase.create_node_placeholder_vertex()
self.assertEqual(expected_node_neighbor, node_neighbor.vertex)
expected_cluster_neighbor = tbase.create_cluster_placeholder_vertex()
self.assertEqual(expected_cluster_neighbor, cluster_neighbor.vertex)
# Validate neighbor edge
edge = node_neighbor.edge
self.assertEqual(edge.source_id, node_neighbor.vertex.vertex_id)
edge = cluster_neighbor.edge
self.assertEqual(edge.source_id, cluster_neighbor.vertex.vertex_id)
self.assertEqual(edge.target_id, zone_vertex_id)
self.assertEqual(edge.label, EdgeLabels.CONTAINS)

2
vitrage/tests/unit/datasources/static_physical/test_static_physical_transformer.py
View File

@ -144,7 +144,7 @@ class TestStaticPhysicalTransformer(base.BaseTest):
self.assertEqual(5,
host_counter,
'Zone can belongs to only one Node')
'Zone can belongs to only one Cluster')
def _validate_host_neighbor(self,
host_neighbor,

6
vitrage/tests/unit/entity_graph/base.py
View File

@ -55,7 +55,7 @@ class TestEntityGraphUnitBase(base.BaseTest):
min=1)
]
NUM_NODES = 1
NUM_CLUSTERS = 1
NUM_ZONES = 2
NUM_HOSTS = 4
NUM_INSTANCES = 16
@ -147,9 +147,9 @@ class TestEntityGraphUnitBase(base.BaseTest):
)
def _num_total_expected_vertices(self):
return self.NUM_NODES + self.NUM_ZONES + self.NUM_HOSTS + \
return self.NUM_CLUSTERS + self.NUM_ZONES + self.NUM_HOSTS + \
self.NUM_INSTANCES
def _num_total_expected_edges(self):
return self.NUM_NODES + self.NUM_ZONES + self.NUM_HOSTS + \
return self.NUM_CLUSTERS + self.NUM_ZONES + self.NUM_HOSTS + \
self.NUM_INSTANCES - 1

12
vitrage/tests/unit/graph/base.py
View File

@ -28,7 +28,7 @@ from vitrage.common.constants import EdgeLabels as ELabel
from vitrage.common.constants import EntityCategory
from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE
from vitrage.datasources.nova.instance import NOVA_INSTANCE_DATASOURCE
from vitrage.datasources import OPENSTACK_NODE
from vitrage.datasources import OPENSTACK_CLUSTER
from vitrage.datasources.static_physical import SWITCH
from vitrage.graph import create_graph
from vitrage.graph import utils as graph_utils
@ -36,7 +36,7 @@ from vitrage.tests import base
LOG = logging.getLogger(__name__)
ENTITY_GRAPH_HOSTS_PER_NODE = 8
ENTITY_GRAPH_HOSTS_PER_CLUSTER = 8
ENTITY_GRAPH_VMS_PER_HOST = 8
ENTITY_GRAPH_ALARMS_PER_HOST = 8
ENTITY_GRAPH_TESTS_PER_HOST = 20
@ -51,9 +51,9 @@ ALARM_ON_HOST = 'ALARM_ON_HOST'
TEST_ON_HOST = 'TEST_ON_HOST'
v_node = graph_utils.create_vertex(
vitrage_id=EntityCategory.RESOURCE + ':' + OPENSTACK_NODE,
vitrage_id=EntityCategory.RESOURCE + ':' + OPENSTACK_CLUSTER,
entity_id='111111111111',
entity_type=OPENSTACK_NODE,
entity_type=OPENSTACK_CLUSTER,
entity_category=RESOURCE)
v_host = graph_utils.create_vertex(
vitrage_id=NOVA_HOST_DATASOURCE + '222222222222',
@ -123,7 +123,7 @@ class GraphTestBase(base.BaseTest):
self.host_test_id = 40000000
self.entity_graph = self._create_entity_graph(
'entity_graph',
num_of_hosts_per_node=ENTITY_GRAPH_HOSTS_PER_NODE,
num_of_hosts_per_node=ENTITY_GRAPH_HOSTS_PER_CLUSTER,
num_of_vms_per_host=ENTITY_GRAPH_VMS_PER_HOST,
num_of_alarms_per_host=ENTITY_GRAPH_ALARMS_PER_HOST,
num_of_alarms_per_vm=ENTITY_GRAPH_ALARMS_PER_VM,
@ -141,7 +141,7 @@ class GraphTestBase(base.BaseTest):
start = time.time()
g = create_graph(name, EntityCategory.RESOURCE + ':' +
OPENSTACK_NODE)
OPENSTACK_CLUSTER)
g.add_vertex(v_node)
g.add_vertex(v_switch)
g.add_edge(e_node_to_switch)

8
vitrage/tests/unit/graph/test_graph.py
View File

@ -372,20 +372,20 @@ class GraphTest(GraphTestBase):
'get_vertices __len__ all vertices')
node_vertices = g.get_vertices(
vertex_attr_filter={VProps.TYPE: OPENSTACK_NODE})
vertex_attr_filter={VProps.TYPE: OPENSTACK_CLUSTER})
self.assertEqual(1, len(node_vertices),
'get_vertices __len__ node vertices')
found_vertex = node_vertices.pop()
self.assertEqual(OPENSTACK_NODE, found_vertex[VProps.TYPE],
self.assertEqual(OPENSTACK_CLUSTER, found_vertex[VProps.TYPE],
'get_vertices check node vertex')
node_vertices = g.get_vertices(
vertex_attr_filter={VProps.TYPE: OPENSTACK_NODE,
vertex_attr_filter={VProps.TYPE: OPENSTACK_CLUSTER,
VProps.CATEGORY: RESOURCE})
self.assertEqual(1, len(node_vertices),
'get_vertices __len__ node vertices')
found_vertex = node_vertices.pop()
self.assertEqual(OPENSTACK_NODE, found_vertex[VProps.TYPE],
self.assertEqual(OPENSTACK_CLUSTER, found_vertex[VProps.TYPE],
'get_vertices check node vertex')
def _check_callback_result(self, result, msg, exp_prev, exp_curr):

38
vitrage/tests/unit/graph/test_graph_algo.py
View File

@ -28,22 +28,22 @@ class GraphAlgorithmTest(GraphTestBase):
def test_graph_query_vertices(self):
ga = create_algorithm(self.entity_graph)
query = {'==': {VProps.TYPE: OPENSTACK_NODE}}
query = {'==': {VProps.TYPE: OPENSTACK_CLUSTER}}
subgraph = ga.graph_query_vertices(query)
self.assertEqual(
1, # For NODE
1, # For Cluster
subgraph.num_vertices(), 'num of vertex node')
query = {
'or': [
{'==': {VProps.TYPE: NOVA_HOST_DATASOURCE}},
{'==': {VProps.TYPE: OPENSTACK_NODE}}
{'==': {VProps.TYPE: OPENSTACK_CLUSTER}}
]
}
subgraph = ga.graph_query_vertices(query)
self.assertEqual(
ENTITY_GRAPH_HOSTS_PER_NODE,
ENTITY_GRAPH_HOSTS_PER_CLUSTER,
subgraph.num_edges(), 'num of edges Host <-- NODE')
query = {
@ -51,15 +51,15 @@ class GraphAlgorithmTest(GraphTestBase):
{'==': {VProps.TYPE: NOVA_INSTANCE_DATASOURCE}},
{'==': {VProps.CATEGORY: ALARM}},
{'==': {VProps.TYPE: NOVA_HOST_DATASOURCE}},
{'==': {VProps.TYPE: OPENSTACK_NODE}}
{'==': {VProps.TYPE: OPENSTACK_CLUSTER}}
]
}
subgraph = ga.graph_query_vertices(query)
self.assertEqual(
ENTITY_GRAPH_HOSTS_PER_NODE +
ENTITY_GRAPH_HOSTS_PER_NODE * ENTITY_GRAPH_ALARMS_PER_HOST +
ENTITY_GRAPH_HOSTS_PER_NODE * ENTITY_GRAPH_VMS_PER_HOST +
ENTITY_GRAPH_HOSTS_PER_NODE * ENTITY_GRAPH_VMS_PER_HOST *
ENTITY_GRAPH_HOSTS_PER_CLUSTER +
ENTITY_GRAPH_HOSTS_PER_CLUSTER * ENTITY_GRAPH_ALARMS_PER_HOST +
ENTITY_GRAPH_HOSTS_PER_CLUSTER * ENTITY_GRAPH_VMS_PER_HOST +
ENTITY_GRAPH_HOSTS_PER_CLUSTER * ENTITY_GRAPH_VMS_PER_HOST *
ENTITY_GRAPH_ALARMS_PER_VM,
subgraph.num_edges(), 'num of BOTH edges Host (depth 1)')
@ -73,7 +73,7 @@ class GraphAlgorithmTest(GraphTestBase):
query_dict=query, root_id=first_host_id, depth=1)
self.assertEqual(
1 + # For tye host
1 + # For NODE
1 + # For Cluster
1 + # For SWITCH
ENTITY_GRAPH_ALARMS_PER_HOST +
ENTITY_GRAPH_TESTS_PER_HOST +
@ -94,8 +94,8 @@ class GraphAlgorithmTest(GraphTestBase):
subgraph = ga.graph_query_vertices(root_id=first_host_id, depth=2)
self.assertEqual(
1 + # Node to switch
ENTITY_GRAPH_HOSTS_PER_NODE * 2 +
1 + # Cluster to switch
ENTITY_GRAPH_HOSTS_PER_CLUSTER * 2 +
ENTITY_GRAPH_ALARMS_PER_HOST +
ENTITY_GRAPH_TESTS_PER_HOST +
ENTITY_GRAPH_VMS_PER_HOST +
@ -118,15 +118,15 @@ class GraphAlgorithmTest(GraphTestBase):
}
subgraph = ga.graph_query_vertices(query_dict=query, depth=3)
self.assertEqual(
1 + # Node to switch
ENTITY_GRAPH_HOSTS_PER_NODE * 2 +
ENTITY_GRAPH_HOSTS_PER_NODE * ENTITY_GRAPH_TESTS_PER_HOST +
ENTITY_GRAPH_HOSTS_PER_NODE * ENTITY_GRAPH_VMS_PER_HOST,
1 + # Cluster to switch
ENTITY_GRAPH_HOSTS_PER_CLUSTER * 2 +
ENTITY_GRAPH_HOSTS_PER_CLUSTER * ENTITY_GRAPH_TESTS_PER_HOST +
ENTITY_GRAPH_HOSTS_PER_CLUSTER * ENTITY_GRAPH_VMS_PER_HOST,
subgraph.num_edges(), 'num of edges Node (depth 3)')
query = {
'or': [
{'==': {VProps.TYPE: OPENSTACK_NODE}},
{'==': {VProps.TYPE: OPENSTACK_CLUSTER}},
{'==': {VProps.CATEGORY: ALARM}},
]
}
@ -171,10 +171,10 @@ class GraphAlgorithmTest(GraphTestBase):
t_v_node = graph_utils.create_vertex(
vitrage_id='6',
entity_category=RESOURCE,
entity_type=OPENSTACK_NODE)
entity_type=OPENSTACK_CLUSTER)
t_v_node_not_in_graph = graph_utils.create_vertex(
vitrage_id='7', entity_category=RESOURCE,
entity_type=OPENSTACK_NODE + ' not in graph')
entity_type=OPENSTACK_CLUSTER + ' not in graph')
e_alarm_on_host = graph_utils.create_edge(
t_v_host_alarm.vertex_id, t_v_host.vertex_id, ELabel.ON)

14
vitrage_tempest_tests/tests/api/topology/base.py
View File

@ -27,7 +27,7 @@ from vitrage.datasources import CINDER_VOLUME_DATASOURCE
from vitrage.datasources import NOVA_HOST_DATASOURCE
from vitrage.datasources import NOVA_INSTANCE_DATASOURCE
from vitrage.datasources import NOVA_ZONE_DATASOURCE
from vitrage.datasources import OPENSTACK_NODE
from vitrage.datasources import OPENSTACK_CLUSTER
from vitrage.datasources.static_physical import SWITCH
from vitrage.graph import Edge
from vitrage.graph import NXGraph
@ -112,16 +112,16 @@ class BaseTopologyTest(test.BaseTestCase):
if os.path.exists(path):
os.remove(path)
def _entities_validation_data(self, node_entities=1, node_edges=1,
def _entities_validation_data(self, cluster_entities=1, cluster_edges=1,
zone_entities=1, zone_edges=2,
host_entities=1, host_edges=1,
instance_entities=0, instance_edges=0,
volume_entities=0, volume_edges=0,
switch_entities=0, switch_edges=0):
return [
{VProps.TYPE: OPENSTACK_NODE,
self.NUM_ENTITIES_PER_TYPE: node_entities,
self.NUM_EDGES_PER_TYPE: node_edges},
{VProps.TYPE: OPENSTACK_CLUSTER,
self.NUM_ENTITIES_PER_TYPE: cluster_entities,
self.NUM_EDGES_PER_TYPE: cluster_edges},
{VProps.TYPE: NOVA_ZONE_DATASOURCE,
self.NUM_ENTITIES_PER_TYPE: zone_entities,
self.NUM_EDGES_PER_TYPE: zone_edges},
@ -284,7 +284,7 @@ class BaseTopologyTest(test.BaseTestCase):
return '{"and": [{"==": {"category": "RESOURCE"}},' \
'{"==": {"is_deleted": false}},' \
'{"==": {"is_placeholder": false}},' \
'{"or": [{"==": {"type": "openstack.node"}},' \
'{"or": [{"==": {"type": "openstack.cluster"}},' \
'{"==": {"type": "nova.instance"}},' \
'{"==": {"type": "nova.host"}},' \
'{"==": {"type": "nova.zone"}}]}]}'
@ -294,6 +294,6 @@ class BaseTopologyTest(test.BaseTestCase):
return '{"and": [{"==": {"category": "RESOURCE"}},' \
'{"==": {"is_deleted": false}},' \
'{"==": {"is_placeholder": false}},' \
'{"or": [{"==": {"type": "openstack.node"}},' \
'{"or": [{"==": {"type": "openstack.cluster"}},' \
'{"==": {"type": "nova.host"}},' \
'{"==": {"type": "nova.zone"}}]}]}'

14
vitrage_tempest_tests/tests/api/topology/test_topology.py
View File

@ -23,7 +23,7 @@ from vitrage.datasources import CINDER_VOLUME_DATASOURCE
from vitrage.datasources import NOVA_HOST_DATASOURCE
from vitrage.datasources import NOVA_INSTANCE_DATASOURCE
from vitrage.datasources import NOVA_ZONE_DATASOURCE
from vitrage.datasources import OPENSTACK_NODE
from vitrage.datasources import OPENSTACK_CLUSTER
from vitrage.graph import Edge
from vitrage.graph import NXGraph
from vitrage.graph import Vertex
@ -148,15 +148,15 @@ class TestTopology(BaseTopologyTest):
# entity graph processor
time.sleep(5)
def _entities_validation_data(self, node_entities=1, node_edges=1,
def _entities_validation_data(self, cluster_entities=1, cluster_edges=1,
zone_entities=1, zone_edges=2,
host_entities=1, host_edges=1,
instance_entities=0, instance_edges=0,
volume_entities=0, volume_edges=0):
return [
{VProps.TYPE: OPENSTACK_NODE,
self.NUM_ENTITIES_PER_TYPE: node_entities,
self.NUM_EDGES_PER_TYPE: node_edges},
{VProps.TYPE: OPENSTACK_CLUSTER,
self.NUM_ENTITIES_PER_TYPE: cluster_entities,
self.NUM_EDGES_PER_TYPE: cluster_edges},
{VProps.TYPE: NOVA_ZONE_DATASOURCE,
self.NUM_ENTITIES_PER_TYPE: zone_entities,
self.NUM_EDGES_PER_TYPE: zone_edges},
@ -316,7 +316,7 @@ class TestTopology(BaseTopologyTest):
return '{"and": [{"==": {"category": "RESOURCE"}},' \
'{"==": {"is_deleted": false}},' \
'{"==": {"is_placeholder": false}},' \
'{"or": [{"==": {"type": "openstack.node"}},' \
'{"or": [{"==": {"type": "openstack.cluster"}},' \
'{"==": {"type": "nova.instance"}},' \
'{"==": {"type": "nova.host"}},' \
'{"==": {"type": "nova.zone"}}]}]}'
@ -326,6 +326,6 @@ class TestTopology(BaseTopologyTest):
return '{"and": [{"==": {"category": "RESOURCE"}},' \
'{"==": {"is_deleted": false}},' \
'{"==": {"is_placeholder": false}},' \
'{"or": [{"==": {"type": "openstack.node"}},' \
'{"or": [{"==": {"type": "openstack.cluster"}},' \
'{"==": {"type": "nova.host"}},' \
'{"==": {"type": "nova.zone"}}]}]}'