From 3b1de001ecddf66535a1b6067afa4c55397d58a0 Mon Sep 17 00:00:00 2001 From: Alexey Weyl Date: Tue, 6 Jun 2017 07:12:57 +0000 Subject: [PATCH] Vertex Properties refactoring Rename vitrage properties to start with the vitrage prefix so it will be easier work with and to recognize. Change-Id: Ia8afaa1a13897927984a9c8d8d9b85343ef69c01 --- doc/source/add-new-datasource.rst | 2 +- doc/source/alarm-severity-config.rst | 2 +- doc/source/resource-state-config.rst | 2 +- .../template_validation_status_code.rst | 4 +- doc/source/templates-loading.rst | 10 +- doc/source/vitrage-api.rst | 282 +++++----- doc/source/vitrage-template-format.rst | 40 +- doc/source/zabbix_vitrage.rst | 4 +- vitrage/api_handler/apis/alarm.py | 8 +- vitrage/api_handler/apis/base.py | 60 +-- vitrage/api_handler/apis/resource.py | 2 +- vitrage/api_handler/apis/topology.py | 10 +- vitrage/common/constants.py | 25 +- vitrage/datasources/alarm_driver_base.py | 8 +- vitrage/datasources/aodh/driver.py | 2 +- vitrage/datasources/aodh/transformer.py | 24 +- .../datasources/cinder/volume/transformer.py | 10 +- vitrage/datasources/collectd/driver.py | 2 +- vitrage/datasources/collectd/transformer.py | 10 +- .../datasources/consistency/transformer.py | 4 +- vitrage/datasources/doctor/driver.py | 2 +- vitrage/datasources/doctor/transformer.py | 8 +- vitrage/datasources/heat/stack/transformer.py | 10 +- vitrage/datasources/nagios/config.py | 2 +- vitrage/datasources/nagios/driver.py | 2 +- vitrage/datasources/nagios/transformer.py | 15 +- .../neutron/network/transformer.py | 10 +- .../datasources/neutron/port/transformer.py | 10 +- vitrage/datasources/nova/host/transformer.py | 15 +- .../datasources/nova/instance/transformer.py | 12 +- vitrage/datasources/nova/zone/transformer.py | 19 +- vitrage/datasources/static/driver.py | 10 +- vitrage/datasources/static/transformer.py | 26 +- vitrage/datasources/static_physical/driver.py | 6 +- .../static_physical/transformer.py | 21 +- vitrage/datasources/transformer_base.py | 48 +- vitrage/datasources/zabbix/driver.py | 2 +- vitrage/datasources/zabbix/transformer.py | 15 +- .../consistency/consistency_enforcer.py | 37 +- .../entity_graph/mappings/alarm_handler.py | 4 +- .../mappings/datasource_info_mapper.py | 48 +- .../entity_graph/mappings/resource_handler.py | 9 +- vitrage/entity_graph/processor/notifier.py | 12 +- vitrage/entity_graph/processor/processor.py | 27 +- .../entity_graph/processor/processor_utils.py | 42 +- vitrage/entity_graph/transformer_manager.py | 5 +- vitrage/evaluator/actions/action_executor.py | 7 +- .../actions/evaluator_event_transformer.py | 32 +- vitrage/evaluator/actions/priority_tools.py | 6 +- .../evaluator/actions/recipes/raise_alarm.py | 2 +- vitrage/evaluator/equivalence_data.py | 5 +- vitrage/evaluator/scenario_evaluator.py | 12 +- vitrage/evaluator/template_data.py | 56 +- .../template_content_validator.py | 6 +- .../graph/algo_driver/networkx_algorithm.py | 3 +- vitrage/graph/query.py | 8 +- vitrage/graph/utils.py | 48 +- .../notifier/plugins/nova/nova_notifier.py | 2 +- vitrage/notifier/plugins/snmp/snmp_sender.py | 2 +- .../tests/functional/api_handler/test_apis.py | 73 +-- .../functional/datasources/aodh/test_aodh.py | 6 +- vitrage/tests/functional/datasources/base.py | 6 +- .../datasources/cinder/test_cinder_volume.py | 6 +- .../datasources/heat/test_heat_stack.py | 12 +- .../datasources/nagios/test_nagios.py | 6 +- .../static_physical/test_static_physical.py | 6 +- .../consistency/test_consistency.py | 45 +- .../states/test_datasource_info_mapper.py | 11 +- .../evaluator/test_action_executor.py | 67 ++- .../evaluator/test_scenario_evaluator.py | 494 ++++++++++-------- vitrage/tests/mocks/mock_driver.py | 5 +- .../driver/driver_host_snapshot_dynamic.json | 2 +- .../driver/driver_inst_snapshot_dynamic.json | 2 +- .../driver_static_snapshot_dynamic.json | 2 +- .../driver/driver_zone_snapshot_dynamic.json | 2 +- .../transformer_aodh_snapshot_dynamic.json | 14 +- .../transformer_aodh_update_dynamic.json | 14 +- .../oid_tree_with_severity_mapping.yaml | 4 +- .../oid_tree_without_severity_mapping.yaml | 4 +- .../aodh/aodh_transformer_base_test.py | 23 +- .../cinder/test_cinder_volume_transformer.py | 39 +- .../test_consistency_transformer.py | 5 +- .../heat/test_heat_stack_transformer.py | 39 +- .../nagios/test_nagios_transformer.py | 21 +- .../nova/test_nova_host_transformer.py | 38 +- .../nova/test_nova_instance_transformer.py | 40 +- .../nova/test_nova_zone_transformer.py | 52 +- .../static/test_static_transformer.py | 32 +- .../test_static_physical_driver.py | 22 +- .../test_static_physical_transformer.py | 37 +- .../test_alarm_transformer_base.py | 12 +- .../unit/datasources/test_transformer_base.py | 4 +- .../zabbix/test_zabbix_transformer.py | 21 +- vitrage/tests/unit/entity_graph/base.py | 20 +- .../tests/unit/entity_graph/processor/base.py | 22 +- .../entity_graph/processor/test_processor.py | 72 +-- .../states/test_datasource_info_mapper.py | 139 ++--- .../evaluator/recipes/test_raise_alarm.py | 6 +- .../unit/evaluator/test_equivalence_data.py | 24 +- .../evaluator/test_scenario_repository.py | 9 +- .../unit/evaluator/test_template_data.py | 35 +- .../test_template_syntax_validator.py | 2 +- vitrage/tests/unit/graph/base.py | 32 +- vitrage/tests/unit/graph/test_graph.py | 85 +-- vitrage/tests/unit/graph/test_graph_algo.py | 262 +++++----- .../unit/notifier/snmp_notifier/common.py | 17 +- .../snmp_notifier/test_snmp_notifier.py | 25 +- .../test_snmp_sender_with_severity_map.py | 14 +- .../test_snmp_sender_without_severity_map.py | 8 +- vitrage/tests/unit/notifier/test_notifier.py | 72 +-- .../tests/api/alarms/test_alarms.py | 2 +- vitrage_tempest_tests/tests/api/base.py | 57 +- .../tests/api/event/test_events.py | 6 +- vitrage_tempest_tests/tests/api/rca/base.py | 32 +- .../tests/api/resources/test_resources.py | 8 +- .../tests/api/topology/base.py | 56 +- .../tests/api/topology/test_topology.py | 14 +- 117 files changed, 1768 insertions(+), 1534 deletions(-) diff --git a/doc/source/add-new-datasource.rst b/doc/source/add-new-datasource.rst index fee942a16..783368cdb 100644 --- a/doc/source/add-new-datasource.rst +++ b/doc/source/add-new-datasource.rst @@ -20,7 +20,7 @@ In order to add a new datasource to Vitrage do the following steps: a. Driver and transformer with the path to your driver and transformer classes respectively. - b. ``update_method`` property that describes the type of update mechanism for + b. ``update_method`` property that describes the vitrage_type of update mechanism for this datasource. The options are (string): push, pull or none. c. In addition to those three, you may add any other configuration options you may need for your datasource. diff --git a/doc/source/alarm-severity-config.rst b/doc/source/alarm-severity-config.rst index d531f1f97..df5fbdc27 100644 --- a/doc/source/alarm-severity-config.rst +++ b/doc/source/alarm-severity-config.rst @@ -16,7 +16,7 @@ Since each data-source might represent severity differently, for each data-source we can supply it's own mapping to the aggregated severity supported in Vitrage. This way we can know which severity is more important. In addition we also normalize the severities for the horizon UI (called -``operational_severity``) in order for the UI to know what color to show in +``vitrage_operational_severity``) in order for the UI to know what color to show in Horizon. This page explains how to handle this mapping for a given diff --git a/doc/source/resource-state-config.rst b/doc/source/resource-state-config.rst index a2f5e99b3..cc38dc75d 100644 --- a/doc/source/resource-state-config.rst +++ b/doc/source/resource-state-config.rst @@ -16,7 +16,7 @@ Since each data-source might represent state differently, for each data-source we can supply it's own mapping to the aggregated state supported in Vitrage. This way we can know which state is more important. In addition we also normalize the states for the horizon UI (called -operational_state) in order for the UI to know what color to show in Horizon. +vitrage_operational_state) in order for the UI to know what color to show in Horizon. This page explains how to handle this mapping for a given data-source. diff --git a/doc/source/template_validation_status_code.rst b/doc/source/template_validation_status_code.rst index 837232efa..0d405430f 100644 --- a/doc/source/template_validation_status_code.rst +++ b/doc/source/template_validation_status_code.rst @@ -34,8 +34,8 @@ The following describes all the possible status code and their messages: +------------------+---------------------------------------------------------+-------------------------------+ | 43 | At least one entity must be defined | syntax | +------------------+---------------------------------------------------------+-------------------------------+ -| 45 | Invalid entity category. Category must be from types: | syntax | -| | [entities_categories] | | +| 45 | Invalid entity category. Category must be from | syntax | +| | types: [entities_categories] | | +------------------+---------------------------------------------------------+-------------------------------+ | 46 | Entity field is required | syntax | +------------------+---------------------------------------------------------+-------------------------------+ diff --git a/doc/source/templates-loading.rst b/doc/source/templates-loading.rst index ad03924c6..8e07b47c6 100644 --- a/doc/source/templates-loading.rst +++ b/doc/source/templates-loading.rst @@ -60,13 +60,13 @@ Let's take a basic template as example expected_entities = { 'alarm': Vertex(vertex_id='alarm', - properties={'category': 'ALARM', - 'type': 'nagios', - 'name': 'HOST_HIGH_CPU_LOAD' + properties={'vitrage_category': 'ALARM', + 'vitrage_type': 'nagios', + 'name': 'HOST_HIGH_CPU_LOAD', }), 'resource': Vertex(vertex_id='resource', - properties={'category': 'RESOURCE', - 'type': 'nova.host' + properties={'vitrage_category': 'RESOURCE', + 'vitrage_type': 'nova.host', }) } diff --git a/doc/source/vitrage-api.rst b/doc/source/vitrage-api.rst index bc6debd0f..1460c210a 100644 --- a/doc/source/vitrage-api.rst +++ b/doc/source/vitrage-api.rst @@ -167,19 +167,19 @@ Query example [ "=": { - "type":"host" + "vitrage_type":"host" }, "=": { - "type":"instance" + "vitrage_type":"instance" }, "=": { - "type":"zone" + "vitrage_type":"zone" }, "=": { - "type":"node" + "vitrage_type":"node" } ] } @@ -215,257 +215,257 @@ Response Examples "graph": {}, "nodes": [ { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "vm-8", "update_timestamp": "2015-12-01T12:46:41Z", "state": "ACTIVE", "project_id": "0683517e1e354d2ba25cba6937f44e79", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "20d12a8a-ea9a-89c6-5947-83bea959362e", "vitrage_id": "RESOURCE:nova.instance:20d12a8a-ea9a-89c6-5947-83bea959362e" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "vm-2", "update_timestamp": "2015-12-01T12:46:41Z", "state": "ACTIVE", "project_id": "0683517e1e354d2ba25cba6937f44e79", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "dc35fa2f-4515-1653-ef6b-03b471bb395b", "vitrage_id": "RESOURCE:nova.instance:dc35fa2f-4515-1653-ef6b-03b471bb395b" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "vm-13", "update_timestamp": "2015-12-01T12:46:41Z", "state": "ACTIVE", "project_id": "0683517e1e354d2ba25cba6937f44e79", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "9879cf5a-bdcf-3651-3017-961ed887ec86", "vitrage_id": "RESOURCE:nova.instance:9879cf5a-bdcf-3651-3017-961ed887ec86" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "vm-10", "update_timestamp": "2015-12-01T12:46:41Z", "state": "ACTIVE", "project_id": "0683517e1e354d2ba25cba6937f44e79", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "fe124f4b-9ed7-4591-fcd1-803cf5c33cb1", "vitrage_id": "RESOURCE:nova.instance:fe124f4b-9ed7-4591-fcd1-803cf5c33cb1" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "vm-11", "update_timestamp": "2015-12-01T12:46:41Z", "state": "ACTIVE", "project_id": "0683517e1e354d2ba25cba6937f44e79", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "f2e48a97-7350-061e-12d3-84c6dc3e67c0", "vitrage_id": "RESOURCE:nova.instance:f2e48a97-7350-061e-12d3-84c6dc3e67c0" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "host-2", "update_timestamp": "2015-12-01T12:46:41Z", "state": "available", - "type": "nova.host", + "vitrage_type": "nova.host", "id": "host-2", "vitrage_id": "RESOURCE:nova.host:host-2" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "host-3", "update_timestamp": "2015-12-01T12:46:41Z", "state": "available", - "type": "nova.host", + "vitrage_type": "nova.host", "id": "host-3", "vitrage_id": "RESOURCE:nova.host:host-3" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "host-0", "update_timestamp": "2015-12-01T12:46:41Z", "state": "available", - "type": "nova.host", + "vitrage_type": "nova.host", "id": "host-0", "vitrage_id": "RESOURCE:nova.host:host-0" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "host-1", "update_timestamp": "2015-12-01T12:46:41Z", "state": "available", - "type": "nova.host", + "vitrage_type": "nova.host", "id": "host-1", "vitrage_id": "RESOURCE:nova.host:host-1" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "vm-9", "update_timestamp": "2015-12-01T12:46:41Z", "state": "ACTIVE", "project_id": "0683517e1e354d2ba25cba6937f44e79", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "275097cf-954e-8e24-b185-9514e24b8591", "vitrage_id": "RESOURCE:nova.instance:275097cf-954e-8e24-b185-9514e24b8591" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "vm-1", "update_timestamp": "2015-12-01T12:46:41Z", "state": "ACTIVE", "project_id": "0683517e1e354d2ba25cba6937f44e79", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "a0f0805f-c804-cffe-c25a-1b38f555ed68", "vitrage_id": "RESOURCE:nova.instance:a0f0805f-c804-cffe-c25a-1b38f555ed68" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "vm-14", "update_timestamp": "2015-12-01T12:46:41Z", "state": "ACTIVE", "project_id": "0683517e1e354d2ba25cba6937f44e79", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "56af57d2-34a4-19b1-5106-b613637a11a7", "vitrage_id": "RESOURCE:nova.instance:56af57d2-34a4-19b1-5106-b613637a11a7" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "zone-1", "update_timestamp": "2015-12-01T12:46:41Z", "state": "available", - "type": "nova.zone", + "vitrage_type": "nova.zone", "id": "zone-1", "vitrage_id": "RESOURCE:nova.zone:zone-1" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "vm-3", "update_timestamp": "2015-12-01T12:46:41Z", "state": "ACTIVE", "project_id": "0683517e1e354d2ba25cba6937f44e79", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "16e14c58-d254-2bec-53e4-c766e48810aa", "vitrage_id": "RESOURCE:nova.instance:16e14c58-d254-2bec-53e4-c766e48810aa" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "vm-7", "update_timestamp": "2015-12-01T12:46:41Z", "state": "ACTIVE", "project_id": "0683517e1e354d2ba25cba6937f44e79", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "f35a1e10-74ff-7332-8edf-83cd6ffcb2de", "vitrage_id": "RESOURCE:nova.instance:f35a1e10-74ff-7332-8edf-83cd6ffcb2de" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "vm-4", "update_timestamp": "2015-12-01T12:46:41Z?vitrage_id=all", "state": "ACTIVE", "project_id": "0683517e1e354d2ba25cba6937f44e79", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "ea8a450e-cab1-2272-f431-494b40c5c378", "vitrage_id": "RESOURCE:nova.instance:ea8a450e-cab1-2272-f431-494b40c5c378" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "vm-6", "update_timestamp": "2015-12-01T12:46:41Z", "state": "ACTIVE", "project_id": "0683517e1e354d2ba25cba6937f44e79", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "6e42bdc3-b776-1b2c-2c7d-b7a8bb98f721", "vitrage_id": "RESOURCE:nova.instance:6e42bdc3-b776-1b2c-2c7d-b7a8bb98f721" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "vm-5", "update_timestamp": "2015-12-01T12:46:41Z", "state": "ACTIVE", "project_id": "0683517e1e354d2ba25cba6937f44e79", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "8c951613-c660-87c0-c18b-0fa3293ce8d8", "vitrage_id": "RESOURCE:nova.instance:8c951613-c660-87c0-c18b-0fa3293ce8d8" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "zone-0", "update_timestamp": "2015-12-01T12:46:41Z", "state": "available", - "type": "nova.zone", + "vitrage_type": "nova.zone", "id": "zone-0", "vitrage_id": "RESOURCE:nova.zone:zone-0" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "vm-0", "update_timestamp": "2015-12-01T12:46:41Z", "state": "ACTIVE", "project_id": "0683517e1e354d2ba25cba6937f44e79", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "78353ce4-2710-49b5-1341-b8cbb6000ebc", "vitrage_id": "RESOURCE:nova.instance:78353ce4-2710-49b5-1341-b8cbb6000ebc" },TODO { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "vm-12", "update_timestamp": "2015-12-01T12:46:41Z", "state": "ACTIVE", "project_id": "0683517e1e354d2ba25cba6937f44e79", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "35bf479a-75d9-80a9-874e-d3b50fb2dd2e", "vitrage_id": "RESOURCE:nova.instance:35bf479a-75d9-80a9-874e-d3b50fb2dd2e" }, { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "openstack.cluster", - "type": "openstack.cluster", + "vitrage_type": "openstack.cluster", "id": "openstack.cluster", "vitrage_id": "RESOURCE:openstack.cluster" } @@ -473,147 +473,147 @@ Response Examples "links": [ { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 3, "key": "contains", "source": 5 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 1, "key": "contains", "source": 5 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 16, "key": "contains", "source": 5 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 11, "key": "contains", "source": 5 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 13, "key": "contains", "source": 6 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 4, "key": "contains", "source": 6 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 14, "key": "contains", "source": 6 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 20, "key": "contains", "source": 7 },?vitrage_id=all { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 0, "key": "contains", "source": 7 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 19, "key": "contains", "source": 7 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 15, "key": "contains", "source": 7 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 9, "key": "contains", "source": 8 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 10, "key": "contains", "source": 8 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 2, "key": "contains", "source": 8 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 17, "key": "contains", "source": 8 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 6, "key": "contains", "source": 12 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 8, "key": "contains", "source": 12 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 5, "key": "contains", "source": 18 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 7, "key": "contains", "source": 18 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 18, "key": "contains", "source": 21 }, { "relationship_name": "contains", - "is_deleted": false, + "vitrage_is_deleted": false, "target": 12, "key": "contains", "source": 21 @@ -685,8 +685,8 @@ Response Examples }, "nodes": [ { - "category": "ALARM", - "type": "nagios", + "vitrage_category": "ALARM", + "vitrage_type": "nagios", "name": "CPU load", "state": "Active", "severity": "WARNING", @@ -699,8 +699,8 @@ Response Examples "vitrage_id": "ALARM:nagios:host0:CPU load" }, { - "category": "ALARM", - "type": "vitrage", + "vitrage_category": "ALARM", + "vitrage_type": "vitrage", "name": "Machine Suboptimal", "state": "Active", "severity": "WARNING", @@ -712,8 +712,8 @@ Response Examples "vitrage_id": "ALARM:vitrage:vm0:Machine Suboptimal" }, { - "category": "ALARM", - "type": "vitrage", + "vitrage_category": "ALARM", + "vitrage_type": "vitrage", "name": "Machine Suboptimal", "state": "Active", "severity": "WARNING", @@ -799,8 +799,8 @@ Response Examples [ { - "category": "ALARM", - "type": "nagios", + "vitrage_category": "ALARM", + "vitrage_type": "nagios", "name": "CPU load", "state": "Active", "severity": "WARNING", @@ -814,8 +814,8 @@ Response Examples "normalized_severity": "WARNING" }, { - "category": "ALARM", - "type": "vitrage", + "vitrage_category": "ALARM", + "vitrage_type": "vitrage", "name": "Machine Suboptimal", "state": "Active", "severity": "CRITICAL", @@ -828,8 +828,8 @@ Response Examples "normalized_severity": "CRITICAL" }, { - "category": "ALARM", - "type": "vitrage", + "vitrage_category": "ALARM", + "vitrage_type": "vitrage", "name": "Machine Suboptimal", "state": "Active", "severity": "CRITICAL", @@ -842,8 +842,8 @@ Response Examples "normalized_severity": "CRITICAL" }, { - "category": "ALARM", - "type": "aodh", + "vitrage_category": "ALARM", + "vitrage_type": "aodh", "name": "Memory overload", "state": "Active", "severity": "WARNING", @@ -1130,30 +1130,30 @@ Response Examples "entities": [ { "entity": { - "category": "ALARM", - "type": "nagios", + "vitrage_category": "ALARM", + "vitrage_type": "nagios", "name": "check_libvirtd", "template_id": "alarm_1" } }, { "entity": { - "category": "RESOURCE", - "type": "nova.host", + "vitrage_category": "RESOURCE", + "vitrage_type": "nova.host", "template_id": "host" } }, { "entity": { - "category": "RESOURCE", - "type": "nova.instance", + "vitrage_category": "RESOURCE", + "vitrage_type": "nova.instance", "template_id": "instance" } }, { "entity": { - "category": "ALARM", - "type": "vitrage", + "vitrage_category": "ALARM", + "vitrage_type": "vitrage", "name": "exploding_world", "template_id": "alarm_2" } @@ -1317,9 +1317,9 @@ Response Examples [ { "vitrage_id": "RESOURCE:nova.host:cloud", - "aggregated_state": "AVAILABLE", + "vitrage_aggregated_state": "AVAILABLE", "state": "available", - "type": "nova.host", + "vitrage_type": "nova.host", "id": "cloud", "metadata": { "name": "cloud", @@ -1387,14 +1387,14 @@ Response Examples :: { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "vm-1", "update_timestamp": "2015-12-01T12:46:41Z", "state": "ACTIVE", "project_id": "0683517e1e354d2ba25cba6937f44e79", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "dc35fa2f-4515-1653-ef6b-03b471bb395b", "vitrage_id": "RESOURCE:nova.instance:dc35fa2f-4515-1653-ef6b-03b471bb395b" } diff --git a/doc/source/vitrage-template-format.rst b/doc/source/vitrage-template-format.rst index 5214cb137..184ca4b45 100644 --- a/doc/source/vitrage-template-format.rst +++ b/doc/source/vitrage-template-format.rst @@ -294,26 +294,26 @@ Adding/removing a template Common parameters and their acceptable values - for writing templates --------------------------------------------------------------------- -+-------------------+---------------+-------------------------+------------------------------------+ -| block | key | supported values | comments | -+===================+===============+=========================+====================================+ -| entity | category | ALARM | | -| | | RESOURCE | | -+-------------------+---------------+-------------------------+------------------------------------+ -| entity (ALARM) | type | any string | | -+-------------------+---------------+-------------------------+------------------------------------+ -| entity (RESOURCE) | type | openstack.cluster, | These are for the datasources that | -| | | nova.zone, | come with vitrage by default. | -| | | nova.host, | Adding datasources will add more | -| | | nova.instance, | supported types, as defined in the | -| | | cinder.volume, | datasource transformer | -| | | switch | | -+-------------------+---------------+-------------------------+------------------------------------+ -| action | action_type | raise_alarm, | | -| | | set_state, | | -| | | add_causal_relationship | | -| | | mark_down | | -+-------------------+---------------+-------------------------+------------------------------------+ ++-------------------+-----------------------+-------------------------+------------------------------------+ +| block | key | supported values | comments | ++===================+=======================+=========================+====================================+ +| entity | category | ALARM | | +| | | RESOURCE | | ++-------------------+-----------------------+-------------------------+------------------------------------+ +| entity (ALARM) | type | any string | | ++-------------------+-----------------------+-------------------------+------------------------------------+ +| entity (RESOURCE) | type | openstack.cluster, | These are for the datasources that | +| | | nova.zone, | come with vitrage by default. | +| | | nova.host, | Adding datasources will add more | +| | | nova.instance, | supported types, as defined in the | +| | | cinder.volume, | datasource transformer | +| | | switch | | ++-------------------+-----------------------+-------------------------+------------------------------------+ +| action | action_type | raise_alarm, | | +| | | set_state, | | +| | | add_causal_relationship | | +| | | mark_down | | ++-------------------+-----------------------+-------------------------+------------------------------------+ Supported Actions diff --git a/doc/source/zabbix_vitrage.rst b/doc/source/zabbix_vitrage.rst index 75fa3c061..6d6321a5f 100644 --- a/doc/source/zabbix_vitrage.rst +++ b/doc/source/zabbix_vitrage.rst @@ -104,8 +104,8 @@ Vitrage configuration zabbix: - zabbix_host: Zabbix server - type: nova.host - name: Zabbix server + type: nova.host + name: Zabbix server 4. Restart vitrage service in devstack/openstack diff --git a/vitrage/api_handler/apis/alarm.py b/vitrage/api_handler/apis/alarm.py index 5d9a1d204..06647f013 100644 --- a/vitrage/api_handler/apis/alarm.py +++ b/vitrage/api_handler/apis/alarm.py @@ -48,10 +48,10 @@ class AlarmApis(EntityGraphApisBase): is_admin_project) alarms = set(alarms) else: - alarms = self.entity_graph.neighbors( - vitrage_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.IS_DELETED: False}) + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_IS_DELETED: False} + alarms = self.entity_graph.neighbors(vitrage_id, + vertex_attr_filter=query) return json.dumps({'alarms': [v.properties for v in alarms]}) diff --git a/vitrage/api_handler/apis/base.py b/vitrage/api_handler/apis/base.py index 7e3742f94..693d80be5 100644 --- a/vitrage/api_handler/apis/base.py +++ b/vitrage/api_handler/apis/base.py @@ -30,15 +30,15 @@ LOG = log.getLogger(__name__) # Used for Sunburst to show only specific resources TREE_TOPOLOGY_QUERY = { 'and': [ - {'==': {VProps.CATEGORY: EntityCategory.RESOURCE}}, - {'==': {VProps.IS_DELETED: False}}, - {'==': {VProps.IS_PLACEHOLDER: False}}, + {'==': {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE}}, + {'==': {VProps.VITRAGE_IS_DELETED: False}}, + {'==': {VProps.VITRAGE_IS_PLACEHOLDER: False}}, { 'or': [ - {'==': {VProps.TYPE: OPENSTACK_CLUSTER}}, - {'==': {VProps.TYPE: NOVA_INSTANCE_DATASOURCE}}, - {'==': {VProps.TYPE: NOVA_HOST_DATASOURCE}}, - {'==': {VProps.TYPE: NOVA_ZONE_DATASOURCE}} + {'==': {VProps.VITRAGE_TYPE: OPENSTACK_CLUSTER}}, + {'==': {VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE}}, + {'==': {VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE}}, + {'==': {VProps.VITRAGE_TYPE: NOVA_ZONE_DATASOURCE}} ] } ] @@ -46,12 +46,12 @@ TREE_TOPOLOGY_QUERY = { TOPOLOGY_AND_ALARMS_QUERY = { 'and': [ - {'==': {VProps.IS_DELETED: False}}, - {'==': {VProps.IS_PLACEHOLDER: False}}, + {'==': {VProps.VITRAGE_IS_DELETED: False}}, + {'==': {VProps.VITRAGE_IS_PLACEHOLDER: False}}, { 'or': [ - {'==': {VProps.CATEGORY: EntityCategory.ALARM}}, - {'==': {VProps.CATEGORY: EntityCategory.RESOURCE}} + {'==': {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM}}, + {'==': {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE}} ] } ] @@ -59,31 +59,31 @@ TOPOLOGY_AND_ALARMS_QUERY = { RCA_QUERY = { 'and': [ - {'==': {VProps.CATEGORY: EntityCategory.ALARM}}, - {'==': {VProps.IS_DELETED: False}} + {'==': {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM}}, + {'==': {VProps.VITRAGE_IS_DELETED: False}} ] } ALARMS_ALL_QUERY = { 'and': [ - {'==': {VProps.CATEGORY: EntityCategory.ALARM}}, - {'==': {VProps.IS_DELETED: False}} + {'==': {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM}}, + {'==': {VProps.VITRAGE_IS_DELETED: False}} ] } ALARM_QUERY = { - VProps.CATEGORY: EntityCategory.ALARM, - VProps.IS_DELETED: False, - VProps.IS_PLACEHOLDER: False + VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_IS_DELETED: False, + VProps.VITRAGE_IS_PLACEHOLDER: False } -EDGE_QUERY = {'==': {EProps.IS_DELETED: False}} +EDGE_QUERY = {'==': {EProps.VITRAGE_IS_DELETED: False}} RESOURCES_ALL_QUERY = { 'and': [ - {'==': {VProps.CATEGORY: EntityCategory.RESOURCE}}, - {'==': {VProps.IS_DELETED: False}}, - {'==': {VProps.IS_PLACEHOLDER: False}} + {'==': {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE}}, + {'==': {VProps.VITRAGE_IS_DELETED: False}}, + {'==': {VProps.VITRAGE_IS_PLACEHOLDER: False}} ] } @@ -93,13 +93,13 @@ class EntityGraphApisBase(object): IS_ADMIN_PROJECT_PROPERTY = 'is_admin' @staticmethod - def _get_query_with_project(category, project_id, is_admin): + def _get_query_with_project(vitrage_category, project_id, is_admin): """Generate query with tenant data Creates query for entity graph which takes into consideration the - category, project_id and if the tenant is admin + vitrage_category, project_id and if the tenant is admin - :type category: string + :type vitrage_category: string :type project_id: string :type is_admin: boolean :rtype: dictionary @@ -107,9 +107,9 @@ class EntityGraphApisBase(object): query = { 'and': [ - {'==': {VProps.IS_DELETED: False}}, - {'==': {VProps.IS_PLACEHOLDER: False}}, - {'==': {VProps.CATEGORY: category}} + {'==': {VProps.VITRAGE_IS_DELETED: False}}, + {'==': {VProps.VITRAGE_IS_PLACEHOLDER: False}}, + {'==': {VProps.VITRAGE_CATEGORY: vitrage_category}} ] } @@ -141,7 +141,7 @@ class EntityGraphApisBase(object): for alarm in alarms: alarm_project_id = alarm.get(VProps.PROJECT_ID, None) if not alarm_project_id: - cat_filter = {VProps.CATEGORY: EntityCategory.RESOURCE} + cat_filter = {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE} alarms_resource = \ self.entity_graph.neighbors(alarm.vertex_id, vertex_attr_filter=cat_filter) @@ -183,7 +183,7 @@ class EntityGraphApisBase(object): entities = self.entity_graph.neighbors(entity.vertex_id, direction=Direction.OUT) for entity in entities: - if entity[VProps.CATEGORY] == EntityCategory.RESOURCE: + if entity[VProps.VITRAGE_CATEGORY] == EntityCategory.RESOURCE: resource_project_id = entity.get(VProps.PROJECT_ID) if resource_project_id == project_id or \ (not resource_project_id and is_admin_project): diff --git a/vitrage/api_handler/apis/resource.py b/vitrage/api_handler/apis/resource.py index 00d6dd7cf..8184d323e 100644 --- a/vitrage/api_handler/apis/resource.py +++ b/vitrage/api_handler/apis/resource.py @@ -47,7 +47,7 @@ class ResourceApis(EntityGraphApisBase): query = copy.deepcopy(resource_query) if resource_type: - type_query = {'==': {VProps.TYPE: resource_type}} + type_query = {'==': {VProps.VITRAGE_TYPE: resource_type}} query['and'].append(type_query) resources = self.entity_graph.get_vertices(query_dict=query) diff --git a/vitrage/api_handler/apis/topology.py b/vitrage/api_handler/apis/topology.py index 8bc775736..086521463 100644 --- a/vitrage/api_handler/apis/topology.py +++ b/vitrage/api_handler/apis/topology.py @@ -65,7 +65,7 @@ class TopologyApis(EntityGraphApisBase): q = query if query else TOPOLOGY_AND_ALARMS_QUERY graph = ga.create_graph_from_matching_vertices( query_dict=q, - edge_attr_filter={VProps.IS_DELETED: False}) + edge_attr_filter={VProps.VITRAGE_IS_DELETED: False}) else: graph = self._get_topology_for_specific_project( ga, @@ -115,7 +115,7 @@ class TopologyApis(EntityGraphApisBase): tmp_graph = ga.create_graph_from_matching_vertices(query_dict=q) graph = self._create_graph_of_connected_components(ga, tmp_graph, root) - edge_query = {EProps.IS_DELETED: False} + edge_query = {EProps.VITRAGE_IS_DELETED: False} self._remove_unnecessary_elements(ga, graph, project_id, @@ -153,7 +153,7 @@ class TopologyApis(EntityGraphApisBase): for alarm in graph.get_vertices(query_dict=ALARMS_ALL_QUERY): if not alarm.get(VProps.PROJECT_ID, None): - cat_filter = {VProps.CATEGORY: EntityCategory.RESOURCE} + cat_filter = {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE} resource_neighbors = \ self.entity_graph.neighbors(alarm.vertex_id, vertex_attr_filter=cat_filter) @@ -220,7 +220,7 @@ class TopologyApis(EntityGraphApisBase): @staticmethod def _find_instance_in_graph(graph): for node, node_data in graph.nodes_iter(data=True): - if node_data[VProps.CATEGORY] == EntityCategory.RESOURCE and \ - node_data[VProps.TYPE] == NOVA_INSTANCE_DATASOURCE: + if node_data[VProps.VITRAGE_CATEGORY] == EntityCategory.RESOURCE and \ + node_data[VProps.VITRAGE_TYPE] == NOVA_INSTANCE_DATASOURCE: return node return None diff --git a/vitrage/common/constants.py b/vitrage/common/constants.py index 7ba4a7e46..3c05ef37c 100644 --- a/vitrage/common/constants.py +++ b/vitrage/common/constants.py @@ -15,23 +15,24 @@ class VertexProperties(object): - CATEGORY = 'category' - TYPE = 'type' + VITRAGE_CATEGORY = 'vitrage_category' + VITRAGE_TYPE = 'vitrage_type' + VITRAGE_ID = 'vitrage_id' + VITRAGE_STATE = 'vitrage_state' + VITRAGE_IS_DELETED = 'vitrage_is_deleted' + VITRAGE_IS_PLACEHOLDER = 'vitrage_is_placeholder' + VITRAGE_SAMPLE_TIMESTAMP = 'vitrage_sample_timestamp' + VITRAGE_AGGREGATED_STATE = 'vitrage_aggregated_state' + VITRAGE_OPERATIONAL_STATE = 'vitrage_operational_state' + VITRAGE_AGGREGATED_SEVERITY = 'vitrage_aggregated_severity' + VITRAGE_OPERATIONAL_SEVERITY = 'vitrage_operational_severity' + VITRAGE_RESOURCE_ID = 'vitrage_resource_id' ID = 'id' - IS_DELETED = 'is_deleted' STATE = 'state' - VITRAGE_STATE = 'vitrage_state' - AGGREGATED_STATE = 'aggregated_state' - OPERATIONAL_STATE = 'operational_state' PROJECT_ID = 'project_id' UPDATE_TIMESTAMP = 'update_timestamp' - SAMPLE_TIMESTAMP = 'sample_timestamp' NAME = 'name' - IS_PLACEHOLDER = 'is_placeholder' SEVERITY = 'severity' - AGGREGATED_SEVERITY = 'aggregated_severity' - OPERATIONAL_SEVERITY = 'operational_severity' - VITRAGE_ID = 'vitrage_id' IS_MARKED_DOWN = 'is_marked_down' INFO = 'info' GRAPH_INDEX = 'graph_index' @@ -45,7 +46,7 @@ class VertexProperties(object): class EdgeProperties(object): RELATIONSHIP_TYPE = 'relationship_type' - IS_DELETED = 'is_deleted' + VITRAGE_IS_DELETED = 'vitrage_is_deleted' UPDATE_TIMESTAMP = 'update_timestamp' diff --git a/vitrage/datasources/alarm_driver_base.py b/vitrage/datasources/alarm_driver_base.py index 015faccc1..98dbd449b 100644 --- a/vitrage/datasources/alarm_driver_base.py +++ b/vitrage/datasources/alarm_driver_base.py @@ -27,8 +27,8 @@ class AlarmDriverBase(DriverBase): super(DriverBase, self).__init__() self.cache = dict() - def _entity_type(self): - """Return the type of the datasource """ + def _vitrage_type(self): + """Return the vitrage_type of the datasource """ pass def _alarm_key(self, alarm): @@ -74,12 +74,12 @@ class AlarmDriverBase(DriverBase): def get_all(self, datasource_action): return self.make_pickleable(self._get_all_alarms(), - self._entity_type(), + self._vitrage_type(), datasource_action) def get_changes(self, datasource_action): return self.make_pickleable(self._get_changed_alarms(), - self._entity_type(), + self._vitrage_type(), datasource_action) def _get_all_alarms(self): diff --git a/vitrage/datasources/aodh/driver.py b/vitrage/datasources/aodh/driver.py index 5ee388d66..a1e661213 100644 --- a/vitrage/datasources/aodh/driver.py +++ b/vitrage/datasources/aodh/driver.py @@ -42,7 +42,7 @@ class AodhDriver(AlarmDriverBase): self._client = os_clients.ceilometer_client(self.conf) return self._client - def _entity_type(self): + def _vitrage_type(self): return AODH_DATASOURCE def _alarm_key(self, alarm): diff --git a/vitrage/datasources/aodh/transformer.py b/vitrage/datasources/aodh/transformer.py index b7d81268b..81b8d431d 100644 --- a/vitrage/datasources/aodh/transformer.py +++ b/vitrage/datasources/aodh/transformer.py @@ -24,6 +24,8 @@ from vitrage.datasources.aodh.properties import AodhProperties as AodhProps from vitrage.datasources.aodh.properties import AodhState from vitrage.datasources import transformer_base as tbase from vitrage.datasources.transformer_base import Neighbor +from vitrage.evaluator.actions.evaluator_event_transformer \ + import VITRAGE_DATASOURCE import vitrage.graph.utils as graph_utils from vitrage.utils import datetime as datetime_utils @@ -67,18 +69,18 @@ class AodhTransformer(AlarmTransformerBase): metadata[AodhProps.STATE_TIMESTAMP] = \ entity_event[AodhProps.STATE_TIMESTAMP] - sample_timestamp = entity_event[DSProps.SAMPLE_DATE] + vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] update_timestamp = self._format_update_timestamp( - AodhTransformer._timestamp(entity_event), sample_timestamp) + AodhTransformer._timestamp(entity_event), vitrage_sample_timestamp) return graph_utils.create_vertex( self._create_entity_key(entity_event), + vitrage_category=EntityCategory.ALARM, + vitrage_type=entity_event[DSProps.ENTITY_TYPE], + vitrage_sample_timestamp=vitrage_sample_timestamp, entity_id=entity_event[AodhProps.ALARM_ID], - entity_category=EntityCategory.ALARM, - entity_type=entity_event[DSProps.ENTITY_TYPE], entity_state=self._get_alarm_state(entity_event), - sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata) @@ -110,16 +112,16 @@ class AodhTransformer(AlarmTransformerBase): AodhProps.DESCRIPTION: entity_event[AodhProps.DESCRIPTION], VProps.PROJECT_ID: entity_event[AodhProps.PROJECT_ID], } - sample_timestamp = entity_event[DSProps.SAMPLE_DATE] + vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] update_timestamp = self._format_update_timestamp( - AodhTransformer._timestamp(entity_event), sample_timestamp) + AodhTransformer._timestamp(entity_event), vitrage_sample_timestamp) return graph_utils.create_vertex( self._create_entity_key(entity_event), + vitrage_category=EntityCategory.ALARM, + vitrage_type=VITRAGE_DATASOURCE, + vitrage_sample_timestamp=vitrage_sample_timestamp, entity_id=entity_event.get(AodhProps.ALARM_ID), - entity_category=EntityCategory.ALARM, - entity_type='vitrage', - sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata) @@ -148,7 +150,7 @@ class AodhTransformer(AlarmTransformerBase): return None return {VProps.ID: affected_resource_id} - def get_type(self): + def get_vitrage_type(self): return AODH_DATASOURCE diff --git a/vitrage/datasources/cinder/volume/transformer.py b/vitrage/datasources/cinder/volume/transformer.py index eb98d62bc..d8e8d1d92 100644 --- a/vitrage/datasources/cinder/volume/transformer.py +++ b/vitrage/datasources/cinder/volume/transformer.py @@ -112,15 +112,15 @@ class CinderVolumeTransformer(ResourceTransformerBase): entity_key = self._create_entity_key(entity_event) - sample_timestamp = entity_event[DSProps.SAMPLE_DATE] + vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] return graph_utils.create_vertex( entity_key, + vitrage_category=EntityCategory.RESOURCE, + vitrage_type=CINDER_VOLUME_DATASOURCE, + vitrage_sample_timestamp=vitrage_sample_timestamp, entity_id=volume_id, - entity_category=EntityCategory.RESOURCE, - entity_type=CINDER_VOLUME_DATASOURCE, entity_state=volume_state, - sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata) @@ -159,5 +159,5 @@ class CinderVolumeTransformer(ResourceTransformerBase): return neighbors - def get_type(self): + def get_vitrage_type(self): return CINDER_VOLUME_DATASOURCE diff --git a/vitrage/datasources/collectd/driver.py b/vitrage/datasources/collectd/driver.py index 4de2cb98f..0557bea04 100644 --- a/vitrage/datasources/collectd/driver.py +++ b/vitrage/datasources/collectd/driver.py @@ -37,7 +37,7 @@ class CollectdDriver(AlarmDriverBase): CollectdDriver.conf_map = \ CollectdDriver._configuration_mapping(conf) - def _entity_type(self): + def _vitrage_type(self): return COLLECTD_DATASOURCE def _alarm_key(self, alarm): diff --git a/vitrage/datasources/collectd/transformer.py b/vitrage/datasources/collectd/transformer.py index dc5296c64..bfebaf2f8 100644 --- a/vitrage/datasources/collectd/transformer.py +++ b/vitrage/datasources/collectd/transformer.py @@ -45,7 +45,7 @@ class CollectdTransformer(AlarmTransformerBase): update_timestamp = entity_event['timestamp'] - sample_timestamp = entity_event[DSProps.SAMPLE_DATE] + vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] entity_state = AlarmProps.INACTIVE_STATE \ if self._ok_status(entity_event) else AlarmProps.ACTIVE_STATE @@ -59,10 +59,10 @@ class CollectdTransformer(AlarmTransformerBase): return graph_utils.create_vertex( self._create_entity_key(entity_event), - entity_category=EntityCategory.ALARM, - entity_type=entity_event[DSProps.ENTITY_TYPE], + vitrage_category=EntityCategory.ALARM, + vitrage_type=entity_event[DSProps.ENTITY_TYPE], + vitrage_sample_timestamp=vitrage_sample_timestamp, entity_state=entity_state, - sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata) @@ -97,7 +97,7 @@ class CollectdTransformer(AlarmTransformerBase): resource_name, alarm_id)) - def get_type(self): + def get_vitrage_type(self): return COLLECTD_DATASOURCE @staticmethod diff --git a/vitrage/datasources/consistency/transformer.py b/vitrage/datasources/consistency/transformer.py index 983d7d1a6..517529999 100644 --- a/vitrage/datasources/consistency/transformer.py +++ b/vitrage/datasources/consistency/transformer.py @@ -47,7 +47,7 @@ class ConsistencyTransformer(ResourceTransformerBase): return graph_utils.create_vertex( entity_event[VProps.VITRAGE_ID], - sample_timestamp=entity_event[DSProps.SAMPLE_DATE], + vitrage_sample_timestamp=entity_event[DSProps.SAMPLE_DATE], metadata=metadata ) @@ -60,5 +60,5 @@ class ConsistencyTransformer(ResourceTransformerBase): def _create_update_neighbors(self, entity_event): return None - def get_type(self): + def get_vitrage_type(self): return CONSISTENCY_DATASOURCE diff --git a/vitrage/datasources/doctor/driver.py b/vitrage/datasources/doctor/driver.py index 950b2625c..bdbee3c19 100644 --- a/vitrage/datasources/doctor/driver.py +++ b/vitrage/datasources/doctor/driver.py @@ -37,7 +37,7 @@ class DoctorDriver(AlarmDriverBase): self.conf = conf self._client = None - def _entity_type(self): + def _vitrage_type(self): return DOCTOR_DATASOURCE def _alarm_key(self, alarm): diff --git a/vitrage/datasources/doctor/transformer.py b/vitrage/datasources/doctor/transformer.py index 02ab2fa68..e0f6dd4f2 100644 --- a/vitrage/datasources/doctor/transformer.py +++ b/vitrage/datasources/doctor/transformer.py @@ -54,10 +54,10 @@ class DoctorTransformer(AlarmTransformerBase): return graph_utils.create_vertex( self._create_entity_key(entity_event), - entity_category=EntityCategory.ALARM, - entity_type=entity_event[DSProps.ENTITY_TYPE], + vitrage_category=EntityCategory.ALARM, + vitrage_type=entity_event[DSProps.ENTITY_TYPE], + vitrage_sample_timestamp=entity_event[DSProps.SAMPLE_DATE], entity_state=self._get_alarm_state(entity_event), - sample_timestamp=entity_event[DSProps.SAMPLE_DATE], update_timestamp=entity_event[DoctorProps.UPDATE_TIME], metadata=details) @@ -76,7 +76,7 @@ class DoctorTransformer(AlarmTransformerBase): entity_event[EventProps.TYPE], get_detail(entity_event, DoctorDetails.HOSTNAME))) - def get_type(self): + def get_vitrage_type(self): return DOCTOR_DATASOURCE def _ok_status(self, entity_event): diff --git a/vitrage/datasources/heat/stack/transformer.py b/vitrage/datasources/heat/stack/transformer.py index 9982c56cc..5ce37936e 100644 --- a/vitrage/datasources/heat/stack/transformer.py +++ b/vitrage/datasources/heat/stack/transformer.py @@ -91,15 +91,15 @@ class HeatStackTransformer(ResourceTransformerBase): entity_key = self._create_entity_key(entity_event) - sample_timestamp = entity_event[DSProps.SAMPLE_DATE] + vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] return graph_utils.create_vertex( entity_key, + vitrage_category=EntityCategory.RESOURCE, + vitrage_type=HEAT_STACK_DATASOURCE, + vitrage_sample_timestamp=vitrage_sample_timestamp, entity_id=stack_id, - entity_category=EntityCategory.RESOURCE, - entity_type=HEAT_STACK_DATASOURCE, entity_state=stack_state, - sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata) @@ -133,5 +133,5 @@ class HeatStackTransformer(ResourceTransformerBase): return neighbors - def get_type(self): + def get_vitrage_type(self): return HEAT_STACK_DATASOURCE diff --git a/vitrage/datasources/nagios/config.py b/vitrage/datasources/nagios/config.py index 19c890656..9ff084d8b 100644 --- a/vitrage/datasources/nagios/config.py +++ b/vitrage/datasources/nagios/config.py @@ -46,7 +46,7 @@ class NagiosConfig(object): config[NAME]) def get_vitrage_resource(self, nagios_host): - """Get Vitrage resource type and name for the given nagios host name + """Get Resource type and name for the given nagios host name Go over the configuration mappings one by one, and return the resource by the first mapping that applies to nagios host name. diff --git a/vitrage/datasources/nagios/driver.py b/vitrage/datasources/nagios/driver.py index 5b825309d..a5d074ab6 100644 --- a/vitrage/datasources/nagios/driver.py +++ b/vitrage/datasources/nagios/driver.py @@ -37,7 +37,7 @@ class NagiosDriver(AlarmDriverBase): self.conf = conf self.config = NagiosConfig(conf) - def _entity_type(self): + def _vitrage_type(self): return NAGIOS_DATASOURCE def _alarm_key(self, alarm): diff --git a/vitrage/datasources/nagios/transformer.py b/vitrage/datasources/nagios/transformer.py index 53f648312..73e54a1a5 100644 --- a/vitrage/datasources/nagios/transformer.py +++ b/vitrage/datasources/nagios/transformer.py @@ -42,9 +42,10 @@ class NagiosTransformer(AlarmTransformerBase): entity_event[NagiosProperties.LAST_CHECK], '%Y-%m-%d %H:%M:%S', tbase.TIMESTAMP_FORMAT) - sample_timestamp = entity_event[DSProps.SAMPLE_DATE] - update_timestamp = self._format_update_timestamp(update_timestamp, - sample_timestamp) + vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] + update_timestamp = \ + self._format_update_timestamp(update_timestamp, + vitrage_sample_timestamp) metadata = { VProps.NAME: entity_event[NagiosProperties.SERVICE], @@ -55,10 +56,10 @@ class NagiosTransformer(AlarmTransformerBase): return graph_utils.create_vertex( self._create_entity_key(entity_event), - entity_category=EntityCategory.ALARM, - entity_type=entity_event[DSProps.ENTITY_TYPE], + vitrage_category=EntityCategory.ALARM, + vitrage_type=entity_event[DSProps.ENTITY_TYPE], + vitrage_sample_timestamp=vitrage_sample_timestamp, entity_state=self._get_alarm_state(entity_event), - sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata) @@ -93,5 +94,5 @@ class NagiosTransformer(AlarmTransformerBase): resource_name, alarm_name)) - def get_type(self): + def get_vitrage_type(self): return NAGIOS_DATASOURCE diff --git a/vitrage/datasources/neutron/network/transformer.py b/vitrage/datasources/neutron/network/transformer.py index f414bd984..bb45e8f52 100644 --- a/vitrage/datasources/neutron/network/transformer.py +++ b/vitrage/datasources/neutron/network/transformer.py @@ -87,15 +87,15 @@ class NetworkTransformer(ResourceTransformerBase): VProps.PROJECT_ID: project_id, } - sample_timestamp = entity_event[DSProps.SAMPLE_DATE] + vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] return graph_utils.create_vertex( self._create_entity_key(entity_event), + vitrage_category=EntityCategory.RESOURCE, + vitrage_type=NEUTRON_NETWORK_DATASOURCE, + vitrage_sample_timestamp=vitrage_sample_timestamp, entity_id=entity_id, - entity_category=EntityCategory.RESOURCE, - entity_type=NEUTRON_NETWORK_DATASOURCE, entity_state=state, - sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata) @@ -107,5 +107,5 @@ class NetworkTransformer(ResourceTransformerBase): key_fields = self._key_values(NEUTRON_NETWORK_DATASOURCE, network_id) return tbase.build_key(key_fields) - def get_type(self): + def get_vitrage_type(self): return NEUTRON_NETWORK_DATASOURCE diff --git a/vitrage/datasources/neutron/port/transformer.py b/vitrage/datasources/neutron/port/transformer.py index fc8dde695..9142f16d0 100644 --- a/vitrage/datasources/neutron/port/transformer.py +++ b/vitrage/datasources/neutron/port/transformer.py @@ -105,15 +105,15 @@ class PortTransformer(ResourceTransformerBase): 'host_id': entity_event.get('binding:host_id'), } - sample_timestamp = entity_event[DSProps.SAMPLE_DATE] + vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] return graph_utils.create_vertex( self._create_entity_key(entity_event), + vitrage_category=EntityCategory.RESOURCE, + vitrage_type=NEUTRON_PORT_DATASOURCE, + vitrage_sample_timestamp=vitrage_sample_timestamp, entity_id=entity_id, - entity_category=EntityCategory.RESOURCE, - entity_type=NEUTRON_PORT_DATASOURCE, entity_state=state, - sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata) @@ -159,5 +159,5 @@ class PortTransformer(ResourceTransformerBase): return tbase.build_key(key_fields) - def get_type(self): + def get_vitrage_type(self): return NEUTRON_PORT_DATASOURCE diff --git a/vitrage/datasources/nova/host/transformer.py b/vitrage/datasources/nova/host/transformer.py index c45670854..207ea419c 100644 --- a/vitrage/datasources/nova/host/transformer.py +++ b/vitrage/datasources/nova/host/transformer.py @@ -48,16 +48,17 @@ class HostTransformer(ResourceTransformerBase): metadata = {VProps.NAME: host_name} entity_key = self._create_entity_key(entity_event) - sample_timestamp = entity_event[DSProps.SAMPLE_DATE] - update_timestamp = self._format_update_timestamp(None, - sample_timestamp) + vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] + update_timestamp = \ + self._format_update_timestamp(None, + vitrage_sample_timestamp) return graph_utils.create_vertex( entity_key, + vitrage_category=EntityCategory.RESOURCE, + vitrage_type=NOVA_HOST_DATASOURCE, + vitrage_sample_timestamp=vitrage_sample_timestamp, entity_id=host_name, - entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_HOST_DATASOURCE, - sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata) @@ -83,5 +84,5 @@ class HostTransformer(ResourceTransformerBase): key_fields = self._key_values(NOVA_HOST_DATASOURCE, host_name) return transformer_base.build_key(key_fields) - def get_type(self): + def get_vitrage_type(self): return NOVA_HOST_DATASOURCE diff --git a/vitrage/datasources/nova/instance/transformer.py b/vitrage/datasources/nova/instance/transformer.py index d6b183d6b..25a7c6394 100644 --- a/vitrage/datasources/nova/instance/transformer.py +++ b/vitrage/datasources/nova/instance/transformer.py @@ -62,21 +62,21 @@ class InstanceTransformer(ResourceTransformerBase): 'host_id': host } - sample_timestamp = entity_event[DSProps.SAMPLE_DATE] + vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] # TODO(Alexey): need to check that only the UPDATE datasource_action # will update the UPDATE_TIMESTAMP property update_timestamp = self._format_update_timestamp( extract_field_value(entity_event, DSProps.SAMPLE_DATE), - sample_timestamp) + vitrage_sample_timestamp) return graph_utils.create_vertex( self._create_entity_key(entity_event), + vitrage_category=EntityCategory.RESOURCE, + vitrage_type=NOVA_INSTANCE_DATASOURCE, + vitrage_sample_timestamp=vitrage_sample_timestamp, entity_id=entity_id, - entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_INSTANCE_DATASOURCE, entity_state=state, - sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata) @@ -106,5 +106,5 @@ class InstanceTransformer(ResourceTransformerBase): instance_id)) return tbase.build_key(key_fields) - def get_type(self): + def get_vitrage_type(self): return NOVA_INSTANCE_DATASOURCE diff --git a/vitrage/datasources/nova/zone/transformer.py b/vitrage/datasources/nova/zone/transformer.py index 7e0c7a347..55c731d20 100644 --- a/vitrage/datasources/nova/zone/transformer.py +++ b/vitrage/datasources/nova/zone/transformer.py @@ -61,17 +61,18 @@ class ZoneTransformer(ResourceTransformerBase): } entity_key = self._create_entity_key(entity_event) - sample_timestamp = entity_event[DSProps.SAMPLE_DATE] - update_timestamp = self._format_update_timestamp(None, - sample_timestamp) + vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] + update_timestamp = \ + self._format_update_timestamp(None, + vitrage_sample_timestamp) return graph_utils.create_vertex( entity_key, + vitrage_category=EntityCategory.RESOURCE, + vitrage_type=NOVA_ZONE_DATASOURCE, + vitrage_sample_timestamp=vitrage_sample_timestamp, entity_id=zone_name, - entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_ZONE_DATASOURCE, entity_state=state, - sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata) @@ -84,7 +85,7 @@ class ZoneTransformer(ResourceTransformerBase): def _create_zone_neighbors(self, entity_event): neighbors = [] metadata = { - VProps.IS_PLACEHOLDER: False, + VProps.VITRAGE_IS_PLACEHOLDER: False, VProps.STATE: 'available', VProps.NAME: OPENSTACK_CLUSTER } @@ -113,7 +114,7 @@ class ZoneTransformer(ResourceTransformerBase): metadata = { VProps.STATE: host_state, - VProps.IS_PLACEHOLDER: False + VProps.VITRAGE_IS_PLACEHOLDER: False } host_neighbor = self._create_neighbor(entity_event, @@ -133,5 +134,5 @@ class ZoneTransformer(ResourceTransformerBase): key_fields = self._key_values(NOVA_ZONE_DATASOURCE, zone_name) return tbase.build_key(key_fields) - def get_type(self): + def get_vitrage_type(self): return NOVA_ZONE_DATASOURCE diff --git a/vitrage/datasources/static/driver.py b/vitrage/datasources/static/driver.py index ed3129bb2..eaed05641 100644 --- a/vitrage/datasources/static/driver.py +++ b/vitrage/datasources/static/driver.py @@ -28,7 +28,9 @@ LOG = log.getLogger(__name__) class StaticDriver(DriverBase): # base fields are required for all entities, others are treated as metadata - BASE_FIELDS = {StaticFields.STATIC_ID, StaticFields.TYPE, StaticFields.ID} + BASE_FIELDS = {StaticFields.STATIC_ID, + StaticFields.TYPE, + StaticFields.ID} def __init__(self, conf): super(StaticDriver, self).__init__() @@ -121,9 +123,11 @@ class StaticDriver(DriverBase): """Expand config id to neighbor entity rel={'source': 's1', 'target': 'r1', 'relationship_type': 'attached'} - neighbor={'static_id': 'h1', 'type': 'host.nova', 'id': 1} + neighbor={'static_id': 'h1', 'vitrage_type': 'host.nova', 'id': 1} result={'relationship_type': 'attached', 'source': 's1', - 'target': {'static_id': 'h1', 'type': 'host.nova', 'id': 1}} + 'target': {'static_id': 'h1', + 'vitrage_type': 'host.nova', + 'id': 1}} """ rel = rel.copy() diff --git a/vitrage/datasources/static/transformer.py b/vitrage/datasources/static/transformer.py index 8faedbff5..9e75426f7 100644 --- a/vitrage/datasources/static/transformer.py +++ b/vitrage/datasources/static/transformer.py @@ -46,27 +46,27 @@ class StaticTransformer(ResourceTransformerBase): def _create_entity_key(self, entity_event): entity_id = entity_event[VProps.ID] - entity_type = entity_event[VProps.TYPE] + entity_type = entity_event[StaticFields.TYPE] key_fields = self._key_values(entity_type, entity_id) return transformer_base.build_key(key_fields) @staticmethod - def get_type(): + def get_vitrage_type(): return STATIC_DATASOURCE def _create_vertex(self, entity_event): - entity_type = entity_event[VProps.TYPE] + entity_type = entity_event[StaticFields.TYPE] entity_id = entity_event[VProps.ID] - sample_timestamp = entity_event[DSProps.SAMPLE_DATE] + vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] if entity_type in self.transformers: properties = { - VProps.TYPE: entity_type, + VProps.VITRAGE_TYPE: entity_type, VProps.ID: entity_id, - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.SAMPLE_TIMESTAMP: sample_timestamp, - VProps.IS_PLACEHOLDER: False + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_SAMPLE_TIMESTAMP: vitrage_sample_timestamp, + VProps.VITRAGE_IS_PLACEHOLDER: False } return self.create_neighbor_placeholder_vertex(**properties) else: @@ -74,15 +74,15 @@ class StaticTransformer(ResourceTransformerBase): state = entity_event[VProps.STATE] update_timestamp = self._format_update_timestamp( update_timestamp=None, - sample_timestamp=sample_timestamp) + sample_timestamp=vitrage_sample_timestamp) metadata = entity_event.get(StaticFields.METADATA, {}) return graph_utils.create_vertex( entity_key, + vitrage_category=EntityCategory.RESOURCE, + vitrage_type=entity_type, + vitrage_sample_timestamp=vitrage_sample_timestamp, entity_id=entity_id, - entity_category=EntityCategory.RESOURCE, - entity_type=entity_type, - sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, entity_state=state, metadata=metadata) @@ -103,7 +103,7 @@ class StaticTransformer(ResourceTransformerBase): return self._create_neighbor( entity_event, neighbor[VProps.ID], - neighbor[VProps.TYPE], + neighbor[StaticFields.TYPE], rel[StaticFields.RELATIONSHIP_TYPE], is_entity_source=is_entity_source) diff --git a/vitrage/datasources/static_physical/driver.py b/vitrage/datasources/static_physical/driver.py index d2c1ce3e8..34fb61382 100644 --- a/vitrage/datasources/static_physical/driver.py +++ b/vitrage/datasources/static_physical/driver.py @@ -18,9 +18,9 @@ from oslo_log import log from vitrage.common.constants import DatasourceProperties as DSProps from vitrage.common.constants import GraphAction -from vitrage.common.constants import VertexProperties as VProps from vitrage.datasources.driver_base import DriverBase from vitrage.datasources.static.driver import StaticDriver +from vitrage.datasources.static import StaticFields from vitrage.datasources.static_physical import STATIC_PHYSICAL_DATASOURCE from vitrage.utils import file as file_utils @@ -149,8 +149,8 @@ class StaticPhysicalDriver(DriverBase): @staticmethod def _find_entity(new_entity, entities): for entity in entities: - if entity[VProps.TYPE] == new_entity[VProps.TYPE] \ - and entity[VProps.ID] == new_entity[VProps.ID]: + if entity[StaticFields.TYPE] == new_entity[StaticFields.TYPE] \ + and entity[StaticFields.ID] == new_entity[StaticFields.ID]: return entity return None diff --git a/vitrage/datasources/static_physical/transformer.py b/vitrage/datasources/static_physical/transformer.py index 0c7b3ceeb..d59408b10 100644 --- a/vitrage/datasources/static_physical/transformer.py +++ b/vitrage/datasources/static_physical/transformer.py @@ -19,6 +19,7 @@ from vitrage.common.constants import VertexProperties as VProps from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE from vitrage.datasources.resource_transformer_base import \ ResourceTransformerBase +from vitrage.datasources.static import StaticFields from vitrage.datasources.static_physical import STATIC_PHYSICAL_DATASOURCE from vitrage.datasources.static_physical import SWITCH from vitrage.datasources import transformer_base @@ -47,22 +48,22 @@ class StaticPhysicalTransformer(ResourceTransformerBase): def _create_vertex(self, entity_event): - entity_type = entity_event[VProps.TYPE] + entity_type = entity_event[StaticFields.TYPE] entity_id = entity_event[VProps.ID] - sample_timestamp = entity_event[DSProps.SAMPLE_DATE] + vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] update_timestamp = self._format_update_timestamp( update_timestamp=None, - sample_timestamp=sample_timestamp) + sample_timestamp=vitrage_sample_timestamp) state = entity_event[VProps.STATE] entity_key = self._create_entity_key(entity_event) metadata = self._extract_metadata(entity_event) return graph_utils.create_vertex( entity_key, + vitrage_category=EntityCategory.RESOURCE, + vitrage_type=entity_type, + vitrage_sample_timestamp=vitrage_sample_timestamp, entity_id=entity_id, - entity_category=EntityCategory.RESOURCE, - entity_type=entity_type, - sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, entity_state=state, metadata=metadata) @@ -75,14 +76,14 @@ class StaticPhysicalTransformer(ResourceTransformerBase): def _create_static_physical_neighbors(self, entity_event): neighbors = [] - entity_type = entity_event[VProps.TYPE] + entity_type = entity_event[StaticFields.TYPE] for neighbor_details in entity_event.get( self.RELATIONSHIPS_SECTION, {}): # TODO(alexey): need to decide what to do if one of the entities # fails neighbor_id = neighbor_details[VProps.ID] - neighbor_type = neighbor_details[VProps.TYPE] + neighbor_type = neighbor_details[StaticFields.TYPE] relation_type = neighbor_details[self.RELATION_TYPE] is_entity_source = not self._find_relation_direction_source( entity_type, neighbor_type) @@ -98,7 +99,7 @@ class StaticPhysicalTransformer(ResourceTransformerBase): def _create_entity_key(self, entity_event): entity_id = entity_event[VProps.ID] - entity_type = entity_event[VProps.TYPE] + entity_type = entity_event[StaticFields.TYPE] key_fields = self._key_values(entity_type, entity_id) return transformer_base.build_key(key_fields) @@ -121,5 +122,5 @@ class StaticPhysicalTransformer(ResourceTransformerBase): relationship = (SWITCH, SWITCH) self.relation_direction[relationship] = True - def get_type(self): + def get_vitrage_type(self): return STATIC_PHYSICAL_DATASOURCE diff --git a/vitrage/datasources/transformer_base.py b/vitrage/datasources/transformer_base.py index b56f39229..26fa5ea55 100644 --- a/vitrage/datasources/transformer_base.py +++ b/vitrage/datasources/transformer_base.py @@ -74,9 +74,9 @@ def create_cluster_placeholder_vertex(): return graph_utils.create_vertex( key, + vitrage_category=cons.EntityCategory.RESOURCE, + vitrage_type=OPENSTACK_CLUSTER, entity_id=CLUSTER_ID, - entity_category=cons.EntityCategory.RESOURCE, - entity_type=OPENSTACK_CLUSTER, entity_state=AVAILABLE, metadata=metadata ) @@ -136,9 +136,11 @@ class TransformerBase(object): def _create_entity_vertex(self, entity_event): if is_update_event(entity_event) and \ - opt_exists(self.conf, self.get_type()) and \ - opt_exists(self.conf[self.get_type()], DSOpts.UPDATE_METHOD): - update_method = self.conf[self.get_type()].update_method.lower() + opt_exists(self.conf, self.get_vitrage_type()) and \ + opt_exists(self.conf[self.get_vitrage_type()], + DSOpts.UPDATE_METHOD): + update_method = \ + self.conf[self.get_vitrage_type()].update_method.lower() if update_method == UpdateMethod.PUSH: return self._create_update_entity_vertex(entity_event) elif update_method == UpdateMethod.PULL: @@ -205,12 +207,12 @@ class TransformerBase(object): metadata = {} if metadata is None else metadata # create placeholder vertex entity_vitrage_id = self._create_entity_key(entity_event) - sample_timestamp = entity_event[DSProps.SAMPLE_DATE] + vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] properties = { VProps.ID: neighbor_id, - VProps.TYPE: neighbor_datasource_type, - VProps.CATEGORY: neighbor_category, - VProps.SAMPLE_TIMESTAMP: sample_timestamp, + VProps.VITRAGE_TYPE: neighbor_datasource_type, + VProps.VITRAGE_CATEGORY: neighbor_category, + VProps.VITRAGE_SAMPLE_TIMESTAMP: vitrage_sample_timestamp, self.METADATA: metadata } neighbor_vertex = \ @@ -244,7 +246,7 @@ class TransformerBase(object): return (EntityCategory.RESOURCE,) + args def create_neighbor_placeholder_vertex(self, **kwargs): - if VProps.TYPE not in kwargs: + if VProps.VITRAGE_TYPE not in kwargs: LOG.error("Can't create placeholder vertex. Missing property TYPE") raise ValueError('Missing property TYPE') @@ -256,15 +258,17 @@ class TransformerBase(object): if self.METADATA in kwargs: metadata = kwargs[self.METADATA] - key_fields = self._key_values(kwargs[VProps.TYPE], kwargs[VProps.ID]) + key_fields = self._key_values(kwargs[VProps.VITRAGE_TYPE], + kwargs[VProps.ID]) return graph_utils.create_vertex( build_key(key_fields), + vitrage_category=kwargs[VProps.VITRAGE_CATEGORY], + vitrage_type=kwargs[VProps.VITRAGE_TYPE], + vitrage_sample_timestamp=kwargs[VProps.VITRAGE_SAMPLE_TIMESTAMP], + vitrage_is_placeholder=kwargs.get(VProps.VITRAGE_IS_PLACEHOLDER, + True), entity_id=kwargs[VProps.ID], - entity_category=kwargs[VProps.CATEGORY], - entity_type=kwargs[VProps.TYPE], - sample_timestamp=kwargs[VProps.SAMPLE_TIMESTAMP], - is_placeholder=kwargs.get(VProps.IS_PLACEHOLDER, True), metadata=metadata) def _extract_graph_action(self, entity_event): @@ -300,9 +304,8 @@ class TransformerBase(object): @staticmethod def _create_end_vertex(entity_event): entity_type = entity_event[DSProps.ENTITY_TYPE] - return graph_utils.create_vertex( - 'END_MESSAGE:' + entity_type, - entity_type=entity_type) + return graph_utils.create_vertex('END_MESSAGE:' + entity_type, + vitrage_type=entity_type) @staticmethod def _is_end_message(entity_event): @@ -325,16 +328,17 @@ class TransformerBase(object): Example: ------- - query = {'type': 'nova.instance'} + query = {'vitrage_type': 'nova.instance'} Before transform is called the result of running the query against the topology graph will be updated to event[QUERY_RESULT] - To contain the list of all the vertices with type=nova.instance + To contain the list of all the vertices with + vitrage_type=nova.instance """ return None @abc.abstractmethod - def get_type(self): - """Returns the type of the datasource + def get_vitrage_type(self): + """Returns the vitrage_type of the datasource :return: datasource type :rtype: String diff --git a/vitrage/datasources/zabbix/driver.py b/vitrage/datasources/zabbix/driver.py index 4788b36e3..8280088d4 100644 --- a/vitrage/datasources/zabbix/driver.py +++ b/vitrage/datasources/zabbix/driver.py @@ -64,7 +64,7 @@ class ZabbixDriver(AlarmDriverBase): LOG.exception('pyzabbix.ZabbixAPI %s', e) self._client = None - def _entity_type(self): + def _vitrage_type(self): return ZABBIX_DATASOURCE def _alarm_key(self, alarm): diff --git a/vitrage/datasources/zabbix/transformer.py b/vitrage/datasources/zabbix/transformer.py index c722f0f92..8b8860d44 100644 --- a/vitrage/datasources/zabbix/transformer.py +++ b/vitrage/datasources/zabbix/transformer.py @@ -46,10 +46,11 @@ class ZabbixTransformer(AlarmTransformerBase): update_timestamp = entity_event[ZProps.TIMESTAMP] - sample_timestamp = entity_event[DSProps.SAMPLE_DATE] + vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] - update_timestamp = self._format_update_timestamp(update_timestamp, - sample_timestamp) + update_timestamp = \ + self._format_update_timestamp(update_timestamp, + vitrage_sample_timestamp) zabbix_hostname = entity_event[ZProps.ZABBIX_RESOURCE_NAME] vitrage_hostname = entity_event[ZProps.RESOURCE_NAME] @@ -70,10 +71,10 @@ class ZabbixTransformer(AlarmTransformerBase): return graph_utils.create_vertex( self._create_entity_key(entity_event), - entity_category=EntityCategory.ALARM, - entity_type=entity_event[DSProps.ENTITY_TYPE], + vitrage_category=EntityCategory.ALARM, + vitrage_type=entity_event[DSProps.ENTITY_TYPE], + vitrage_sample_timestamp=vitrage_sample_timestamp, entity_state=entity_state, - sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata) @@ -121,5 +122,5 @@ class ZabbixTransformer(AlarmTransformerBase): ZProps.ZABBIX_TIMESTAMP_FORMAT, tbase.TIMESTAMP_FORMAT) - def get_type(self): + def get_vitrage_type(self): return ZABBIX_DATASOURCE diff --git a/vitrage/entity_graph/consistency/consistency_enforcer.py b/vitrage/entity_graph/consistency/consistency_enforcer.py index 23d22064c..49cd9c488 100644 --- a/vitrage/entity_graph/consistency/consistency_enforcer.py +++ b/vitrage/entity_graph/consistency/consistency_enforcer.py @@ -24,7 +24,8 @@ from vitrage.common.constants import GraphAction from vitrage.common.constants import VertexProperties as VProps from vitrage.datasources.consistency import CONSISTENCY_DATASOURCE from vitrage.datasources import OPENSTACK_CLUSTER -from vitrage.evaluator.actions.evaluator_event_transformer import VITRAGE_TYPE +from vitrage.evaluator.actions.evaluator_event_transformer \ + import VITRAGE_DATASOURCE from vitrage.utils.datetime import utcnow LOG = log.getLogger(__name__) @@ -77,14 +78,14 @@ class ConsistencyEnforcer(object): try: LOG.debug('Consistency Periodic Process - Started') - # remove is_deleted=True entities + # remove vitrage_is_deleted=True entities old_deleted_entities = self._find_old_deleted_entities() LOG.debug('Found %s vertices to be deleted by consistency service' ': %s', len(old_deleted_entities), old_deleted_entities) self._push_events_to_queue(old_deleted_entities, GraphAction.REMOVE_DELETED_ENTITY) - # mark stale entities as is_deleted=True + # mark stale entities as vitrage_is_deleted=True stale_entities = self._find_stale_entities() LOG.debug('Found %s vertices to be marked as deleted by ' 'consistency service: %s', len(stale_entities), @@ -96,12 +97,13 @@ class ConsistencyEnforcer(object): 'Error in deleting vertices from entity_graph: %s', e) def _find_stale_entities(self): + vitrage_sample_tstmp = str(utcnow() - timedelta( + seconds=2 * self.conf.datasources.snapshots_interval)) query = { 'and': [ - {'!=': {VProps.TYPE: VITRAGE_TYPE}}, - {'<': {VProps.SAMPLE_TIMESTAMP: str(utcnow() - timedelta( - seconds=2 * self.conf.datasources.snapshots_interval))}}, - {'==': {VProps.IS_DELETED: False}} + {'!=': {VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE}}, + {'<': {VProps.VITRAGE_SAMPLE_TIMESTAMP: vitrage_sample_tstmp}}, + {'==': {VProps.VITRAGE_IS_DELETED: False}} ] } @@ -110,11 +112,12 @@ class ConsistencyEnforcer(object): return set(self._filter_vertices_to_be_deleted(vertices)) def _find_old_deleted_entities(self): + vitrage_sample_tstmp = str(utcnow() - timedelta( + seconds=self.conf.consistency.min_time_to_delete)) query = { 'and': [ - {'==': {VProps.IS_DELETED: True}}, - {'<': {VProps.SAMPLE_TIMESTAMP: str(utcnow() - timedelta( - seconds=self.conf.consistency.min_time_to_delete))}} + {'==': {VProps.VITRAGE_IS_DELETED: True}}, + {'<': {VProps.VITRAGE_SAMPLE_TIMESTAMP: vitrage_sample_tstmp}} ] } @@ -125,9 +128,9 @@ class ConsistencyEnforcer(object): def _find_old_deduced_alarms(self, timestamp): query = { 'and': [ - {'==': {VProps.CATEGORY: EntityCategory.ALARM}}, - {'==': {VProps.TYPE: VITRAGE_TYPE}}, - {'<': {VProps.SAMPLE_TIMESTAMP: timestamp}} + {'==': {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM}}, + {'==': {VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE}}, + {'<': {VProps.VITRAGE_SAMPLE_TIMESTAMP: timestamp}} ] } return self.graph.get_vertices(query_dict=query) @@ -159,8 +162,8 @@ class ConsistencyEnforcer(object): DSProps.EVENT_TYPE: action, VProps.VITRAGE_ID: vertex[VProps.VITRAGE_ID], VProps.ID: vertex.get(VProps.ID, None), - VProps.TYPE: vertex[VProps.TYPE], - VProps.CATEGORY: vertex[VProps.CATEGORY], + VProps.VITRAGE_TYPE: vertex[VProps.VITRAGE_TYPE], + VProps.VITRAGE_CATEGORY: vertex[VProps.VITRAGE_CATEGORY], VProps.IS_REAL_VITRAGE_ID: True } self.evaluator_queue.put(event) @@ -169,8 +172,8 @@ class ConsistencyEnforcer(object): def _filter_vertices_to_be_deleted(vertices): return list(filter( lambda ver: - not (ver[VProps.CATEGORY] == EntityCategory.RESOURCE and - ver[VProps.TYPE] == OPENSTACK_CLUSTER), vertices)) + not (ver[VProps.VITRAGE_CATEGORY] == EntityCategory.RESOURCE and + ver[VProps.VITRAGE_TYPE] == OPENSTACK_CLUSTER), vertices)) def _wait_for_action(self, function): count_retries = 0 diff --git a/vitrage/entity_graph/mappings/alarm_handler.py b/vitrage/entity_graph/mappings/alarm_handler.py index 6f52579a1..78f6cc062 100644 --- a/vitrage/entity_graph/mappings/alarm_handler.py +++ b/vitrage/entity_graph/mappings/alarm_handler.py @@ -30,10 +30,10 @@ class AlarmHandler(HandlerBase): return [VProps.SEVERITY] def set_operational_value(self, new_vertex, operational_value): - new_vertex[VProps.OPERATIONAL_SEVERITY] = operational_value + new_vertex[VProps.VITRAGE_OPERATIONAL_SEVERITY] = operational_value def set_aggregated_value(self, new_vertex, aggregated_value): - new_vertex[VProps.AGGREGATED_SEVERITY] = aggregated_value + new_vertex[VProps.VITRAGE_AGGREGATED_SEVERITY] = aggregated_value def default_values(self): return [(None, OperationalAlarmSeverity.NA, 0)] diff --git a/vitrage/entity_graph/mappings/datasource_info_mapper.py b/vitrage/entity_graph/mappings/datasource_info_mapper.py index 1b06ccbcc..3acaa4e5e 100644 --- a/vitrage/entity_graph/mappings/datasource_info_mapper.py +++ b/vitrage/entity_graph/mappings/datasource_info_mapper.py @@ -39,7 +39,7 @@ class DatasourceInfoMapper(object): self.category_normalizer = self._init_category_normalizer() self.datasources_state_confs = self._load_state_configurations() - def operational_state(self, datasource_name, state): + def vitrage_operational_state(self, datasource_name, state): return self._get_state_data(datasource_name, state, self.OPERATIONAL_VALUES) @@ -49,20 +49,20 @@ class DatasourceInfoMapper(object): state, self.PRIORITY_VALUES) - def aggregated_state(self, new_vertex, graph_vertex): - datasource_name = new_vertex[VProps.TYPE] if \ - VProps.TYPE in new_vertex.properties else \ - graph_vertex[VProps.TYPE] + def vitrage_aggregated_state(self, new_vertex, graph_vertex): + datasource_name = new_vertex[VProps.VITRAGE_TYPE] if \ + VProps.VITRAGE_TYPE in new_vertex.properties else \ + graph_vertex[VProps.VITRAGE_TYPE] - category = new_vertex[VProps.CATEGORY] if \ - VProps.CATEGORY in new_vertex.properties else \ - graph_vertex[VProps.CATEGORY] + vitrage_category = new_vertex[VProps.VITRAGE_CATEGORY] if \ + VProps.VITRAGE_CATEGORY in new_vertex.properties else \ + graph_vertex[VProps.VITRAGE_CATEGORY] if datasource_name in self.datasources_state_confs or \ datasource_name not in self.conf.datasources.types: value_properties = \ - self.category_normalizer[category].value_properties() - operational_state, aggregated_state, state_priority = \ + self.category_normalizer[vitrage_category].value_properties() + vitrage_operational_state, vitrage_aggregated_state, state_priority = \ self._find_operational_state_and_priority(new_vertex, graph_vertex, value_properties[0], @@ -76,18 +76,18 @@ class DatasourceInfoMapper(object): property_, datasource_name) if t_state_priority > state_priority: - operational_state = t_operational_state - aggregated_state = t_aggregated_state + vitrage_operational_state = t_operational_state + vitrage_aggregated_state = t_aggregated_state state_priority = t_state_priority - self.category_normalizer[category].set_aggregated_value( - new_vertex, aggregated_state) - self.category_normalizer[category].set_operational_value( - new_vertex, operational_state) + self.category_normalizer[vitrage_category].set_aggregated_value( + new_vertex, vitrage_aggregated_state) + self.category_normalizer[vitrage_category].set_operational_value( + new_vertex, vitrage_operational_state) else: - self.category_normalizer[category].set_aggregated_value( + self.category_normalizer[vitrage_category].set_aggregated_value( new_vertex, self.UNDEFINED_DATASOURCE) - self.category_normalizer[category].set_operational_value( + self.category_normalizer[vitrage_category].set_operational_value( new_vertex, self.UNDEFINED_DATASOURCE) def get_datasource_priorities(self, datasource_name=None): @@ -140,7 +140,7 @@ class DatasourceInfoMapper(object): states = {} priorities = {} config = file_utils.load_yaml_file(full_path, with_exception=True) - category = config['category'] + vitrage_category = config['category'] for item in config['values']: aggregated_values = item['aggregated values'] @@ -153,9 +153,9 @@ class DatasourceInfoMapper(object): states[original_value.upper()] = operational_value priorities[original_value.upper()] = priority_value - self._check_validity(category, states, priorities, full_path) + self._check_validity(vitrage_category, states, priorities, full_path) - self._add_default_states(states, priorities, category) + self._add_default_states(states, priorities, vitrage_category) return states, priorities @@ -208,13 +208,13 @@ class DatasourceInfoMapper(object): upper_state = state if not state else state.upper() - operational_state = self.operational_state(datasource_name, - upper_state) + vitrage_operational_state = self.vitrage_operational_state( + datasource_name, upper_state) state_priority = self.state_priority(datasource_name, upper_state) - return operational_state, upper_state, state_priority + return vitrage_operational_state, upper_state, state_priority @staticmethod def _get_all_local_variables_of_class(class_instance): diff --git a/vitrage/entity_graph/mappings/resource_handler.py b/vitrage/entity_graph/mappings/resource_handler.py index 4b4c49277..dd691c1e7 100644 --- a/vitrage/entity_graph/mappings/resource_handler.py +++ b/vitrage/entity_graph/mappings/resource_handler.py @@ -29,11 +29,12 @@ class ResourceHandler(HandlerBase): def value_properties(self): return [VProps.STATE, VProps.VITRAGE_STATE] - def set_operational_value(self, new_vertex, operational_value): - new_vertex[VProps.OPERATIONAL_STATE] = operational_value + def set_operational_value(self, new_vertex, vitrage_operational_value): + new_vertex[VProps.VITRAGE_OPERATIONAL_STATE] = \ + vitrage_operational_value - def set_aggregated_value(self, new_vertex, aggregated_value): - new_vertex[VProps.AGGREGATED_STATE] = aggregated_value + def set_aggregated_value(self, new_vertex, vitrage_aggregated_value): + new_vertex[VProps.VITRAGE_AGGREGATED_STATE] = vitrage_aggregated_value def default_values(self): return [(None, OperationalResourceState.NA, 0)] diff --git a/vitrage/entity_graph/processor/notifier.py b/vitrage/entity_graph/processor/notifier.py index 10797c0ce..a343f1a56 100644 --- a/vitrage/entity_graph/processor/notifier.py +++ b/vitrage/entity_graph/processor/notifier.py @@ -55,7 +55,7 @@ class GraphNotifier(object): change that happened. None if the element was just created. :param current: The graph element (vertex or edge) after the change that happened. Deleted elements should arrive with the - is_deleted property set to True + vitrage_is_deleted property set to True :param graph: The graph """ notification_types = _get_notification_type(before, current, is_vertex) @@ -109,8 +109,8 @@ def _get_notification_type(before, current, is_vertex): def _is_active_deduced_alarm(vertex): if not vertex: return False - if vertex.get(VProps.CATEGORY) == EntityCategory.ALARM and \ - vertex.get(VProps.TYPE) == evaluator.VITRAGE_TYPE: + if vertex.get(VProps.VITRAGE_CATEGORY) == EntityCategory.ALARM and \ + vertex.get(VProps.VITRAGE_TYPE) == evaluator.VITRAGE_DATASOURCE: return _is_relevant_vertex(vertex) return False @@ -118,14 +118,14 @@ def _is_active_deduced_alarm(vertex): def _is_marked_down(vertex): if not vertex: return False - if vertex.get(VProps.CATEGORY) == EntityCategory.RESOURCE and \ + if vertex.get(VProps.VITRAGE_CATEGORY) == EntityCategory.RESOURCE and \ vertex.get(VProps.IS_MARKED_DOWN) is True: return _is_relevant_vertex(vertex) return False def _is_relevant_vertex(vertex): - if vertex.get(VProps.IS_DELETED, False) or \ - vertex.get(VProps.IS_PLACEHOLDER, False): + if vertex.get(VProps.VITRAGE_IS_DELETED, False) or \ + vertex.get(VProps.VITRAGE_IS_PLACEHOLDER, False): return False return True diff --git a/vitrage/entity_graph/processor/processor.py b/vitrage/entity_graph/processor/processor.py index 1833ab247..1e9fa97b9 100644 --- a/vitrage/entity_graph/processor/processor.py +++ b/vitrage/entity_graph/processor/processor.py @@ -64,7 +64,7 @@ class Processor(processor.ProcessorBase): self._enrich_event(event) entity = self.transformer_manager.transform(event) - self._calculate_aggregated_state(entity.vertex, entity.action) + self._calculate_vitrage_aggregated_state(entity.vertex, entity.action) self.actions[entity.action](entity.vertex, entity.neighbors) def create_entity(self, new_vertex, neighbors): @@ -198,7 +198,7 @@ class Processor(processor.ProcessorBase): def remove_deleted_entity(self, vertex, neighbors): """Removes the deleted vertex from the entity graph - Removes vertex that it's is_deleted value is True + Removes vertex that it's vitrage_is_deleted value is True :param vertex: The vertex to be removed from the graph :type vertex: Vertex @@ -218,7 +218,8 @@ class Processor(processor.ProcessorBase): LOG.warning("Delete event arrived on invalid resource: %s", vertex) def handle_end_message(self, vertex, neighbors): - self.initialization_status.end_messages[vertex[VProps.TYPE]] = True + self.initialization_status.end_messages[vertex[VProps.VITRAGE_TYPE]] \ + = True if len(self.initialization_status.end_messages) == \ len(self.conf.datasources.types): @@ -258,7 +259,7 @@ class Processor(processor.ProcessorBase): if not graph_vertex or not PUtils.is_deleted(graph_vertex): if PUtils.can_update_vertex(graph_vertex, vertex): LOG.debug("Updates vertex: %s", vertex) - self._calculate_aggregated_state(vertex, action) + self._calculate_vitrage_aggregated_state(vertex, action) PUtils.update_entity_graph_vertex(self.entity_graph, graph_vertex, vertex) @@ -336,7 +337,7 @@ class Processor(processor.ProcessorBase): GraphAction.END_MESSAGE: self.handle_end_message } - def _calculate_aggregated_state(self, vertex, action): + def _calculate_vitrage_aggregated_state(self, vertex, action): LOG.debug("calculate event state") try: @@ -359,7 +360,7 @@ class Processor(processor.ProcessorBase): action, vertex) return None - self.state_manager.aggregated_state(vertex, graph_vertex) + self.state_manager.vitrage_aggregated_state(vertex, graph_vertex) except Exception as e: LOG.exception("Calculate aggregated state failed - %s", e) @@ -408,7 +409,7 @@ class Processor(processor.ProcessorBase): and not include_deleted): vitrage_id = uuidutils.generate_uuid() - if vertex[VProps.TYPE] == OPENSTACK_CLUSTER: + if vertex[VProps.VITRAGE_TYPE] == OPENSTACK_CLUSTER: self.entity_graph.root_id = vitrage_id else: vitrage_id = graph_vertex[VProps.VITRAGE_ID] @@ -429,9 +430,10 @@ class Processor(processor.ProcessorBase): edge.source_id = vitrage_id edge.target_id = neighbor_vertex.vertex_id - def _add_resource_details_to_alarm(self, vertex, neighbors): + @staticmethod + def _add_resource_details_to_alarm(vertex, neighbors): - if not vertex.get(VProps.CATEGORY) == EntityCategory.ALARM \ + if not vertex.get(VProps.VITRAGE_CATEGORY) == EntityCategory.ALARM \ or not neighbors: return @@ -441,11 +443,12 @@ class Processor(processor.ProcessorBase): for neighbor in neighbors: - if neighbor.vertex.get(VProps.CATEGORY) == EntityCategory.RESOURCE: + if neighbor.vertex.get(VProps.VITRAGE_CATEGORY) == \ + EntityCategory.RESOURCE: vertex.properties[VProps.VITRAGE_RESOURCE_ID] = \ neighbor.vertex.vertex_id vertex.properties[VProps.VITRAGE_RESOURCE_TYPE] = \ - neighbor.vertex.get(VProps.TYPE) + neighbor.vertex.get(VProps.VITRAGE_TYPE) def _get_single_graph_vertex_by_props(self, vertex, include_deleted=False): """Returns a single vertex by it's defining properties @@ -470,7 +473,7 @@ class Processor(processor.ProcessorBase): graph_vertices.append(tmp_vertex) else: for tmp_vertex in received_graph_vertices: - if not tmp_vertex.get(VProps.IS_DELETED, False): + if not tmp_vertex.get(VProps.VITRAGE_IS_DELETED, False): graph_vertices.append(tmp_vertex) if len(graph_vertices) > 1: diff --git a/vitrage/entity_graph/processor/processor_utils.py b/vitrage/entity_graph/processor/processor_utils.py index 08d6bf899..9a9964f59 100644 --- a/vitrage/entity_graph/processor/processor_utils.py +++ b/vitrage/entity_graph/processor/processor_utils.py @@ -28,12 +28,12 @@ LOG = log.getLogger(__name__) def is_newer_vertex(prev_vertex, new_vertex): - prev_timestamp = prev_vertex.get(VProps.SAMPLE_TIMESTAMP) + prev_timestamp = prev_vertex.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) if not prev_timestamp: return True prev_time = parser.parse(prev_timestamp) - new_timestamp = new_vertex[VProps.SAMPLE_TIMESTAMP] + new_timestamp = new_vertex[VProps.VITRAGE_SAMPLE_TIMESTAMP] if not new_timestamp: return False new_time = parser.parse(new_timestamp) @@ -43,17 +43,19 @@ def is_newer_vertex(prev_vertex, new_vertex): def is_deleted(item): return item and \ - (isinstance(item, Vertex) and item.get(VProps.IS_DELETED, False)) or\ - (isinstance(item, Edge) and item.get(EProps.IS_DELETED, False)) + (isinstance(item, Vertex) and + item.get(VProps.VITRAGE_IS_DELETED, False)) or \ + (isinstance(item, Edge) and + item.get(EProps.VITRAGE_IS_DELETED, False)) def mark_deleted(g, item): if isinstance(item, Vertex): - item[VProps.IS_DELETED] = True - item[VProps.SAMPLE_TIMESTAMP] = str(utcnow()) + item[VProps.VITRAGE_IS_DELETED] = True + item[VProps.VITRAGE_SAMPLE_TIMESTAMP] = str(utcnow()) g.update_vertex(item) elif isinstance(item, Edge): - item[EProps.IS_DELETED] = True + item[EProps.VITRAGE_IS_DELETED] = True item[EProps.UPDATE_TIMESTAMP] = str(utcnow()) g.update_edge(item) @@ -61,7 +63,7 @@ def mark_deleted(g, item): def delete_placeholder_vertex(g, vertex): """Checks if it is a placeholder vertex, and if so deletes it """ - if not vertex[VProps.IS_PLACEHOLDER]: + if not vertex[VProps.VITRAGE_IS_PLACEHOLDER]: return if not any(True for neighbor_edge in g.get_edges(vertex.vertex_id) if not is_deleted(neighbor_edge)): @@ -79,29 +81,31 @@ def find_neighbor_types(neighbors): def get_vertex_types(vertex): - category = vertex[VProps.CATEGORY] - type_ = vertex[VProps.TYPE] - return category, type_ + vitrage_category = vertex[VProps.VITRAGE_CATEGORY] + vitrage_type = vertex[VProps.VITRAGE_TYPE] + return vitrage_category, vitrage_type def get_defining_properties(vertex): - if vertex.get(VProps.CATEGORY) == EntityCategory.ALARM: - dp = (vertex.get(VProps.TYPE), vertex.get(VProps.ID), + if vertex.get(VProps.VITRAGE_CATEGORY) == EntityCategory.ALARM: + dp = (vertex.get(VProps.VITRAGE_TYPE), vertex.get(VProps.ID), vertex.get(VProps.RESOURCE_ID), vertex.get(VProps.NAME)) else: - dp = (vertex.get(VProps.TYPE), vertex.get(VProps.ID)) + dp = (vertex.get(VProps.VITRAGE_TYPE), vertex.get(VProps.ID)) return hash(dp) def can_update_vertex(graph_vertex, new_vertex): - return (not graph_vertex) or (not new_vertex[VProps.IS_PLACEHOLDER]) + return (not graph_vertex) or \ + (not new_vertex[VProps.VITRAGE_IS_PLACEHOLDER]) def update_entity_graph_vertex(g, graph_vertex, updated_vertex): - if updated_vertex[VProps.IS_PLACEHOLDER] and \ - graph_vertex and not graph_vertex[VProps.IS_PLACEHOLDER]: + if updated_vertex[VProps.VITRAGE_IS_PLACEHOLDER] and \ + graph_vertex and not graph_vertex[VProps.VITRAGE_IS_PLACEHOLDER]: - updated_vertex[VProps.IS_PLACEHOLDER] = False - updated_vertex[VProps.IS_DELETED] = graph_vertex[VProps.IS_DELETED] + updated_vertex[VProps.VITRAGE_IS_PLACEHOLDER] = False + updated_vertex[VProps.VITRAGE_IS_DELETED] = \ + graph_vertex[VProps.VITRAGE_IS_DELETED] g.update_vertex(updated_vertex) diff --git a/vitrage/entity_graph/transformer_manager.py b/vitrage/entity_graph/transformer_manager.py index b2b29d6df..8301f6996 100644 --- a/vitrage/entity_graph/transformer_manager.py +++ b/vitrage/entity_graph/transformer_manager.py @@ -22,7 +22,8 @@ from vitrage.datasources.consistency import CONSISTENCY_DATASOURCE from vitrage.datasources.consistency.transformer import ConsistencyTransformer from vitrage.evaluator.actions.evaluator_event_transformer import \ EvaluatorEventTransformer -from vitrage.evaluator.actions.evaluator_event_transformer import VITRAGE_TYPE +from vitrage.evaluator.actions.evaluator_event_transformer \ + import VITRAGE_DATASOURCE from vitrage.utils import opt_exists LOG = logging.getLogger(__name__) @@ -53,7 +54,7 @@ class TransformerManager(object): LOG.exception('Failed to register transformer %s. ' 'Exception: %s', datasource_type, e) - transformers[VITRAGE_TYPE] = importutils.import_object( + transformers[VITRAGE_DATASOURCE] = importutils.import_object( "%s.%s" % (EvaluatorEventTransformer.__module__, EvaluatorEventTransformer.__name__), transformers, conf) diff --git a/vitrage/evaluator/actions/action_executor.py b/vitrage/evaluator/actions/action_executor.py index 37d18128b..805bab475 100644 --- a/vitrage/evaluator/actions/action_executor.py +++ b/vitrage/evaluator/actions/action_executor.py @@ -21,7 +21,8 @@ from vitrage.common.constants import DatasourceProperties as DSProps from vitrage.common.constants import VertexProperties as VProps from vitrage.evaluator.actions.base import ActionMode from vitrage.evaluator.actions.base import ActionType -from vitrage.evaluator.actions.evaluator_event_transformer import VITRAGE_TYPE +from vitrage.evaluator.actions.evaluator_event_transformer \ + import VITRAGE_DATASOURCE from vitrage.evaluator.actions.recipes.action_steps import ADD_EDGE from vitrage.evaluator.actions.recipes.action_steps import ADD_VERTEX from vitrage.evaluator.actions.recipes.action_steps import REMOVE_EDGE @@ -104,9 +105,9 @@ class ActionExecutor(object): def _add_default_properties(event): event[DSProps.DATASOURCE_ACTION] = AType.UPDATE - event[DSProps.ENTITY_TYPE] = VITRAGE_TYPE + event[DSProps.ENTITY_TYPE] = VITRAGE_DATASOURCE event[VProps.UPDATE_TIMESTAMP] = str(datetime_utils.utcnow(False)) - event[VProps.SAMPLE_TIMESTAMP] = str(datetime_utils.utcnow()) + event[VProps.VITRAGE_SAMPLE_TIMESTAMP] = str(datetime_utils.utcnow()) @staticmethod def _register_action_recipes(): diff --git a/vitrage/evaluator/actions/evaluator_event_transformer.py b/vitrage/evaluator/actions/evaluator_event_transformer.py index 9875ee795..64e366551 100644 --- a/vitrage/evaluator/actions/evaluator_event_transformer.py +++ b/vitrage/evaluator/actions/evaluator_event_transformer.py @@ -36,7 +36,7 @@ from vitrage.graph import Vertex LOG = logging.getLogger(__name__) -VITRAGE_TYPE = 'vitrage' +VITRAGE_DATASOURCE = 'vitrage' class EvaluatorEventTransformer(transformer_base.TransformerBase): @@ -63,8 +63,9 @@ class EvaluatorEventTransformer(transformer_base.TransformerBase): if event_type == UPDATE_VERTEX: properties = { VProps.UPDATE_TIMESTAMP: update_timestamp, - VProps.SAMPLE_TIMESTAMP: event[VProps.SAMPLE_TIMESTAMP], - VProps.IS_PLACEHOLDER: False, + VProps.VITRAGE_SAMPLE_TIMESTAMP: + event[VProps.VITRAGE_SAMPLE_TIMESTAMP], + VProps.VITRAGE_IS_PLACEHOLDER: False, VProps.RESOURCE_ID: event.get(TFields.TARGET) } if VProps.IS_REAL_VITRAGE_ID in event: @@ -89,9 +90,10 @@ class EvaluatorEventTransformer(transformer_base.TransformerBase): } return graph_utils.create_vertex( self._create_entity_key(event), - entity_category=EntityCategory.ALARM, - entity_type=VITRAGE_TYPE, - sample_timestamp=event[VProps.SAMPLE_TIMESTAMP], + vitrage_category=EntityCategory.ALARM, + vitrage_type=VITRAGE_DATASOURCE, + vitrage_sample_timestamp=event[ + VProps.VITRAGE_SAMPLE_TIMESTAMP], update_timestamp=update_timestamp, metadata=metadata) @@ -104,7 +106,6 @@ class EvaluatorEventTransformer(transformer_base.TransformerBase): return self._create_vitrage_neighbors(event) def _create_vitrage_neighbors(self, event): - event_type = event[EVALUATOR_EVENT_TYPE] timestamp = transformer_base.convert_timestamp_format( @@ -113,6 +114,7 @@ class EvaluatorEventTransformer(transformer_base.TransformerBase): ) if event_type in [ADD_EDGE, REMOVE_EDGE]: + relation_edge = graph_utils.create_edge( source_id=event[TFields.SOURCE], target_id=event[TFields.TARGET], @@ -122,6 +124,7 @@ class EvaluatorEventTransformer(transformer_base.TransformerBase): return [Neighbor(None, relation_edge)] if event_type == ADD_VERTEX: + relation_edge = graph_utils.create_edge( source_id=self._create_entity_key(event), target_id=event[TFields.TARGET], @@ -129,12 +132,13 @@ class EvaluatorEventTransformer(transformer_base.TransformerBase): update_timestamp=timestamp) neighbor_props = { - VProps.IS_PLACEHOLDER: True, + VProps.VITRAGE_IS_PLACEHOLDER: True, VProps.UPDATE_TIMESTAMP: timestamp, - VProps.SAMPLE_TIMESTAMP: event[VProps.SAMPLE_TIMESTAMP], + VProps.VITRAGE_SAMPLE_TIMESTAMP: + event[VProps.VITRAGE_SAMPLE_TIMESTAMP], VProps.IS_REAL_VITRAGE_ID: True, - VProps.TYPE: event[VProps.VITRAGE_RESOURCE_TYPE], - VProps.CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: event[VProps.VITRAGE_RESOURCE_TYPE], + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, } neighbor = Vertex(event[TFields.TARGET], neighbor_props) return [Neighbor(neighbor, relation_edge)] @@ -166,10 +170,10 @@ class EvaluatorEventTransformer(transformer_base.TransformerBase): return transformer_base.build_key(key_fields) def _key_values(self, *args): - return (EntityCategory.ALARM, VITRAGE_TYPE) + args + return (EntityCategory.ALARM, VITRAGE_DATASOURCE) + args def create_neighbor_placeholder_vertex(self, **kwargs): LOG.info('Evaluator does not create placeholders') - def get_type(self): - return VITRAGE_TYPE + def get_vitrage_type(self): + return VITRAGE_DATASOURCE diff --git a/vitrage/evaluator/actions/priority_tools.py b/vitrage/evaluator/actions/priority_tools.py index ad04a5f14..dbbc8cdb7 100644 --- a/vitrage/evaluator/actions/priority_tools.py +++ b/vitrage/evaluator/actions/priority_tools.py @@ -53,9 +53,9 @@ class SetStateTools(object): def get_score(self, action_info): state = action_info.specs.properties[TemplateFields.STATE].upper() target_resource = action_info.specs.targets[TemplateFields.TARGET] - target_type = target_resource[VProps.TYPE] - score_name = \ - target_type if target_type in self.scores else DEFAULT_INFO_MAPPER + target_vitrage_type = target_resource[VProps.VITRAGE_TYPE] + score_name = target_vitrage_type \ + if target_vitrage_type in self.scores else DEFAULT_INFO_MAPPER return self.scores[score_name].get(state, 0) @staticmethod diff --git a/vitrage/evaluator/actions/recipes/raise_alarm.py b/vitrage/evaluator/actions/recipes/raise_alarm.py index d2577c015..e009a7dd2 100644 --- a/vitrage/evaluator/actions/recipes/raise_alarm.py +++ b/vitrage/evaluator/actions/recipes/raise_alarm.py @@ -58,7 +58,7 @@ class RaiseAlarm(base.Recipe): target_resource = action_spec.targets[TFields.TARGET] add_vertex_params = { TFields.TARGET: target_resource.vertex_id, - VProps.VITRAGE_RESOURCE_TYPE: target_resource[VProps.TYPE], + VProps.VITRAGE_RESOURCE_TYPE: target_resource[VProps.VITRAGE_TYPE], } add_vertex_params.update(action_spec.properties) diff --git a/vitrage/evaluator/equivalence_data.py b/vitrage/evaluator/equivalence_data.py index 72697a3a3..bc7a6932d 100644 --- a/vitrage/evaluator/equivalence_data.py +++ b/vitrage/evaluator/equivalence_data.py @@ -14,6 +14,7 @@ from vitrage.common.constants import TemplateTopologyFields from vitrage.common.exception import VitrageError +from vitrage.evaluator.template_data import TemplateData class Fields(TemplateTopologyFields): @@ -51,7 +52,9 @@ class EquivalenceData(object): for entity_def in equivalent_entities: entity_props = {(k, v) for k, v in entity_def[Fields.ENTITY].items()} - entity_key = frozenset(entity_props) + + entity_key = frozenset( + TemplateData._convert_props_with_set(entity_props)) if entity_key in equivalence: raise VitrageError('duplicated entities found in ' 'equivalence') diff --git a/vitrage/evaluator/scenario_evaluator.py b/vitrage/evaluator/scenario_evaluator.py index 88b298611..62f495ef6 100644 --- a/vitrage/evaluator/scenario_evaluator.py +++ b/vitrage/evaluator/scenario_evaluator.py @@ -77,7 +77,7 @@ class ScenarioEvaluator(object): change that happened. None if the element was just created. :param current: The graph element (vertex or edge) after the change that happened. Deleted elements should arrive with the - is_deleted property set to True + vitrage_is_deleted property set to True """ if not self.enabled: @@ -118,8 +118,8 @@ class ScenarioEvaluator(object): def _get_element_scenarios(self, element, is_vertex): if not element \ - or element.get(VProps.IS_DELETED) \ - or element.get(EProps.IS_DELETED): + or element.get(VProps.VITRAGE_IS_DELETED) \ + or element.get(EProps.VITRAGE_IS_DELETED): return [] elif is_vertex: return self._scenario_repo.get_scenarios_by_vertex(element) @@ -310,8 +310,8 @@ class ScenarioEvaluator(object): connected_component = self.get_connected_component(subgraph, action_target) - # change the is_deleted and negative_condition props to false when - # is_switch_mode=true so that when we have an event on a + # change the vitrage_is_deleted and negative_condition props to + # false when is_switch_mode=true so that when we have an event on a # negative_condition=true edge it will find the correct subgraph self._switch_edge_negative_props(is_switch_mode, scenario_edge, subgraph, False) @@ -349,7 +349,7 @@ class ScenarioEvaluator(object): status): if is_switch_mode: scenario_edge.edge[NEG_CONDITION] = status - scenario_edge.edge[EProps.IS_DELETED] = status + scenario_edge.edge[EProps.VITRAGE_IS_DELETED] = status subgraph.update_edge(scenario_edge.edge) @staticmethod diff --git a/vitrage/evaluator/template_data.py b/vitrage/evaluator/template_data.py index 97d5ef57c..13bd2b784 100644 --- a/vitrage/evaluator/template_data.py +++ b/vitrage/evaluator/template_data.py @@ -52,6 +52,19 @@ def copy_edge_desc(edge_desc): # noinspection PyAttributeOutsideInit class TemplateData(object): + PROPS_CONVERSION = { + 'category': VProps.VITRAGE_CATEGORY, + 'type': VProps.VITRAGE_TYPE, + 'resource_id': VProps.VITRAGE_RESOURCE_ID, + 'sample_timestamp': VProps.VITRAGE_SAMPLE_TIMESTAMP, + 'is_deleted': VProps.VITRAGE_IS_DELETED, + 'is_placeholder': VProps.VITRAGE_IS_PLACEHOLDER, + 'aggregated_state': VProps.VITRAGE_AGGREGATED_STATE, + 'operational_state': VProps.VITRAGE_OPERATIONAL_STATE, + 'aggregated_severity': VProps.VITRAGE_AGGREGATED_SEVERITY, + 'operational_severity': VProps.VITRAGE_OPERATIONAL_SEVERITY + } + def __init__(self, template_def): self.name = template_def[TFields.METADATA][TFields.NAME] @@ -105,7 +118,8 @@ class TemplateData(object): entity_dict = entity_def[TFields.ENTITY] template_id = entity_dict[TFields.TEMPLATE_ID] - properties = self._extract_properties(entity_dict) + properties = self._convert_properties_with_dictionary( + self._extract_properties(entity_dict)) entities[template_id] = Vertex(template_id, properties) return entities @@ -143,6 +157,24 @@ class TemplateData(object): return dict((key, var_dict[key]) for key in var_dict if key not in ignore_ids) + @staticmethod + def _convert_props_with_set(properties): + converted_properties = set() + for key, value in properties: + new_key = TemplateData.PROPS_CONVERSION[key] if key in \ + TemplateData.PROPS_CONVERSION else key + converted_properties.add((new_key, value)) + return converted_properties + + @staticmethod + def _convert_properties_with_dictionary(properties): + converted_properties = {} + for key, value in properties.items(): + new_key = TemplateData.PROPS_CONVERSION[key] if key in \ + TemplateData.PROPS_CONVERSION else key + converted_properties[new_key] = value + return converted_properties + def _build_scenarios(self, scenarios_defs): scenarios = [] @@ -347,14 +379,14 @@ class TemplateData(object): variable, var_type = extract_var(term.symbol_name) if var_type == ENTITY: vertex = variable.copy() - vertex[VProps.IS_DELETED] = False - vertex[VProps.IS_PLACEHOLDER] = False + vertex[VProps.VITRAGE_IS_DELETED] = False + vertex[VProps.VITRAGE_IS_PLACEHOLDER] = False condition_g.add_vertex(vertex) else: # type = relationship - # prevent overwritten of NEG_CONDITION and IS_DELETED - # property when there are both "not A" and "A" in same - # template + # prevent overwritten of NEG_CONDITION and + # VITRAGE_IS_DELETED property when there are both "not A" + # and "A" in same template edge_desc = copy_edge_desc(variable) cls._set_edge_relationship_info(edge_desc, term.positive) cls._add_edge_relationship(condition_g, edge_desc) @@ -366,15 +398,15 @@ class TemplateData(object): is_positive_condition): if not is_positive_condition: edge_description.edge[NEG_CONDITION] = True - edge_description.edge[EProps.IS_DELETED] = True + edge_description.edge[EProps.VITRAGE_IS_DELETED] = True else: - edge_description.edge[EProps.IS_DELETED] = False + edge_description.edge[EProps.VITRAGE_IS_DELETED] = False edge_description.edge[NEG_CONDITION] = False - edge_description.source[VProps.IS_DELETED] = False - edge_description.source[VProps.IS_PLACEHOLDER] = False - edge_description.target[VProps.IS_DELETED] = False - edge_description.target[VProps.IS_PLACEHOLDER] = False + edge_description.source[VProps.VITRAGE_IS_DELETED] = False + edge_description.source[VProps.VITRAGE_IS_PLACEHOLDER] = False + edge_description.target[VProps.VITRAGE_IS_DELETED] = False + edge_description.target[VProps.VITRAGE_IS_PLACEHOLDER] = False @staticmethod def _add_edge_relationship(condition_graph, edge_description): diff --git a/vitrage/evaluator/template_validation/template_content_validator.py b/vitrage/evaluator/template_validation/template_content_validator.py index e0b7bb71f..3fa55d197 100644 --- a/vitrage/evaluator/template_validation/template_content_validator.py +++ b/vitrage/evaluator/template_validation/template_content_validator.py @@ -316,12 +316,12 @@ def _validate_template_id(definitions_index, id_to_check): return get_correct_result(RESULT_DESCRIPTION) -def _validate_entity_category(entity_to_check, category): +def _validate_entity_category(entity_to_check, vitrage_category): if TemplateFields.CATEGORY not in entity_to_check \ - or entity_to_check[TemplateFields.CATEGORY] != category: + or entity_to_check[TemplateFields.CATEGORY] != vitrage_category: msg = status_msgs[132] + ' expect %s to be %s' \ - % (entity_to_check, category) + % (entity_to_check, vitrage_category) LOG.error('%s status code: %s' % (msg, 132)) return get_fault_result(RESULT_DESCRIPTION, 132, msg) diff --git a/vitrage/graph/algo_driver/networkx_algorithm.py b/vitrage/graph/algo_driver/networkx_algorithm.py index 5b15f3aeb..cbaa25c81 100644 --- a/vitrage/graph/algo_driver/networkx_algorithm.py +++ b/vitrage/graph/algo_driver/networkx_algorithm.py @@ -191,7 +191,8 @@ class NXAlgorithm(GraphAlgorithm): has real neighbors in the entity graph. """ if self.graph.neighbors(ge_v_id, - edge_attr_filter={EProps.IS_DELETED: False}): + edge_attr_filter={EProps.VITRAGE_IS_DELETED: + False}): template_vertex = subgraph.get_vertex(sge_v_id) graph_vertex = self.graph.get_vertex(ge_v_id) match = Mapping(template_vertex, graph_vertex, True) diff --git a/vitrage/graph/query.py b/vitrage/graph/query.py index 89b0b5e6e..3ba65c3ab 100644 --- a/vitrage/graph/query.py +++ b/vitrage/graph/query.py @@ -42,18 +42,18 @@ def create_predicate(query_dict): -------------- query_dict = { 'and': [ - {'==': {'TYPE': 'ALARM'}}, + {'==': {'CATEGORY': 'ALARM'}}, {'or': [ {'>': {'TIME': 150}}, - {'==': {'IS_DELETED': True}} + {'==': {'VITRAGE_IS_DELETED': True}} ]} ] } Example Output: -------------- - lambda item: ((item['TYPE']== 'ALARM') and - ((item['TIME']> 150) or (item['IS_DELETED']== True))) + lambda item: ((item['CATEGORY']== 'ALARM') and + ((item['TIME']> 150) or (item['VITRAGE_IS_DELETED']== True))) Example Usage: -------------- diff --git a/vitrage/graph/utils.py b/vitrage/graph/utils.py index 18871cf3c..9f5043a49 100644 --- a/vitrage/graph/utils.py +++ b/vitrage/graph/utils.py @@ -19,14 +19,14 @@ from vitrage.graph.driver.elements import Vertex def create_vertex(vitrage_id, + vitrage_category=None, + vitrage_type=None, + vitrage_sample_timestamp=None, + vitrage_is_deleted=False, + vitrage_is_placeholder=False, entity_id=None, - entity_category=None, - entity_type=None, entity_state=None, - is_deleted=False, - sample_timestamp=None, update_timestamp=None, - is_placeholder=False, project_id=None, metadata=None): """A builder to create a vertex @@ -35,22 +35,22 @@ def create_vertex(vitrage_id, :type vitrage_id: str :param entity_id: :type entity_id: str - :param entity_category: - :type entity_category: str - :param entity_type: - :type entity_type: str + :param vitrage_category: + :type vitrage_category: str + :param vitrage_type: + :type vitrage_type: str :param entity_state: :type entity_state: str - :param is_deleted: - :type is_deleted: boolean + :param vitrage_is_deleted: + :type vitrage_is_deleted: boolean :param update_timestamp: :type update_timestamp: str - :param sample_timestamp: - :type sample_timestamp: str + :param vitrage_sample_timestamp: + :type vitrage_sample_timestamp: str :param metadata: :type metadata: dict - :param is_placeholder: - :type is_placeholder: boolean + :param vitrage_is_placeholder: + :type vitrage_is_placeholder: boolean :param project_id: :type project_id: str :return: @@ -60,12 +60,12 @@ def create_vertex(vitrage_id, properties = { VConst.ID: entity_id, VConst.STATE: entity_state, - VConst.TYPE: entity_type, - VConst.CATEGORY: entity_category, - VConst.IS_DELETED: is_deleted, + VConst.VITRAGE_TYPE: vitrage_type, + VConst.VITRAGE_CATEGORY: vitrage_category, + VConst.VITRAGE_IS_DELETED: vitrage_is_deleted, VConst.UPDATE_TIMESTAMP: update_timestamp, - VConst.SAMPLE_TIMESTAMP: sample_timestamp, - VConst.IS_PLACEHOLDER: is_placeholder, + VConst.VITRAGE_SAMPLE_TIMESTAMP: vitrage_sample_timestamp, + VConst.VITRAGE_IS_PLACEHOLDER: vitrage_is_placeholder, VConst.VITRAGE_ID: vitrage_id, VConst.PROJECT_ID: project_id } @@ -80,7 +80,7 @@ def create_vertex(vitrage_id, def create_edge(source_id, target_id, relationship_type, - is_deleted=False, + vitrage_is_deleted=False, update_timestamp=None, metadata=None): """A builder to create an edge @@ -92,8 +92,8 @@ def create_edge(source_id, :type target_id: str :param relationship_type: :type relationship_type: str - :param is_deleted: - :type is_deleted: str + :param vitrage_is_deleted: + :type vitrage_is_deleted: str :param metadata: :type metadata: dict :return: @@ -101,7 +101,7 @@ def create_edge(source_id, """ properties = { EConst.UPDATE_TIMESTAMP: update_timestamp, - EConst.IS_DELETED: is_deleted, + EConst.VITRAGE_IS_DELETED: vitrage_is_deleted, EConst.RELATIONSHIP_TYPE: relationship_type, } if metadata: diff --git a/vitrage/notifier/plugins/nova/nova_notifier.py b/vitrage/notifier/plugins/nova/nova_notifier.py index a9270959d..411fc4a13 100644 --- a/vitrage/notifier/plugins/nova/nova_notifier.py +++ b/vitrage/notifier/plugins/nova/nova_notifier.py @@ -33,7 +33,7 @@ class NovaNotifier(NotifierBase): self.client = os_clients.nova_client(conf) def process_event(self, data, event_type): - if data and data.get(VProps.TYPE) == NOVA_HOST_DATASOURCE: + if data and data.get(VProps.VITRAGE_TYPE) == NOVA_HOST_DATASOURCE: if event_type == NotifierEventTypes.ACTIVATE_MARK_DOWN_EVENT: self._mark_host_down(data.get(VProps.ID), True) elif event_type == NotifierEventTypes.DEACTIVATE_MARK_DOWN_EVENT: diff --git a/vitrage/notifier/plugins/snmp/snmp_sender.py b/vitrage/notifier/plugins/snmp/snmp_sender.py index 6b8f04dea..8846f86d4 100644 --- a/vitrage/notifier/plugins/snmp/snmp_sender.py +++ b/vitrage/notifier/plugins/snmp/snmp_sender.py @@ -151,7 +151,7 @@ class SnmpSender(SnmpSenderBase): if not severity_mapping: return None - alarm_severity = alert_values.get(VProps.OPERATIONAL_SEVERITY) + alarm_severity = alert_values.get(VProps.VITRAGE_OPERATIONAL_SEVERITY) state = alert_values.get(VProps.STATE) if state in severity_mapping: diff --git a/vitrage/tests/functional/api_handler/test_apis.py b/vitrage/tests/functional/api_handler/test_apis.py index dc00ec97d..22bac4dcb 100644 --- a/vitrage/tests/functional/api_handler/test_apis.py +++ b/vitrage/tests/functional/api_handler/test_apis.py @@ -18,6 +18,7 @@ from vitrage.api_handler.apis.alarm import AlarmApis from vitrage.api_handler.apis.rca import RcaApis from vitrage.api_handler.apis.resource import ResourceApis from vitrage.api_handler.apis.topology import TopologyApis +from vitrage.common.constants import EdgeLabel from vitrage.common.constants import EntityCategory from vitrage.common.constants import VertexProperties as VProps from vitrage.datasources import NOVA_HOST_DATASOURCE @@ -370,7 +371,8 @@ class TestApis(TestEntityGraphUnitBase): tmp_project_id = alarm.get(VProps.PROJECT_ID, None) condition = True if check_alarm_category: - condition = alarm[VProps.CATEGORY] == EntityCategory.ALARM + condition = \ + alarm[VProps.VITRAGE_CATEGORY] == EntityCategory.ALARM if project_id: condition = condition and \ (not tmp_project_id or @@ -381,11 +383,12 @@ class TestApis(TestEntityGraphUnitBase): resource_type, project_id=None): self.assertEqual(resource[VProps.VITRAGE_ID], vitrage_id) self.assertEqual(resource[VProps.ID], vitrage_id) - self.assertEqual(resource[VProps.CATEGORY], EntityCategory.RESOURCE) - self.assertEqual(resource[VProps.TYPE], resource_type) + self.assertEqual(resource[VProps.VITRAGE_CATEGORY], + EntityCategory.RESOURCE) + self.assertEqual(resource[VProps.VITRAGE_TYPE], resource_type) self.assertEqual(resource[VProps.STATE], 'active') - self.assertFalse(resource[VProps.IS_DELETED]) - self.assertFalse(resource[VProps.IS_PLACEHOLDER]) + self.assertFalse(resource[VProps.VITRAGE_IS_DELETED]) + self.assertFalse(resource[VProps.VITRAGE_IS_PLACEHOLDER]) if project_id: self.assertEqual(resource[VProps.PROJECT_ID], project_id) @@ -413,98 +416,98 @@ class TestApis(TestEntityGraphUnitBase): alarm_on_host_vertex = self._create_alarm( 'alarm_on_host', 'alarm_on_host', - metadata={'type': 'nova.host', - 'name': 'host_1', - 'resource_id': 'host_1'}) + metadata={VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE, + VProps.NAME: 'host_1', + VProps.RESOURCE_ID: 'host_1'}) alarm_on_instance_1_vertex = self._create_alarm( 'alarm_on_instance_1', 'deduced_alarm', project_id='project_1', - metadata={'type': 'nova.instance', - 'name': 'instance_1', - 'resource_id': 'sdg7849ythksjdg'}) + metadata={VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE, + VProps.NAME: 'instance_1', + VProps.RESOURCE_ID: 'sdg7849ythksjdg'}) alarm_on_instance_2_vertex = self._create_alarm( 'alarm_on_instance_2', 'deduced_alarm', - metadata={'type': 'nova.instance', - 'name': 'instance_2', - 'resource_id': 'nbfhsdugf'}) + metadata={VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE, + VProps.NAME: 'instance_2', + VProps.RESOURCE_ID: 'nbfhsdugf'}) alarm_on_instance_3_vertex = self._create_alarm( 'alarm_on_instance_3', 'deduced_alarm', project_id='project_2', - metadata={'type': 'nova.instance', - 'name': 'instance_3', - 'resource_id': 'nbffhsdasdugf'}) + metadata={VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE, + VProps.NAME: 'instance_3', + VProps.RESOURCE_ID: 'nbffhsdasdugf'}) alarm_on_instance_4_vertex = self._create_alarm( 'alarm_on_instance_4', 'deduced_alarm', - metadata={'type': 'nova.instance', - 'name': 'instance_4', - 'resource_id': 'ngsuy76hgd87f'}) + metadata={VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE, + VProps.NAME: 'instance_4', + VProps.RESOURCE_ID: 'ngsuy76hgd87f'}) # create links edges = list() edges.append(graph_utils.create_edge( cluster_vertex.vertex_id, zone_vertex.vertex_id, - 'contains')) + EdgeLabel.CONTAINS)) edges.append(graph_utils.create_edge( zone_vertex.vertex_id, host_vertex.vertex_id, - 'contains')) + EdgeLabel.CONTAINS)) edges.append(graph_utils.create_edge( host_vertex.vertex_id, instance_1_vertex.vertex_id, - 'contains')) + EdgeLabel.CONTAINS)) edges.append(graph_utils.create_edge( host_vertex.vertex_id, instance_2_vertex.vertex_id, - 'contains')) + EdgeLabel.CONTAINS)) edges.append(graph_utils.create_edge( host_vertex.vertex_id, instance_3_vertex.vertex_id, - 'contains')) + EdgeLabel.CONTAINS)) edges.append(graph_utils.create_edge( host_vertex.vertex_id, instance_4_vertex.vertex_id, - 'contains')) + EdgeLabel.CONTAINS)) edges.append(graph_utils.create_edge( alarm_on_host_vertex.vertex_id, host_vertex.vertex_id, - 'on')) + EdgeLabel.ON)) edges.append(graph_utils.create_edge( alarm_on_instance_1_vertex.vertex_id, instance_1_vertex.vertex_id, - 'on')) + EdgeLabel.ON)) edges.append(graph_utils.create_edge( alarm_on_instance_2_vertex.vertex_id, instance_2_vertex.vertex_id, - 'on')) + EdgeLabel.ON)) edges.append(graph_utils.create_edge( alarm_on_instance_3_vertex.vertex_id, instance_3_vertex.vertex_id, - 'on')) + EdgeLabel.ON)) edges.append(graph_utils.create_edge( alarm_on_instance_4_vertex.vertex_id, instance_4_vertex.vertex_id, - 'on')) + EdgeLabel.ON)) edges.append(graph_utils.create_edge( alarm_on_host_vertex.vertex_id, alarm_on_instance_1_vertex.vertex_id, - 'causes')) + EdgeLabel.CAUSES)) edges.append(graph_utils.create_edge( alarm_on_host_vertex.vertex_id, alarm_on_instance_2_vertex.vertex_id, - 'causes')) + EdgeLabel.CAUSES)) edges.append(graph_utils.create_edge( alarm_on_host_vertex.vertex_id, alarm_on_instance_3_vertex.vertex_id, - 'causes')) + EdgeLabel.CAUSES)) edges.append(graph_utils.create_edge( alarm_on_host_vertex.vertex_id, alarm_on_instance_4_vertex.vertex_id, - 'causes')) + EdgeLabel.CAUSES)) # add vertices to graph graph.add_vertex(cluster_vertex) diff --git a/vitrage/tests/functional/datasources/aodh/test_aodh.py b/vitrage/tests/functional/datasources/aodh/test_aodh.py index 6392e5b96..9829dd72d 100644 --- a/vitrage/tests/functional/datasources/aodh/test_aodh.py +++ b/vitrage/tests/functional/datasources/aodh/test_aodh.py @@ -78,8 +78,8 @@ class TestAodhAlarms(TestDataSourcesBase): aodh_vertices = processor.entity_graph.get_vertices( vertex_attr_filter={ - VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: AODH_DATASOURCE + VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: AODH_DATASOURCE }) self.assertEqual(1, len(aodh_vertices)) @@ -88,4 +88,4 @@ class TestAodhAlarms(TestDataSourcesBase): self.assertEqual(1, len(aodh_neighbors)) self.assertEqual(NOVA_HOST_DATASOURCE, - aodh_neighbors[0][VProps.TYPE]) + aodh_neighbors[0][VProps.VITRAGE_TYPE]) diff --git a/vitrage/tests/functional/datasources/base.py b/vitrage/tests/functional/datasources/base.py index 1562b041b..12af2f4bd 100644 --- a/vitrage/tests/functional/datasources/base.py +++ b/vitrage/tests/functional/datasources/base.py @@ -19,10 +19,10 @@ from vitrage.tests.functional.base import TestFunctionalBase class TestDataSourcesBase(TestFunctionalBase): - def _find_entity_id_by_type(self, graph, type_): + def _find_entity_id_by_type(self, graph, vitrage_type): entity_vertices = graph.get_vertices(vertex_attr_filter={ - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: type_ + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: vitrage_type }) self.assertGreater(len(entity_vertices), 0) diff --git a/vitrage/tests/functional/datasources/cinder/test_cinder_volume.py b/vitrage/tests/functional/datasources/cinder/test_cinder_volume.py index 29696463b..97be1eadf 100644 --- a/vitrage/tests/functional/datasources/cinder/test_cinder_volume.py +++ b/vitrage/tests/functional/datasources/cinder/test_cinder_volume.py @@ -75,8 +75,8 @@ class TestCinderVolume(TestDataSourcesBase): cinder_vertices = processor.entity_graph.get_vertices( vertex_attr_filter={ - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: CINDER_VOLUME_DATASOURCE + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: CINDER_VOLUME_DATASOURCE }) self.assertEqual(1, len(cinder_vertices)) @@ -85,4 +85,4 @@ class TestCinderVolume(TestDataSourcesBase): self.assertEqual(1, len(cinder_neighbors)) self.assertEqual(NOVA_INSTANCE_DATASOURCE, - cinder_neighbors[0][VProps.TYPE]) + cinder_neighbors[0][VProps.VITRAGE_TYPE]) diff --git a/vitrage/tests/functional/datasources/heat/test_heat_stack.py b/vitrage/tests/functional/datasources/heat/test_heat_stack.py index 5b5e55765..a03d2b4ee 100644 --- a/vitrage/tests/functional/datasources/heat/test_heat_stack.py +++ b/vitrage/tests/functional/datasources/heat/test_heat_stack.py @@ -72,22 +72,22 @@ class TestHeatStack(TestDataSourcesBase): stack_vertices = processor.entity_graph.get_vertices( vertex_attr_filter={ - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: HEAT_STACK_DATASOURCE + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: HEAT_STACK_DATASOURCE }) self.assertEqual(1, len(stack_vertices)) instance_vertices = processor.entity_graph.get_vertices( vertex_attr_filter={ - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: NOVA_INSTANCE_DATASOURCE + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE }) self.assertEqual(self.NUM_INSTANCES + 1, len(instance_vertices)) cinder_vertices = processor.entity_graph.get_vertices( vertex_attr_filter={ - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: CINDER_VOLUME_DATASOURCE + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: CINDER_VOLUME_DATASOURCE }) self.assertEqual(1, len(cinder_vertices)) diff --git a/vitrage/tests/functional/datasources/nagios/test_nagios.py b/vitrage/tests/functional/datasources/nagios/test_nagios.py index 459f59180..e12c5c7c2 100644 --- a/vitrage/tests/functional/datasources/nagios/test_nagios.py +++ b/vitrage/tests/functional/datasources/nagios/test_nagios.py @@ -74,8 +74,8 @@ class TestNagios(TestDataSourcesBase): nagios_vertices = processor.entity_graph.get_vertices( vertex_attr_filter={ - VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: NAGIOS_DATASOURCE + VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE }) self.assertEqual(1, len(nagios_vertices)) @@ -84,4 +84,4 @@ class TestNagios(TestDataSourcesBase): self.assertEqual(1, len(nagios_neighbors)) self.assertEqual(NOVA_HOST_DATASOURCE, - nagios_neighbors[0][VProps.TYPE]) + nagios_neighbors[0][VProps.VITRAGE_TYPE]) diff --git a/vitrage/tests/functional/datasources/static_physical/test_static_physical.py b/vitrage/tests/functional/datasources/static_physical/test_static_physical.py index 26a971ce3..8a7bf9c81 100644 --- a/vitrage/tests/functional/datasources/static_physical/test_static_physical.py +++ b/vitrage/tests/functional/datasources/static_physical/test_static_physical.py @@ -81,8 +81,8 @@ class TestStaticPhysical(TestDataSourcesBase): static_physical_vertices = processor.entity_graph.get_vertices( vertex_attr_filter={ - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: SWITCH + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: SWITCH }) self.assertEqual(1, len(static_physical_vertices)) @@ -91,4 +91,4 @@ class TestStaticPhysical(TestDataSourcesBase): self.assertEqual(1, len(static_physical_neighbors)) self.assertEqual(NOVA_HOST_DATASOURCE, - static_physical_neighbors[0][VProps.TYPE]) + static_physical_neighbors[0][VProps.VITRAGE_TYPE]) diff --git a/vitrage/tests/functional/entity_graph/consistency/test_consistency.py b/vitrage/tests/functional/entity_graph/consistency/test_consistency.py index d42b85ec6..4bf7f29ea 100644 --- a/vitrage/tests/functional/entity_graph/consistency/test_consistency.py +++ b/vitrage/tests/functional/entity_graph/consistency/test_consistency.py @@ -30,7 +30,8 @@ from vitrage.entity_graph.consistency.consistency_enforcer \ import ConsistencyEnforcer from vitrage.entity_graph.initialization_status import InitializationStatus from vitrage.entity_graph.processor.processor import Processor -from vitrage.evaluator.actions.evaluator_event_transformer import VITRAGE_TYPE +from vitrage.evaluator.actions.evaluator_event_transformer \ + import VITRAGE_DATASOURCE from vitrage.evaluator.scenario_evaluator import ScenarioEvaluator from vitrage.evaluator.scenario_repository import ScenarioRepository import vitrage.graph.utils as graph_utils @@ -117,30 +118,30 @@ class TestConsistencyFunctional(TestFunctionalBase): num_of_host_alarms * num_instances_per_host num_undeleted_vertices_in_graph = \ len(self.processor.entity_graph.get_vertices(vertex_attr_filter={ - VProps.IS_DELETED: False + VProps.VITRAGE_IS_DELETED: False })) self.assertEqual(self._num_total_expected_vertices() + num_correct_alarms, num_undeleted_vertices_in_graph) alarm_vertices_in_graph = self.processor.entity_graph.get_vertices({ - VProps.CATEGORY: EntityCategory.ALARM, - VProps.IS_DELETED: False + VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_IS_DELETED: False }) self.assertEqual(num_correct_alarms, len(alarm_vertices_in_graph)) is_deleted_alarm_vertices_in_graph = \ self.processor.entity_graph.get_vertices({ - VProps.CATEGORY: EntityCategory.ALARM, - VProps.IS_DELETED: True + VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_IS_DELETED: True }) self.assertEqual(num_of_host_alarms * num_instances_per_host, len(is_deleted_alarm_vertices_in_graph)) instance_vertices = self.processor.entity_graph.get_vertices({ - VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: VITRAGE_TYPE, - VProps.IS_DELETED: False + VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, + VProps.VITRAGE_IS_DELETED: False }) self.assertEqual(num_of_host_alarms * num_instances_per_host, len(instance_vertices)) @@ -157,14 +158,14 @@ class TestConsistencyFunctional(TestFunctionalBase): # Test Assertions instance_vertices = self.processor.entity_graph.get_vertices({ - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: NOVA_INSTANCE_DATASOURCE + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE }) deleted_instance_vertices = \ self.processor.entity_graph.get_vertices({ - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: NOVA_INSTANCE_DATASOURCE, - VProps.IS_DELETED: True + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE, + VProps.VITRAGE_IS_DELETED: True }) self.assertEqual(self.NUM_INSTANCES - 3, len(instance_vertices)) self.assertEqual(self._num_total_expected_vertices() - 3, @@ -183,8 +184,8 @@ class TestConsistencyFunctional(TestFunctionalBase): # check number of instances in graph instance_vertices = self.processor.entity_graph.get_vertices({ - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: NOVA_INSTANCE_DATASOURCE + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE }) self.assertEqual(self.NUM_INSTANCES, len(instance_vertices)) @@ -193,13 +194,13 @@ class TestConsistencyFunctional(TestFunctionalBase): # set part of the instances as deleted for i in range(3, 6): - instance_vertices[i][VProps.IS_DELETED] = True + instance_vertices[i][VProps.VITRAGE_IS_DELETED] = True self.processor.entity_graph.update_vertex(instance_vertices[i]) # set part of the instances as deleted for i in range(6, 9): - instance_vertices[i][VProps.IS_DELETED] = True - instance_vertices[i][VProps.SAMPLE_TIMESTAMP] = str( + instance_vertices[i][VProps.VITRAGE_IS_DELETED] = True + instance_vertices[i][VProps.VITRAGE_SAMPLE_TIMESTAMP] = str( current_time + timedelta(seconds=2 * consistency_interval + 1)) self.processor.entity_graph.update_vertex(instance_vertices[i]) @@ -215,8 +216,8 @@ class TestConsistencyFunctional(TestFunctionalBase): def _add_alarms(self): # find hosts and instances host_vertices = self.processor.entity_graph.get_vertices({ - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: NOVA_HOST_DATASOURCE + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE }) # add host alarms + deduced alarms @@ -249,7 +250,7 @@ class TestConsistencyFunctional(TestFunctionalBase): def _update_timestamp(self, lst, timestamp): for vertex in lst: - vertex[VProps.SAMPLE_TIMESTAMP] = str(timestamp) + vertex[VProps.VITRAGE_SAMPLE_TIMESTAMP] = str(timestamp) self.processor.entity_graph.update_vertex(vertex) def _process_events(self): diff --git a/vitrage/tests/functional/entity_graph/states/test_datasource_info_mapper.py b/vitrage/tests/functional/entity_graph/states/test_datasource_info_mapper.py index 0c39d5cb0..51bd7b7db 100644 --- a/vitrage/tests/functional/entity_graph/states/test_datasource_info_mapper.py +++ b/vitrage/tests/functional/entity_graph/states/test_datasource_info_mapper.py @@ -49,9 +49,9 @@ class TestDatasourceInfoMapperFunctional(TestFunctionalBase): entity = processor.transformer_manager.transform(event) processor._find_and_fix_graph_vertex(entity.vertex, []) vertex = processor.entity_graph.get_vertex(entity.vertex.vertex_id) - self.assertEqual('ACTIVE', vertex[VProps.AGGREGATED_STATE]) + self.assertEqual('ACTIVE', vertex[VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.OK, - vertex[VProps.OPERATIONAL_STATE]) + vertex[VProps.VITRAGE_OPERATIONAL_STATE]) def test_state_on_neighbor_update(self): # setup @@ -61,7 +61,7 @@ class TestDatasourceInfoMapperFunctional(TestFunctionalBase): self.assertEqual(2, processor.entity_graph.num_vertices()) neighbors[0].vertex[VProps.STATE] = 'available' - neighbors[0].vertex[VProps.IS_PLACEHOLDER] = False + neighbors[0].vertex[VProps.VITRAGE_IS_PLACEHOLDER] = False # action processor._connect_neighbors(neighbors, [], GraphAction.UPDATE_ENTITY) @@ -69,6 +69,7 @@ class TestDatasourceInfoMapperFunctional(TestFunctionalBase): # test assertions neighbor_vertex = processor.entity_graph.get_vertex( neighbors[0].vertex.vertex_id) - self.assertEqual('AVAILABLE', neighbor_vertex[VProps.AGGREGATED_STATE]) + self.assertEqual('AVAILABLE', + neighbor_vertex[VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.OK, - neighbor_vertex[VProps.OPERATIONAL_STATE]) + neighbor_vertex[VProps.VITRAGE_OPERATIONAL_STATE]) diff --git a/vitrage/tests/functional/evaluator/test_action_executor.py b/vitrage/tests/functional/evaluator/test_action_executor.py index 5ef0f74ea..7302aeb40 100644 --- a/vitrage/tests/functional/evaluator/test_action_executor.py +++ b/vitrage/tests/functional/evaluator/test_action_executor.py @@ -12,10 +12,11 @@ # License for the specific language governing permissions and limitations # under the License. +from six.moves import queue from oslo_config import cfg -from six.moves import queue +from vitrage.common.constants import DatasourceAction from vitrage.common.constants import DatasourceProperties as DSProp from vitrage.common.constants import EdgeLabel from vitrage.common.constants import EntityCategory @@ -24,13 +25,19 @@ from vitrage.common.constants import VertexProperties as VProps from vitrage.datasources.alarm_properties import AlarmProperties as AlarmProps from vitrage.datasources.nagios import NAGIOS_DATASOURCE from vitrage.datasources.nagios.properties import NagiosProperties as NProps +from vitrage.datasources.nagios.properties import NagiosTestStatus from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE +from vitrage.entity_graph.mappings.operational_alarm_severity import \ + OperationalAlarmSeverity from vitrage.entity_graph.mappings.operational_resource_state import \ OperationalResourceState from vitrage.evaluator.actions.action_executor import ActionExecutor from vitrage.evaluator.actions.base import ActionMode from vitrage.evaluator.actions.base import ActionType -from vitrage.evaluator.actions.evaluator_event_transformer import VITRAGE_TYPE +from vitrage.evaluator.actions.evaluator_event_transformer \ + import VITRAGE_DATASOURCE +from vitrage.evaluator.actions.recipes.action_steps import ADD_VERTEX +from vitrage.evaluator.actions.recipes.base import EVALUATOR_EVENT_TYPE from vitrage.evaluator.template_data import ActionSpecs from vitrage.evaluator.template_fields import TemplateFields as TFields from vitrage.opts import register_opts @@ -54,7 +61,7 @@ class TestActionExecutor(TestFunctionalBase): # Test Setup processor = self._create_processor_with_graph(self.conf, uuid=True) - vertex_attrs = {VProps.TYPE: NOVA_HOST_DATASOURCE} + vertex_attrs = {VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE} host_vertices = processor.entity_graph.get_vertices( vertex_attr_filter=vertex_attrs) host_vertex_before = host_vertices[0] @@ -74,12 +81,14 @@ class TestActionExecutor(TestFunctionalBase): host_vertex_before.vertex_id) # Test Assertions - agg_state_before = host_vertex_before.get(VProps.AGGREGATED_STATE) + agg_state_before = \ + host_vertex_before.get(VProps.VITRAGE_AGGREGATED_STATE) self.assertNotEqual(agg_state_before, OperationalResourceState.SUBOPTIMAL) self.assertNotIn(VProps.VITRAGE_STATE, host_vertex_before.properties) - agg_state_after = host_vertex_after.get(VProps.AGGREGATED_STATE) + agg_state_after = \ + host_vertex_after.get(VProps.VITRAGE_AGGREGATED_STATE) self.assertEqual(agg_state_after, OperationalResourceState.SUBOPTIMAL) v_state_after = host_vertex_after.get(VProps.VITRAGE_STATE) self.assertEqual(v_state_after, OperationalResourceState.SUBOPTIMAL) @@ -92,7 +101,8 @@ class TestActionExecutor(TestFunctionalBase): host_vertex_before.vertex_id) # Test Assertions - agg_state_after_undo = host_vertex_before.get(VProps.AGGREGATED_STATE) + agg_state_after_undo = \ + host_vertex_before.get(VProps.VITRAGE_AGGREGATED_STATE) self.assertEqual(agg_state_after_undo, agg_state_before) self.assertNotIn( VProps.VITRAGE_STATE, host_vertex_after_undo.properties) @@ -102,7 +112,7 @@ class TestActionExecutor(TestFunctionalBase): # Test Setup processor = self._create_processor_with_graph(self.conf, uuid=True) - vertex_attrs = {VProps.TYPE: NOVA_HOST_DATASOURCE} + vertex_attrs = {VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE} host_vertices = processor.entity_graph.get_vertices( vertex_attr_filter=vertex_attrs) host_vertex_before = host_vertices[0] @@ -139,7 +149,7 @@ class TestActionExecutor(TestFunctionalBase): # Test Setup processor = self._create_processor_with_graph(self.conf, uuid=True) - vertex_attrs = {VProps.TYPE: NOVA_HOST_DATASOURCE} + vertex_attrs = {VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE} host_vertices = processor.entity_graph.get_vertices( vertex_attr_filter=vertex_attrs) @@ -153,7 +163,7 @@ class TestActionExecutor(TestFunctionalBase): host_2.get(VProps.ID), NOVA_HOST_DATASOURCE) processor.process_event(nagios_event2) - alarms_attrs = {VProps.TYPE: NAGIOS_DATASOURCE} + alarms_attrs = {VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE} alarms_vertices = processor.entity_graph.get_vertices( vertex_attr_filter=alarms_attrs) @@ -189,7 +199,7 @@ class TestActionExecutor(TestFunctionalBase): # Test Setup processor = self._create_processor_with_graph(self.conf, uuid=True) - vertex_attrs = {VProps.TYPE: NOVA_HOST_DATASOURCE} + vertex_attrs = {VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE} host_vertices = processor.entity_graph.get_vertices( vertex_attr_filter=vertex_attrs) @@ -207,7 +217,7 @@ class TestActionExecutor(TestFunctionalBase): # Raise alarm action adds new vertex with type vitrage to the graph action_spec = ActionSpecs(ActionType.RAISE_ALARM, targets, props) - alarm_vertex_attrs = {VProps.TYPE: VITRAGE_TYPE} + alarm_vertex_attrs = {VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE} before_alarms = processor.entity_graph.get_vertices( vertex_attr_filter=alarm_vertex_attrs) event_queue = queue.Queue() @@ -226,13 +236,13 @@ class TestActionExecutor(TestFunctionalBase): alarm = after_alarms[0] - self.assertEqual(alarm.properties[VProps.CATEGORY], + self.assertEqual(alarm.properties[VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(alarm.properties[VProps.TYPE], - VITRAGE_TYPE) + self.assertEqual(alarm.properties[VProps.VITRAGE_TYPE], + VITRAGE_DATASOURCE) self.assertEqual(alarm.properties[VProps.SEVERITY], props[TFields.SEVERITY]) - self.assertEqual(alarm.properties[VProps.OPERATIONAL_SEVERITY], + self.assertEqual(alarm.properties[VProps.VITRAGE_OPERATIONAL_SEVERITY], props[TFields.SEVERITY]) self.assertEqual(alarm.properties[VProps.STATE], AlarmProps.ACTIVE_STATE) @@ -247,7 +257,7 @@ class TestActionExecutor(TestFunctionalBase): # Test Setup processor = self._create_processor_with_graph(self.conf, uuid=True) - vertex_attrs = {VProps.TYPE: NOVA_HOST_DATASOURCE} + vertex_attrs = {VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE} host_vertices = processor.entity_graph.get_vertices( vertex_attr_filter=vertex_attrs) @@ -269,8 +279,8 @@ class TestActionExecutor(TestFunctionalBase): processor.process_event(add_vertex_event) - alarm_vertex_attrs = {VProps.TYPE: VITRAGE_TYPE, - VProps.IS_DELETED: False} + alarm_vertex_attrs = {VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, + VProps.VITRAGE_IS_DELETED: False} before_alarms = processor.entity_graph.get_vertices( vertex_attr_filter=alarm_vertex_attrs) @@ -295,10 +305,10 @@ class TestActionExecutor(TestFunctionalBase): NProps.RESOURCE_NAME: resource_name, NProps.RESOURCE_TYPE: resource_type, NProps.SERVICE: 'Check_MK', - NProps.STATUS: 'CRITICAL', + NProps.STATUS: NagiosTestStatus.CRITICAL, NProps.STATUS_INFO: 'test test test', - DSProp.DATASOURCE_ACTION: 'snapshot', - DSProp.ENTITY_TYPE: 'nagios', + DSProp.DATASOURCE_ACTION: DatasourceAction.SNAPSHOT, + DSProp.ENTITY_TYPE: NAGIOS_DATASOURCE, DSProp.SAMPLE_DATE: '2016-02-07 15:26:04'} @staticmethod @@ -306,13 +316,14 @@ class TestActionExecutor(TestFunctionalBase): return {TTFields.TARGET: target_vertex.vertex_id, VProps.UPDATE_TIMESTAMP: '2016-03-17 11:33:32.443002', - DSProp.DATASOURCE_ACTION: 'update', + DSProp.DATASOURCE_ACTION: DatasourceAction.UPDATE, TFields.ALARM_NAME: alarm_name, VProps.STATE: 'Active', - VProps.TYPE: 'add_vertex', - DSProp.ENTITY_TYPE: 'vitrage', - VProps.SEVERITY: 'CRITICAL', + EVALUATOR_EVENT_TYPE: ADD_VERTEX, + DSProp.ENTITY_TYPE: VITRAGE_DATASOURCE, + VProps.SEVERITY: OperationalAlarmSeverity.CRITICAL, VProps.VITRAGE_ID: 'mock_vitrage_id', - VProps.VITRAGE_RESOURCE_TYPE: 'nova.host', - VProps.CATEGORY: 'ALARM', - VProps.SAMPLE_TIMESTAMP: '2016-03-17 11:33:32.443002+00:00'} + VProps.VITRAGE_RESOURCE_TYPE: NOVA_HOST_DATASOURCE, + VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_SAMPLE_TIMESTAMP: + '2016-03-17 11:33:32.443002+00:00'} diff --git a/vitrage/tests/functional/evaluator/test_scenario_evaluator.py b/vitrage/tests/functional/evaluator/test_scenario_evaluator.py index fd26bab02..74465c403 100644 --- a/vitrage/tests/functional/evaluator/test_scenario_evaluator.py +++ b/vitrage/tests/functional/evaluator/test_scenario_evaluator.py @@ -18,11 +18,13 @@ from oslo_config import cfg from vitrage.common.constants import DatasourceAction from vitrage.common.constants import DatasourceProperties as DSProps +from vitrage.common.constants import EdgeLabel from vitrage.common.constants import EdgeProperties as EProps from vitrage.common.constants import EntityCategory from vitrage.common.constants import VertexProperties as VProps from vitrage.datasources.cinder.volume.transformer import \ CINDER_VOLUME_DATASOURCE +from vitrage.datasources.nagios import NAGIOS_DATASOURCE from vitrage.datasources.nagios.properties import NagiosProperties from vitrage.datasources.nagios.properties import NagiosTestStatus from vitrage.datasources.neutron.network import NEUTRON_NETWORK_DATASOURCE @@ -30,6 +32,8 @@ from vitrage.datasources.neutron.port import NEUTRON_PORT_DATASOURCE 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.evaluator.actions.evaluator_event_transformer \ + import VITRAGE_DATASOURCE from vitrage.evaluator.scenario_evaluator import ScenarioEvaluator from vitrage.evaluator.scenario_repository import ScenarioRepository from vitrage.graph import create_edge @@ -80,7 +84,7 @@ class TestScenarioEvaluator(TestFunctionalBase): _TARGET_HOST, _TARGET_HOST, processor.entity_graph) - self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE], + self.assertEqual('AVAILABLE', host_v[VProps.VITRAGE_AGGREGATED_STATE], 'host should be AVAILABLE when starting') # generate nagios alarm to trigger template scenario @@ -91,14 +95,14 @@ class TestScenarioEvaluator(TestFunctionalBase): host_v = self.get_host_after_event(event_queue, warning_test, processor, _TARGET_HOST) - self.assertEqual('SUBOPTIMAL', host_v[VProps.AGGREGATED_STATE], + self.assertEqual('SUBOPTIMAL', host_v[VProps.VITRAGE_AGGREGATED_STATE], 'host should be SUBOPTIMAL with warning alarm') # next disable the alarm warning_test['status'] = 'OK' host_v = self.get_host_after_event(event_queue, warning_test, processor, _TARGET_HOST) - self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE], + self.assertEqual('AVAILABLE', host_v[VProps.VITRAGE_AGGREGATED_STATE], 'host should be AVAILABLE when alarm disabled') def test_overlapping_deduced_state_1(self): @@ -109,7 +113,7 @@ class TestScenarioEvaluator(TestFunctionalBase): _TARGET_HOST, _TARGET_HOST, processor.entity_graph) - self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE], + self.assertEqual('AVAILABLE', host_v[VProps.VITRAGE_AGGREGATED_STATE], 'host should be AVAILABLE when starting') # generate nagios alarm to trigger @@ -120,7 +124,7 @@ class TestScenarioEvaluator(TestFunctionalBase): host_v = self.get_host_after_event(event_queue, warning_test, processor, _TARGET_HOST) - self.assertEqual('SUBOPTIMAL', host_v[VProps.AGGREGATED_STATE], + self.assertEqual('SUBOPTIMAL', host_v[VProps.VITRAGE_AGGREGATED_STATE], 'host should be SUBOPTIMAL with warning alarm') # generate CRITICAL nagios alarm to trigger @@ -131,21 +135,21 @@ class TestScenarioEvaluator(TestFunctionalBase): host_v = self.get_host_after_event(event_queue, critical_test, processor, _TARGET_HOST) - self.assertEqual('ERROR', host_v[VProps.AGGREGATED_STATE], + self.assertEqual('ERROR', host_v[VProps.VITRAGE_AGGREGATED_STATE], 'host should be ERROR with critical alarm') # next disable the critical alarm critical_test['status'] = 'OK' host_v = self.get_host_after_event(event_queue, critical_test, processor, _TARGET_HOST) - self.assertEqual('SUBOPTIMAL', host_v[VProps.AGGREGATED_STATE], + self.assertEqual('SUBOPTIMAL', host_v[VProps.VITRAGE_AGGREGATED_STATE], 'host should be SUBOPTIMAL with only warning alarm') # next disable the alarm warning_test['status'] = 'OK' host_v = self.get_host_after_event(event_queue, warning_test, processor, _TARGET_HOST) - self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE], + self.assertEqual('AVAILABLE', host_v[VProps.VITRAGE_AGGREGATED_STATE], 'host should be AVAILABLE after alarm disabled') def test_overlapping_deduced_state_2(self): @@ -156,7 +160,7 @@ class TestScenarioEvaluator(TestFunctionalBase): _TARGET_HOST, _TARGET_HOST, processor.entity_graph) - self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE], + self.assertEqual('AVAILABLE', host_v[VProps.VITRAGE_AGGREGATED_STATE], 'host should be AVAILABLE when starting') # generate CRITICAL nagios alarm to trigger @@ -167,7 +171,7 @@ class TestScenarioEvaluator(TestFunctionalBase): host_v = self.get_host_after_event(event_queue, critical_test, processor, _TARGET_HOST) - self.assertEqual('ERROR', host_v[VProps.AGGREGATED_STATE], + self.assertEqual('ERROR', host_v[VProps.VITRAGE_AGGREGATED_STATE], 'host should be ERROR with critical alarm') # generate WARNING nagios alarm to trigger @@ -178,14 +182,14 @@ class TestScenarioEvaluator(TestFunctionalBase): host_v = self.get_host_after_event(event_queue, warning_test, processor, _TARGET_HOST) - self.assertEqual('ERROR', host_v[VProps.AGGREGATED_STATE], + self.assertEqual('ERROR', host_v[VProps.VITRAGE_AGGREGATED_STATE], 'host should be ERROR with critical alarm') # next disable the critical alarm critical_test['status'] = 'OK' host_v = self.get_host_after_event(event_queue, critical_test, processor, _TARGET_HOST) - self.assertEqual('SUBOPTIMAL', host_v[VProps.AGGREGATED_STATE], + self.assertEqual('SUBOPTIMAL', host_v[VProps.VITRAGE_AGGREGATED_STATE], 'host should be SUBOPTIMAL with only warning alarm') def test_deduced_alarm(self): @@ -196,7 +200,7 @@ class TestScenarioEvaluator(TestFunctionalBase): _TARGET_HOST, _TARGET_HOST, processor.entity_graph) - self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE], + self.assertEqual('AVAILABLE', host_v[VProps.VITRAGE_AGGREGATED_STATE], 'host should be AVAILABLE when starting') # generate CRITICAL nagios alarm to trigger @@ -342,8 +346,8 @@ class TestScenarioEvaluator(TestFunctionalBase): """Handles a simple not operator use case We have created the following template: if there is a neutron.port that - doesn't have a nagios alarm of type PORT_PROBLEM on it, then raise a - deduced alarm on the port called simple_port_deduced_alarm. + doesn't have a nagios alarm of vitrage_type PORT_PROBLEM on it, then + raise a deduced alarm on the port called simple_port_deduced_alarm. The test has 5 steps in it: 1. create neutron.network and neutron.port and check that the simple_port_deduced_alarm is raised on the neutron.port because it @@ -377,8 +381,8 @@ class TestScenarioEvaluator(TestFunctionalBase): # find instances query = { - VProps.CATEGORY: 'RESOURCE', - VProps.TYPE: NOVA_INSTANCE_DATASOURCE + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE } instance_ver = entity_graph.get_vertices(vertex_attr_filter=query)[0] @@ -389,9 +393,9 @@ class TestScenarioEvaluator(TestFunctionalBase): 'updated_at': '2015-12-01T12:46:41Z', 'status': 'active', 'id': '12345', - 'vitrage_entity_type': 'neutron.network', - 'vitrage_datasource_action': 'snapshot', - 'vitrage_sample_date': '2015-12-01T12:46:41Z', + DSProps.ENTITY_TYPE: NEUTRON_NETWORK_DATASOURCE, + DSProps.DATASOURCE_ACTION: DatasourceAction.SNAPSHOT, + DSProps.SAMPLE_DATE: '2015-12-01T12:46:41Z', } # update port @@ -401,9 +405,9 @@ class TestScenarioEvaluator(TestFunctionalBase): 'updated_at': '2015-12-01T12:46:41Z', 'status': 'active', 'id': '54321', - 'vitrage_entity_type': 'neutron.port', - 'vitrage_datasource_action': 'snapshot', - 'vitrage_sample_date': '2015-12-01T12:46:41Z', + DSProps.ENTITY_TYPE: NEUTRON_PORT_DATASOURCE, + DSProps.DATASOURCE_ACTION: DatasourceAction.SNAPSHOT, + DSProps.SAMPLE_DATE: '2015-12-01T12:46:41Z', 'network_id': '12345', 'device_id': instance_ver.get(VProps.ID), 'device_owner': 'compute:nova', @@ -413,12 +417,13 @@ class TestScenarioEvaluator(TestFunctionalBase): processor.process_event(network_event) processor.process_event(port_event) port_vertex = entity_graph.get_vertices( - vertex_attr_filter={VProps.TYPE: NEUTRON_PORT_DATASOURCE})[0] + vertex_attr_filter={VProps.VITRAGE_TYPE: + NEUTRON_PORT_DATASOURCE})[0] while not event_queue.empty(): processor.process_event(event_queue.get()) # test asserts - query = {VProps.CATEGORY: EntityCategory.ALARM} + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM} port_neighbors = entity_graph.neighbors(port_vertex.vertex_id, vertex_attr_filter=query) self.assertEqual(num_orig_vertices + num_added_vertices + @@ -426,9 +431,10 @@ class TestScenarioEvaluator(TestFunctionalBase): self.assertEqual(num_orig_edges + num_added_edges + num_deduced_edges, entity_graph.num_edges()) self.assertEqual(1, len(port_neighbors)) - self.assertEqual(port_neighbors[0][VProps.CATEGORY], + self.assertEqual(port_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(port_neighbors[0][VProps.TYPE], 'vitrage') + self.assertEqual(port_neighbors[0][VProps.VITRAGE_TYPE], + VITRAGE_DATASOURCE) self.assertEqual(port_neighbors[0][VProps.NAME], 'simple_port_deduced_alarm') @@ -454,35 +460,41 @@ class TestScenarioEvaluator(TestFunctionalBase): self.assertEqual(num_orig_edges + num_added_edges + num_deduced_edges + num_nagios_alarm_edges, entity_graph.num_edges()) - query = {VProps.CATEGORY: EntityCategory.ALARM, VProps.TYPE: 'vitrage'} + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE} port_neighbors = entity_graph.neighbors(port_vertex.vertex_id, vertex_attr_filter=query) self.assertEqual(1, len(port_neighbors)) - self.assertEqual(port_neighbors[0][VProps.CATEGORY], + self.assertEqual(port_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(port_neighbors[0][VProps.TYPE], 'vitrage') + self.assertEqual(port_neighbors[0][VProps.VITRAGE_TYPE], + VITRAGE_DATASOURCE) self.assertEqual(port_neighbors[0][VProps.NAME], 'simple_port_deduced_alarm') - self.assertEqual(port_neighbors[0][VProps.IS_DELETED], True) + self.assertEqual(port_neighbors[0][VProps.VITRAGE_IS_DELETED], True) - query = {VProps.CATEGORY: EntityCategory.ALARM, VProps.TYPE: 'nagios'} + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE} port_neighbors = entity_graph.neighbors(port_vertex.vertex_id, vertex_attr_filter=query) - self.assertEqual(port_neighbors[0][VProps.CATEGORY], + self.assertEqual(port_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(port_neighbors[0][VProps.TYPE], 'nagios') + self.assertEqual(port_neighbors[0][VProps.VITRAGE_TYPE], + NAGIOS_DATASOURCE) self.assertEqual(port_neighbors[0][VProps.NAME], 'PORT_PROBLEM') - self.assertEqual(port_neighbors[0][VProps.IS_DELETED], False) - self.assertEqual(port_neighbors[0][VProps.IS_PLACEHOLDER], False) + self.assertEqual(port_neighbors[0][VProps.VITRAGE_IS_DELETED], False) + self.assertEqual(port_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], + False) # ################### STEP 3 ################### # disable connection between port and alarm - query = {VProps.CATEGORY: 'ALARM', VProps.TYPE: 'nagios'} + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE} nagios_vertex = \ processor.entity_graph.get_vertices(vertex_attr_filter=query)[0] nagios_edge = [e for e in processor.entity_graph.get_edges( nagios_vertex.vertex_id)][0] - nagios_edge[EProps.IS_DELETED] = True + nagios_edge[EProps.VITRAGE_IS_DELETED] = True processor.entity_graph.update_edge(nagios_edge) while not event_queue.empty(): processor.process_event(event_queue.get()) @@ -498,40 +510,47 @@ class TestScenarioEvaluator(TestFunctionalBase): self.assertEqual(num_orig_edges + num_added_edges + num_deduced_edges + num_nagios_alarm_edges + 1, entity_graph.num_edges()) - query = {VProps.CATEGORY: EntityCategory.ALARM, VProps.TYPE: 'vitrage', - VProps.IS_DELETED: True} - is_deleted = True + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, + VProps.VITRAGE_IS_DELETED: True} + vitrage_is_deleted = True for counter in range(0, 1): port_neighbors = entity_graph.neighbors(port_vertex.vertex_id, vertex_attr_filter=query) self.assertEqual(1, len(port_neighbors)) - self.assertEqual(port_neighbors[0][VProps.CATEGORY], + self.assertEqual(port_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(port_neighbors[0][VProps.TYPE], 'vitrage') + self.assertEqual(port_neighbors[0][VProps.VITRAGE_TYPE], + VITRAGE_DATASOURCE) self.assertEqual(port_neighbors[0][VProps.NAME], 'simple_port_deduced_alarm') - self.assertEqual(port_neighbors[0][VProps.IS_DELETED], is_deleted) - query = {VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: 'vitrage', VProps.IS_DELETED: False} - is_deleted = False - - query = {VProps.CATEGORY: EntityCategory.ALARM, VProps.TYPE: 'nagios'} + self.assertEqual(port_neighbors[0][VProps.VITRAGE_IS_DELETED], + vitrage_is_deleted) + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, + VProps.VITRAGE_IS_DELETED: False} + vitrage_is_deleted = False + + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE} port_neighbors = entity_graph.neighbors(port_vertex.vertex_id, vertex_attr_filter=query) - self.assertEqual(port_neighbors[0][VProps.CATEGORY], + self.assertEqual(port_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(port_neighbors[0][VProps.TYPE], 'nagios') + self.assertEqual(port_neighbors[0][VProps.VITRAGE_TYPE], + NAGIOS_DATASOURCE) self.assertEqual(port_neighbors[0][VProps.NAME], 'PORT_PROBLEM') - self.assertEqual(port_neighbors[0][VProps.IS_DELETED], False) + self.assertEqual(port_neighbors[0][VProps.VITRAGE_IS_DELETED], False) # ################### STEP 4 ################### # enable connection between port and alarm - query = {VProps.CATEGORY: 'ALARM', VProps.TYPE: 'nagios'} + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE} nagios_vertex = \ processor.entity_graph.get_vertices(vertex_attr_filter=query)[0] nagios_edge = [e for e in processor.entity_graph.get_edges( nagios_vertex.vertex_id)][0] - nagios_edge[EProps.IS_DELETED] = False + nagios_edge[EProps.VITRAGE_IS_DELETED] = False processor.entity_graph.update_edge(nagios_edge) while not event_queue.empty(): processor.process_event(event_queue.get()) @@ -547,35 +566,41 @@ class TestScenarioEvaluator(TestFunctionalBase): self.assertEqual(num_orig_edges + num_added_edges + num_deduced_edges + num_nagios_alarm_edges + 1, entity_graph.num_edges()) - query = {VProps.CATEGORY: EntityCategory.ALARM, VProps.TYPE: 'vitrage', - VProps.IS_DELETED: True} - is_deleted = True + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, + VProps.VITRAGE_IS_DELETED: True} + vitrage_is_deleted = True for counter in range(0, 1): port_neighbors = entity_graph.neighbors(port_vertex.vertex_id, vertex_attr_filter=query) self.assertEqual(2, len(port_neighbors)) for in_counter in range(0, 1): - self.assertEqual(port_neighbors[in_counter][VProps.CATEGORY], - EntityCategory.ALARM) - self.assertEqual(port_neighbors[in_counter][VProps.TYPE], - 'vitrage') + self.assertEqual( + port_neighbors[in_counter][VProps.VITRAGE_CATEGORY], + EntityCategory.ALARM) + self.assertEqual(port_neighbors[in_counter] + [VProps.VITRAGE_TYPE], VITRAGE_DATASOURCE) self.assertEqual(port_neighbors[in_counter][VProps.NAME], 'simple_port_deduced_alarm') self.assertEqual( - port_neighbors[in_counter][VProps.IS_DELETED], is_deleted) + port_neighbors[in_counter][VProps.VITRAGE_IS_DELETED], + vitrage_is_deleted) - query = {VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: 'vitrage', VProps.IS_DELETED: False} - is_deleted = False + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, + VProps.VITRAGE_IS_DELETED: False} + vitrage_is_deleted = False - query = {VProps.CATEGORY: EntityCategory.ALARM, VProps.TYPE: 'nagios'} + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE} port_neighbors = entity_graph.neighbors(port_vertex.vertex_id, vertex_attr_filter=query) - self.assertEqual(port_neighbors[0][VProps.CATEGORY], + self.assertEqual(port_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(port_neighbors[0][VProps.TYPE], 'nagios') + self.assertEqual(port_neighbors[0][VProps.VITRAGE_TYPE], + NAGIOS_DATASOURCE) self.assertEqual(port_neighbors[0][VProps.NAME], 'PORT_PROBLEM') - self.assertEqual(port_neighbors[0][VProps.IS_DELETED], False) + self.assertEqual(port_neighbors[0][VProps.VITRAGE_IS_DELETED], False) # ################### STEP 5 ################### # disable PORT_PROBLEM alarm @@ -591,50 +616,57 @@ class TestScenarioEvaluator(TestFunctionalBase): # new alarm doesn't update same deleted alarm. # Instead, it keeps the old one and creates a new one # Since this is the second test, there are already two - # alarms of this type + # alarms of this vitrage_type 2, entity_graph.num_vertices()) self.assertEqual(num_orig_edges + num_added_edges + num_deduced_edges + num_nagios_alarm_edges + 2, entity_graph.num_edges()) - query = {VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: 'vitrage', VProps.IS_DELETED: True} - is_deleted = True + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, + VProps.VITRAGE_IS_DELETED: True} + vitrage_is_deleted = True for counter in range(0, 1): port_neighbors = entity_graph.neighbors(port_vertex.vertex_id, vertex_attr_filter=query) self.assertEqual(2, len(port_neighbors)) for in_counter in range(0, 1): - self.assertEqual(port_neighbors[in_counter][VProps.CATEGORY], - EntityCategory.ALARM) - self.assertEqual(port_neighbors[in_counter][VProps.TYPE], - 'vitrage') + self.assertEqual( + port_neighbors[in_counter][VProps.VITRAGE_CATEGORY], + EntityCategory.ALARM) + self.assertEqual(port_neighbors[in_counter] + [VProps.VITRAGE_TYPE], VITRAGE_DATASOURCE) self.assertEqual(port_neighbors[in_counter][VProps.NAME], 'simple_port_deduced_alarm') self.assertEqual( - port_neighbors[in_counter][VProps.IS_DELETED], is_deleted) + port_neighbors[in_counter][VProps.VITRAGE_IS_DELETED], + vitrage_is_deleted) - query = {VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: 'vitrage', VProps.IS_DELETED: False} - is_deleted = False + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, + VProps.VITRAGE_IS_DELETED: False} + vitrage_is_deleted = False - query = {VProps.CATEGORY: EntityCategory.ALARM, VProps.TYPE: 'nagios'} + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE} port_neighbors = entity_graph.neighbors(port_vertex.vertex_id, vertex_attr_filter=query) - self.assertEqual(port_neighbors[0][VProps.CATEGORY], + self.assertEqual(port_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(port_neighbors[0][VProps.TYPE], 'nagios') + self.assertEqual(port_neighbors[0][VProps.VITRAGE_TYPE], + NAGIOS_DATASOURCE) self.assertEqual(port_neighbors[0][VProps.NAME], 'PORT_PROBLEM') - self.assertEqual(port_neighbors[0][VProps.IS_DELETED], True) + self.assertEqual(port_neighbors[0][VProps.VITRAGE_IS_DELETED], True) def test_complex_not_operator_deduced_alarm(self): """Handles a complex not operator use case We have created the following template: if there is a openstack.cluster that has a nova.zone which is connected to a neutron.network and also - there is no nagios alarm of type CLUSTER_PROBLEM on the cluster and no - nagios alarm of type NETWORK_PROBLEM on the neutron.network, then raise - a deduced alarm on the nova.zone called complex_zone_deduced_alarm. + there is no nagios alarm of vitrage_type CLUSTER_PROBLEM on the cluster + and no nagios alarm of vitrage_type NETWORK_PROBLEM on the + neutron.network, then raise a deduced alarm on the nova.zone called + complex_zone_deduced_alarm. The test has 3 steps in it: 1. create a neutron.network and connect it to a zone, and check that the complex_zone_deduced_alarm is raised on the nova.zone because it @@ -674,17 +706,18 @@ class TestScenarioEvaluator(TestFunctionalBase): 'updated_at': '2015-12-01T12:46:41Z', 'status': 'active', 'id': '12345', - 'vitrage_entity_type': 'neutron.network', - 'vitrage_datasource_action': 'snapshot', - 'vitrage_sample_date': '2015-12-01T12:46:41Z', + DSProps.ENTITY_TYPE: NEUTRON_NETWORK_DATASOURCE, + DSProps.DATASOURCE_ACTION: DatasourceAction.SNAPSHOT, + DSProps.SAMPLE_DATE: '2015-12-01T12:46:41Z', } # process events processor.process_event(zone_event) - query = {VProps.TYPE: NOVA_ZONE_DATASOURCE, VProps.ID: 'zone-7'} + query = {VProps.VITRAGE_TYPE: NOVA_ZONE_DATASOURCE, + VProps.ID: 'zone-7'} zone_vertex = entity_graph.get_vertices(vertex_attr_filter=query)[0] processor.process_event(network_event) - query = {VProps.TYPE: NEUTRON_NETWORK_DATASOURCE} + query = {VProps.VITRAGE_TYPE: NEUTRON_NETWORK_DATASOURCE} network_vertex = entity_graph.get_vertices(vertex_attr_filter=query)[0] # add edge between network and zone @@ -696,7 +729,7 @@ class TestScenarioEvaluator(TestFunctionalBase): processor.process_event(event_queue.get()) # test asserts - query = {VProps.CATEGORY: EntityCategory.ALARM} + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM} zone_neighbors = entity_graph.neighbors(zone_vertex.vertex_id, vertex_attr_filter=query) self.assertEqual(num_orig_vertices + num_added_vertices + @@ -704,9 +737,10 @@ class TestScenarioEvaluator(TestFunctionalBase): self.assertEqual(num_orig_edges + num_added_edges + num_deduced_edges, entity_graph.num_edges()) self.assertEqual(1, len(zone_neighbors)) - self.assertEqual(zone_neighbors[0][VProps.CATEGORY], + self.assertEqual(zone_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(zone_neighbors[0][VProps.TYPE], 'vitrage') + self.assertEqual(zone_neighbors[0][VProps.VITRAGE_TYPE], + VITRAGE_DATASOURCE) self.assertEqual(zone_neighbors[0][VProps.NAME], 'complex_zone_deduced_alarm') @@ -732,26 +766,30 @@ class TestScenarioEvaluator(TestFunctionalBase): self.assertEqual(num_orig_edges + num_added_edges + num_deduced_edges + num_network_alarm_edges, entity_graph.num_edges()) - query = {VProps.CATEGORY: EntityCategory.ALARM} + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM} network_neighbors = entity_graph.neighbors(network_vertex.vertex_id, vertex_attr_filter=query) self.assertEqual(1, len(network_neighbors)) - self.assertEqual(network_neighbors[0][VProps.CATEGORY], + self.assertEqual(network_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(network_neighbors[0][VProps.TYPE], 'nagios') + self.assertEqual(network_neighbors[0][VProps.VITRAGE_TYPE], + NAGIOS_DATASOURCE) self.assertEqual(network_neighbors[0][VProps.NAME], 'NETWORK_PROBLEM') - self.assertEqual(network_neighbors[0][VProps.IS_DELETED], False) - self.assertEqual(network_neighbors[0][VProps.IS_PLACEHOLDER], False) + self.assertEqual(network_neighbors[0][VProps.VITRAGE_IS_DELETED], + False) + self.assertEqual(network_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], + False) zone_neighbors = entity_graph.neighbors(zone_vertex.vertex_id, vertex_attr_filter=query) self.assertEqual(1, len(zone_neighbors)) - self.assertEqual(zone_neighbors[0][VProps.CATEGORY], + self.assertEqual(zone_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(zone_neighbors[0][VProps.TYPE], 'vitrage') + self.assertEqual(zone_neighbors[0][VProps.VITRAGE_TYPE], + VITRAGE_DATASOURCE) self.assertEqual(zone_neighbors[0][VProps.NAME], 'complex_zone_deduced_alarm') - self.assertEqual(zone_neighbors[0][VProps.IS_DELETED], True) + self.assertEqual(zone_neighbors[0][VProps.VITRAGE_IS_DELETED], True) # ################### STEP 3 ################### # delete NETWORK_PROBLEM alarm @@ -770,35 +808,38 @@ class TestScenarioEvaluator(TestFunctionalBase): self.assertEqual(num_orig_edges + num_added_edges + num_deduced_edges + num_network_alarm_edges + 1, entity_graph.num_edges()) - query = {VProps.CATEGORY: EntityCategory.ALARM} + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM} network_neighbors = entity_graph.neighbors(network_vertex.vertex_id, vertex_attr_filter=query) self.assertEqual(1, len(network_neighbors)) - self.assertEqual(network_neighbors[0][VProps.CATEGORY], + self.assertEqual(network_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(network_neighbors[0][VProps.TYPE], 'nagios') + self.assertEqual(network_neighbors[0][VProps.VITRAGE_TYPE], + NAGIOS_DATASOURCE) self.assertEqual(network_neighbors[0][VProps.NAME], 'NETWORK_PROBLEM') - self.assertEqual(network_neighbors[0][VProps.IS_DELETED], True) + self.assertEqual(network_neighbors[0][VProps.VITRAGE_IS_DELETED], True) - query = {VProps.CATEGORY: EntityCategory.ALARM, - VProps.IS_DELETED: True} - is_deleted = True + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_IS_DELETED: True} + vitrage_is_deleted = True # Alarm History is saved. We are testing the deleted alarm and # then we are testing the live alarm for counter in range(0, 1): zone_neighbors = entity_graph.neighbors(zone_vertex.vertex_id, vertex_attr_filter=query) self.assertEqual(1, len(zone_neighbors)) - self.assertEqual(zone_neighbors[0][VProps.CATEGORY], + self.assertEqual(zone_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(zone_neighbors[0][VProps.TYPE], 'vitrage') + self.assertEqual(zone_neighbors[0][VProps.VITRAGE_TYPE], + VITRAGE_DATASOURCE) self.assertEqual(zone_neighbors[0][VProps.NAME], 'complex_zone_deduced_alarm') - self.assertEqual(zone_neighbors[0][VProps.IS_DELETED], is_deleted) + self.assertEqual(zone_neighbors[0][VProps.VITRAGE_IS_DELETED], + vitrage_is_deleted) - query = {VProps.CATEGORY: EntityCategory.ALARM, - VProps.IS_DELETED: False} - is_deleted = False + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_IS_DELETED: False} + vitrage_is_deleted = False def test_ha(self): event_queue, processor, evaluator = self._init_system() @@ -806,15 +847,15 @@ class TestScenarioEvaluator(TestFunctionalBase): # find host query = { - VProps.CATEGORY: 'RESOURCE', - VProps.TYPE: NOVA_HOST_DATASOURCE + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE } hosts = entity_graph.get_vertices(vertex_attr_filter=query) # find instances on host query = { - VProps.CATEGORY: 'RESOURCE', - VProps.TYPE: NOVA_INSTANCE_DATASOURCE + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE } instances = entity_graph.neighbors(hosts[0].vertex_id, vertex_attr_filter=query) @@ -847,29 +888,34 @@ class TestScenarioEvaluator(TestFunctionalBase): self.assertEqual(num_orig_edges + num_volumes + num_deduced_alarms, entity_graph.num_edges()) - query = {VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: CINDER_VOLUME_DATASOURCE} + query = {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: CINDER_VOLUME_DATASOURCE} instance_neighbors = entity_graph.neighbors(instances[0].vertex_id, vertex_attr_filter=query) self.assertEqual(1, len(instance_neighbors)) - self.assertEqual(instance_neighbors[0][VProps.CATEGORY], + self.assertEqual(instance_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.RESOURCE) - self.assertEqual(instance_neighbors[0][VProps.TYPE], + self.assertEqual(instance_neighbors[0][VProps.VITRAGE_TYPE], CINDER_VOLUME_DATASOURCE) self.assertEqual(instance_neighbors[0][VProps.NAME], 'volume-1') - self.assertEqual(instance_neighbors[0][VProps.IS_DELETED], False) - self.assertEqual(instance_neighbors[0][VProps.IS_PLACEHOLDER], False) + self.assertEqual(instance_neighbors[0][VProps.VITRAGE_IS_DELETED], + False) + self.assertEqual(instance_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], + False) - query = {VProps.CATEGORY: EntityCategory.ALARM, VProps.TYPE: 'vitrage'} + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE} host_neighbors = entity_graph.neighbors(hosts[0].vertex_id, vertex_attr_filter=query) - self.assertEqual(host_neighbors[0][VProps.CATEGORY], + self.assertEqual(host_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(host_neighbors[0][VProps.TYPE], 'vitrage') + self.assertEqual(host_neighbors[0][VProps.VITRAGE_TYPE], + VITRAGE_DATASOURCE) self.assertEqual(host_neighbors[0][VProps.NAME], 'ha_warning_deduced_alarm') - self.assertEqual(host_neighbors[0][VProps.IS_DELETED], False) - self.assertEqual(host_neighbors[0][VProps.IS_PLACEHOLDER], False) + self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_DELETED], False) + self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], + False) # ################### STEP 2 ################### # Add cinder volume 2 @@ -894,48 +940,54 @@ class TestScenarioEvaluator(TestFunctionalBase): entity_graph.num_edges()) # check instance neighbors - query = {VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: CINDER_VOLUME_DATASOURCE} + query = {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: CINDER_VOLUME_DATASOURCE} instance_neighbors = entity_graph.neighbors(instances[1].vertex_id, vertex_attr_filter=query) self.assertEqual(1, len(instance_neighbors)) - self.assertEqual(instance_neighbors[0][VProps.CATEGORY], + self.assertEqual(instance_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.RESOURCE) - self.assertEqual(instance_neighbors[0][VProps.TYPE], + self.assertEqual(instance_neighbors[0][VProps.VITRAGE_TYPE], CINDER_VOLUME_DATASOURCE) self.assertEqual(instance_neighbors[0][VProps.NAME], 'volume-2') - self.assertEqual(instance_neighbors[0][VProps.IS_DELETED], False) - self.assertEqual(instance_neighbors[0][VProps.IS_PLACEHOLDER], False) + self.assertEqual(instance_neighbors[0][VProps.VITRAGE_IS_DELETED], + False) + self.assertEqual(instance_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], + False) # check ha_error_deduced_alarm - query = {VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: 'vitrage', + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, VProps.NAME: 'ha_error_deduced_alarm'} host_neighbors = entity_graph.neighbors(hosts[0].vertex_id, vertex_attr_filter=query) self.assertEqual(1, len(host_neighbors)) - self.assertEqual(host_neighbors[0][VProps.CATEGORY], + self.assertEqual(host_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(host_neighbors[0][VProps.TYPE], 'vitrage') + self.assertEqual(host_neighbors[0][VProps.VITRAGE_TYPE], + VITRAGE_DATASOURCE) self.assertEqual(host_neighbors[0][VProps.NAME], 'ha_error_deduced_alarm') - self.assertEqual(host_neighbors[0][VProps.IS_DELETED], False) - self.assertEqual(host_neighbors[0][VProps.IS_PLACEHOLDER], False) + self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_DELETED], False) + self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], + False) # check ha_warning_deduced_alarm - query = {VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: 'vitrage', + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, VProps.NAME: 'ha_warning_deduced_alarm'} host_neighbors = entity_graph.neighbors(hosts[0].vertex_id, vertex_attr_filter=query) self.assertEqual(1, len(host_neighbors)) - self.assertEqual(host_neighbors[0][VProps.CATEGORY], + self.assertEqual(host_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(host_neighbors[0][VProps.TYPE], 'vitrage') + self.assertEqual(host_neighbors[0][VProps.VITRAGE_TYPE], + VITRAGE_DATASOURCE) self.assertEqual(host_neighbors[0][VProps.NAME], 'ha_warning_deduced_alarm') - self.assertEqual(host_neighbors[0][VProps.IS_DELETED], True) - self.assertEqual(host_neighbors[0][VProps.IS_PLACEHOLDER], False) + self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_DELETED], True) + self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], + False) # ################### STEP 3 ################### # Remove Cinder Volume 2 @@ -959,65 +1011,73 @@ class TestScenarioEvaluator(TestFunctionalBase): self.assertEqual(num_orig_edges + num_volumes + num_deduced_alarms + 1, entity_graph.num_edges()) - query = {VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: CINDER_VOLUME_DATASOURCE} + query = {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: CINDER_VOLUME_DATASOURCE} instance_neighbors = entity_graph.neighbors(instances[1].vertex_id, vertex_attr_filter=query) self.assertEqual(1, len(instance_neighbors)) - self.assertEqual(instance_neighbors[0][VProps.CATEGORY], + self.assertEqual(instance_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.RESOURCE) - self.assertEqual(instance_neighbors[0][VProps.TYPE], + self.assertEqual(instance_neighbors[0][VProps.VITRAGE_TYPE], CINDER_VOLUME_DATASOURCE) self.assertEqual(instance_neighbors[0][VProps.NAME], 'volume-2') - self.assertEqual(instance_neighbors[0][VProps.IS_DELETED], False) - self.assertEqual(instance_neighbors[0][VProps.IS_PLACEHOLDER], False) + self.assertEqual(instance_neighbors[0][VProps.VITRAGE_IS_DELETED], + False) + self.assertEqual(instance_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], + False) # check ha_error_deduced_alarm - query = {VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: 'vitrage', + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, VProps.NAME: 'ha_error_deduced_alarm'} host_neighbors = entity_graph.neighbors(hosts[0].vertex_id, vertex_attr_filter=query) self.assertEqual(1, len(host_neighbors)) - self.assertEqual(host_neighbors[0][VProps.CATEGORY], + self.assertEqual(host_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(host_neighbors[0][VProps.TYPE], 'vitrage') + self.assertEqual(host_neighbors[0][VProps.VITRAGE_TYPE], + VITRAGE_DATASOURCE) self.assertEqual(host_neighbors[0][VProps.NAME], 'ha_error_deduced_alarm') - self.assertEqual(host_neighbors[0][VProps.IS_DELETED], True) - self.assertEqual(host_neighbors[0][VProps.IS_PLACEHOLDER], False) + self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_DELETED], True) + self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], + False) # check new ha_warning_deduced_alarm - query = {VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: 'vitrage', + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, VProps.NAME: 'ha_warning_deduced_alarm', - VProps.IS_DELETED: False} + VProps.VITRAGE_IS_DELETED: False} host_neighbors = entity_graph.neighbors(hosts[0].vertex_id, vertex_attr_filter=query) self.assertEqual(1, len(host_neighbors)) - self.assertEqual(host_neighbors[0][VProps.CATEGORY], + self.assertEqual(host_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(host_neighbors[0][VProps.TYPE], 'vitrage') + self.assertEqual(host_neighbors[0][VProps.VITRAGE_TYPE], + VITRAGE_DATASOURCE) self.assertEqual(host_neighbors[0][VProps.NAME], 'ha_warning_deduced_alarm') - self.assertEqual(host_neighbors[0][VProps.IS_DELETED], False) - self.assertEqual(host_neighbors[0][VProps.IS_PLACEHOLDER], False) + self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_DELETED], False) + self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], + False) # check old deleted ha_warning_deduced_alarm - query = {VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: 'vitrage', + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, VProps.NAME: 'ha_warning_deduced_alarm', - VProps.IS_DELETED: True} + VProps.VITRAGE_IS_DELETED: True} host_neighbors = entity_graph.neighbors(hosts[0].vertex_id, vertex_attr_filter=query) self.assertEqual(1, len(host_neighbors)) - self.assertEqual(host_neighbors[0][VProps.CATEGORY], + self.assertEqual(host_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(host_neighbors[0][VProps.TYPE], 'vitrage') + self.assertEqual(host_neighbors[0][VProps.VITRAGE_TYPE], + VITRAGE_DATASOURCE) self.assertEqual(host_neighbors[0][VProps.NAME], 'ha_warning_deduced_alarm') - self.assertEqual(host_neighbors[0][VProps.IS_DELETED], True) - self.assertEqual(host_neighbors[0][VProps.IS_PLACEHOLDER], False) + self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_DELETED], True) + self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], + False) # ################### STEP 4 ################### # Remove Cinder Volume 1 @@ -1041,57 +1101,65 @@ class TestScenarioEvaluator(TestFunctionalBase): self.assertEqual(num_orig_edges + num_volumes + num_deduced_alarms + 1, entity_graph.num_edges()) - query = {VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: CINDER_VOLUME_DATASOURCE} + query = {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: CINDER_VOLUME_DATASOURCE} instance_neighbors = entity_graph.neighbors(instances[0].vertex_id, vertex_attr_filter=query) self.assertEqual(1, len(instance_neighbors)) - self.assertEqual(instance_neighbors[0][VProps.CATEGORY], + self.assertEqual(instance_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.RESOURCE) - self.assertEqual(instance_neighbors[0][VProps.TYPE], + self.assertEqual(instance_neighbors[0][VProps.VITRAGE_TYPE], CINDER_VOLUME_DATASOURCE) self.assertEqual(instance_neighbors[0][VProps.NAME], 'volume-1') - self.assertEqual(instance_neighbors[0][VProps.IS_DELETED], False) - self.assertEqual(instance_neighbors[0][VProps.IS_PLACEHOLDER], False) + self.assertEqual(instance_neighbors[0][VProps.VITRAGE_IS_DELETED], + False) + self.assertEqual(instance_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], + False) # check ha_error_deduced_alarm - query = {VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: 'vitrage', + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, VProps.NAME: 'ha_error_deduced_alarm'} host_neighbors = entity_graph.neighbors(hosts[0].vertex_id, vertex_attr_filter=query) self.assertEqual(1, len(host_neighbors)) - self.assertEqual(host_neighbors[0][VProps.CATEGORY], + self.assertEqual(host_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(host_neighbors[0][VProps.TYPE], 'vitrage') + self.assertEqual(host_neighbors[0][VProps.VITRAGE_TYPE], + VITRAGE_DATASOURCE) self.assertEqual(host_neighbors[0][VProps.NAME], 'ha_error_deduced_alarm') - self.assertEqual(host_neighbors[0][VProps.IS_DELETED], True) - self.assertEqual(host_neighbors[0][VProps.IS_PLACEHOLDER], False) + self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_DELETED], True) + self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], + False) # check old ha_warning_deduced_alarm - query = {VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: 'vitrage', + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, VProps.NAME: 'ha_warning_deduced_alarm'} host_neighbors = entity_graph.neighbors(hosts[0].vertex_id, vertex_attr_filter=query) self.assertEqual(2, len(host_neighbors)) - self.assertEqual(host_neighbors[0][VProps.CATEGORY], + self.assertEqual(host_neighbors[0][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(host_neighbors[0][VProps.TYPE], 'vitrage') + self.assertEqual(host_neighbors[0][VProps.VITRAGE_TYPE], + VITRAGE_DATASOURCE) self.assertEqual(host_neighbors[0][VProps.NAME], 'ha_warning_deduced_alarm') - self.assertEqual(host_neighbors[0][VProps.IS_DELETED], True) - self.assertEqual(host_neighbors[0][VProps.IS_PLACEHOLDER], False) + self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_DELETED], True) + self.assertEqual(host_neighbors[0][VProps.VITRAGE_IS_PLACEHOLDER], + False) - self.assertEqual(host_neighbors[1][VProps.CATEGORY], + self.assertEqual(host_neighbors[1][VProps.VITRAGE_CATEGORY], EntityCategory.ALARM) - self.assertEqual(host_neighbors[1][VProps.TYPE], 'vitrage') + self.assertEqual(host_neighbors[1][VProps.VITRAGE_TYPE], + VITRAGE_DATASOURCE) self.assertEqual(host_neighbors[1][VProps.NAME], 'ha_warning_deduced_alarm') - self.assertEqual(host_neighbors[1][VProps.IS_DELETED], True) - self.assertEqual(host_neighbors[1][VProps.IS_PLACEHOLDER], False) + self.assertEqual(host_neighbors[1][VProps.VITRAGE_IS_DELETED], True) + self.assertEqual(host_neighbors[1][VProps.VITRAGE_IS_PLACEHOLDER], + False) def test_simple_or_operator_deduced_alarm(self): """Handles a simple not operator use case @@ -1107,7 +1175,7 @@ class TestScenarioEvaluator(TestFunctionalBase): _TARGET_HOST, _TARGET_HOST, processor.entity_graph) - self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE], + self.assertEqual('AVAILABLE', host_v[VProps.VITRAGE_AGGREGATED_STATE], 'host should be AVAILABLE when starting') # generate nagios alarm1 to trigger, raise alarm3 @@ -1174,7 +1242,7 @@ class TestScenarioEvaluator(TestFunctionalBase): _TARGET_HOST, _TARGET_HOST, entity_graph) - self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE], + self.assertEqual('AVAILABLE', host_v[VProps.VITRAGE_AGGREGATED_STATE], 'host should be AVAILABLE when starting') # generate nagios alarm_a to trigger @@ -1231,14 +1299,14 @@ class TestScenarioEvaluator(TestFunctionalBase): alarms = self._get_alarms_on_host(host_v, entity_graph) self.assertEqual(3, len(alarms)) - query = {VProps.CATEGORY: EntityCategory.ALARM, - VProps.IS_DELETED: True} + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_IS_DELETED: True} deleted_alarms = entity_graph.neighbors(host_v.vertex_id, vertex_attr_filter=query) self.assertEqual(num_orig_vertices + len(deleted_alarms) + 3, entity_graph.num_vertices()) - query = {VProps.IS_DELETED: True} + query = {VProps.VITRAGE_IS_DELETED: True} deleted_edges = entity_graph.neighbors(host_v.vertex_id, edge_attr_filter=query) self.assertEqual(num_orig_edges + len(deleted_edges) + 3, @@ -1256,14 +1324,14 @@ class TestScenarioEvaluator(TestFunctionalBase): alarms = self._get_alarms_on_host(host_v, entity_graph) self.assertEqual(1, len(alarms)) - query = {VProps.CATEGORY: EntityCategory.ALARM, - VProps.IS_DELETED: True} + query = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_IS_DELETED: True} deleted_alarms = entity_graph.neighbors(host_v.vertex_id, vertex_attr_filter=query) self.assertEqual(num_orig_vertices + len(deleted_alarms) + 1, entity_graph.num_vertices()) - query = {VProps.IS_DELETED: True} + query = {VProps.VITRAGE_IS_DELETED: True} deleted_edges = entity_graph.neighbors(host_v.vertex_id, edge_attr_filter=query) self.assertEqual(num_orig_edges + len(deleted_edges) + 1, @@ -1292,7 +1360,7 @@ class TestScenarioEvaluator(TestFunctionalBase): def _get_entity_from_graph(entity_type, entity_name, entity_id, entity_graph): - vertex_attrs = {VProps.TYPE: entity_type, + vertex_attrs = {VProps.VITRAGE_TYPE: entity_type, VProps.ID: entity_id, VProps.NAME: entity_name} vertices = entity_graph.get_vertices(vertex_attr_filter=vertex_attrs) @@ -1303,22 +1371,22 @@ class TestScenarioEvaluator(TestFunctionalBase): def _get_deduced_alarms_on_host(host_v, entity_graph): v_id = host_v.vertex_id vertex_attrs = {VProps.NAME: 'deduced_alarm', - VProps.TYPE: 'vitrage', - VProps.IS_DELETED: False, } + VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE, + VProps.VITRAGE_IS_DELETED: False, } return entity_graph.neighbors(v_id=v_id, vertex_attr_filter=vertex_attrs) @staticmethod def _get_alarms_on_host(host_v, entity_graph): v_id = host_v.vertex_id - vertex_attrs = {VProps.CATEGORY: EntityCategory.ALARM, - VProps.IS_DELETED: False, } + vertex_attrs = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_IS_DELETED: False, } return entity_graph.neighbors(v_id=v_id, vertex_attr_filter=vertex_attrs) @staticmethod def _get_alarm_causes(alarm_v, entity_graph): v_id = alarm_v.vertex_id - edge_attrs = {EProps.RELATIONSHIP_TYPE: "causes", - EProps.IS_DELETED: False, } + edge_attrs = {EProps.RELATIONSHIP_TYPE: EdgeLabel.CAUSES, + EProps.VITRAGE_IS_DELETED: False, } return entity_graph.neighbors(v_id=v_id, edge_attr_filter=edge_attrs) diff --git a/vitrage/tests/mocks/mock_driver.py b/vitrage/tests/mocks/mock_driver.py index d614d8225..41126a78d 100644 --- a/vitrage/tests/mocks/mock_driver.py +++ b/vitrage/tests/mocks/mock_driver.py @@ -15,8 +15,9 @@ """Methods for generating driver events -For each type of entity, need to supply configuration files that specify (a -regex of) what can be returned, which will be used to generate driver events +For each vitrage_type of entity, need to supply configuration files that +specify (a regex of) what can be returned, which will be used to generate +driver events usage example: test_entity_spec_list = [ diff --git a/vitrage/tests/resources/mock_configurations/driver/driver_host_snapshot_dynamic.json b/vitrage/tests/resources/mock_configurations/driver/driver_host_snapshot_dynamic.json index ad17d3a29..ea4d1888a 100644 --- a/vitrage/tests/resources/mock_configurations/driver/driver_host_snapshot_dynamic.json +++ b/vitrage/tests/resources/mock_configurations/driver/driver_host_snapshot_dynamic.json @@ -10,7 +10,7 @@ "vitrage_entity_type": "nova.host", "zone": "zone0", "id": "compute-0-0.local", - "category": "RESOURCE", + "vitrage_category": "RESOURCE", "vitrage_id": "compute-0-0.local", "vitrage_datasource_action": "init_snapshot", "vitrage_sample_date": "2015-12-01T12:46:41Z" diff --git a/vitrage/tests/resources/mock_configurations/driver/driver_inst_snapshot_dynamic.json b/vitrage/tests/resources/mock_configurations/driver/driver_inst_snapshot_dynamic.json index 79c42b26f..6c5913bc3 100644 --- a/vitrage/tests/resources/mock_configurations/driver/driver_inst_snapshot_dynamic.json +++ b/vitrage/tests/resources/mock_configurations/driver/driver_inst_snapshot_dynamic.json @@ -72,7 +72,7 @@ "key_name": null, "OS-EXT-SRV-ATTR:hypervisor_hostname": "nyakar-devstack", "name": "vm2", - "category": "RESOURCE", + "vitrage_category": "RESOURCE", "created": "2015-11-25T14:18:07Z", "tenant_id": "0683517e1e354d2ba25cba6937f44e79", "os-extended-volumes:volumes_attached": [], diff --git a/vitrage/tests/resources/mock_configurations/driver/driver_static_snapshot_dynamic.json b/vitrage/tests/resources/mock_configurations/driver/driver_static_snapshot_dynamic.json index a46e0ad4d..bc547138b 100644 --- a/vitrage/tests/resources/mock_configurations/driver/driver_static_snapshot_dynamic.json +++ b/vitrage/tests/resources/mock_configurations/driver/driver_static_snapshot_dynamic.json @@ -2,7 +2,7 @@ "name": "[switch|host|custom]-[1-9]", "id": "[1-9]{5}", "static_id": "[shc][1-9]", - "type": "[switch|nova.host|custom]", + "vitrage_type": "[switch|nova.host|custom]", "state": "available", "vitrage_datasource_action": "snapshot", "vitrage_sample_date": "2015-12-01T12:46:41Z", diff --git a/vitrage/tests/resources/mock_configurations/driver/driver_zone_snapshot_dynamic.json b/vitrage/tests/resources/mock_configurations/driver/driver_zone_snapshot_dynamic.json index 15b6d54f9..ffa9deb1a 100644 --- a/vitrage/tests/resources/mock_configurations/driver/driver_zone_snapshot_dynamic.json +++ b/vitrage/tests/resources/mock_configurations/driver/driver_zone_snapshot_dynamic.json @@ -14,7 +14,7 @@ "zoneName": "zone0", "id": "zone0", "vitrage_id": "zone0", - "category": "RESOURCE", + "vitrage_category": "RESOURCE", "zoneState": { "available": "True" } diff --git a/vitrage/tests/resources/mock_configurations/transformer/transformer_aodh_snapshot_dynamic.json b/vitrage/tests/resources/mock_configurations/transformer/transformer_aodh_snapshot_dynamic.json index 1e956aa12..a801b37f7 100644 --- a/vitrage/tests/resources/mock_configurations/transformer/transformer_aodh_snapshot_dynamic.json +++ b/vitrage/tests/resources/mock_configurations/transformer/transformer_aodh_snapshot_dynamic.json @@ -18,18 +18,18 @@ "vitrage_sample_date": "2016-11-29T06:31:50.094836", "graph_query_result": [ { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "dwj", "update_timestamp": "2016-12-02 07:18:05.628479+00:00", - "sample_timestamp": "2016-12-02 07:18:05.628479+00:00", - "operational_state": "OK", - "aggregated_state": "ACTIVE", + "vitrage_sample_timestamp": "2016-12-02 07:18:05.628479+00:00", + "vitrage_operational_state": "OK", + "vitrage_aggregated_state": "ACTIVE", "state": "ACTIVE", "graph_index": 3, "project_id": "f0895991f44044ccba8e62b201b70360", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "3dcee183-ca42-4ccb-84af-9f0196b2e160" } ] diff --git a/vitrage/tests/resources/mock_configurations/transformer/transformer_aodh_update_dynamic.json b/vitrage/tests/resources/mock_configurations/transformer/transformer_aodh_update_dynamic.json index 409ce256c..ccc06cd07 100644 --- a/vitrage/tests/resources/mock_configurations/transformer/transformer_aodh_update_dynamic.json +++ b/vitrage/tests/resources/mock_configurations/transformer/transformer_aodh_update_dynamic.json @@ -18,18 +18,18 @@ "vitrage_sample_date": "2016-11-29T06:31:50.094836", "graph_query_result": [ { - "category": "RESOURCE", - "is_placeholder": false, - "is_deleted": false, + "vitrage_category": "RESOURCE", + "vitrage_is_placeholder": false, + "vitrage_is_deleted": false, "name": "test", "update_timestamp": "2016-12-02 07:18:05.628479+00:00", - "sample_timestamp": "2016-12-02 07:18:05.628479+00:00", - "operational_state": "OK", - "aggregated_state": "ACTIVE", + "vitrage_sample_timestamp": "2016-12-02 07:18:05.628479+00:00", + "vitrage_operational_state": "OK", + "vitrage_aggregated_state": "ACTIVE", "state": "ACTIVE", "graph_index": 3, "project_id": "f0895991f44044ccba8e62b201b70360", - "type": "nova.instance", + "vitrage_type": "nova.instance", "id": "3dcee183-ca42-4ccb-84af-9f0196b2e160" } ] diff --git a/vitrage/tests/resources/snmp_notifier/oid_tree_with_severity_mapping.yaml b/vitrage/tests/resources/snmp_notifier/oid_tree_with_severity_mapping.yaml index 0cf79a4db..40b423d13 100644 --- a/vitrage/tests/resources/snmp_notifier/oid_tree_with_severity_mapping.yaml +++ b/vitrage/tests/resources/snmp_notifier/oid_tree_with_severity_mapping.yaml @@ -15,9 +15,9 @@ snmp_tree: next: name: oid: 1 - is_deleted: + vitrage_is_deleted: oid: 2 - operational_severity: + vitrage_operational_severity: oid: 3 ALARM_PREFIX: oid: 2 diff --git a/vitrage/tests/resources/snmp_notifier/oid_tree_without_severity_mapping.yaml b/vitrage/tests/resources/snmp_notifier/oid_tree_without_severity_mapping.yaml index 1fe08517a..9a8cfc27b 100644 --- a/vitrage/tests/resources/snmp_notifier/oid_tree_without_severity_mapping.yaml +++ b/vitrage/tests/resources/snmp_notifier/oid_tree_without_severity_mapping.yaml @@ -11,9 +11,9 @@ snmp_tree: next: name: oid: 1 - is_deleted: + vitrage_is_deleted: oid: 2 - operational_severity: + vitrage_operational_severity: oid: 3 ALARM_PREFIX: oid: 2 diff --git a/vitrage/tests/unit/datasources/aodh/aodh_transformer_base_test.py b/vitrage/tests/unit/datasources/aodh/aodh_transformer_base_test.py index 5e0ad2ea4..6fcf3d2c7 100644 --- a/vitrage/tests/unit/datasources/aodh/aodh_transformer_base_test.py +++ b/vitrage/tests/unit/datasources/aodh/aodh_transformer_base_test.py @@ -31,8 +31,9 @@ class AodhTransformerBaseTest(base.BaseTest): def _validate_aodh_vertex_props(self, vertex, event): - self.assertEqual(EntityCategory.ALARM, vertex[VProps.CATEGORY]) - self.assertEqual(event[DSProps.ENTITY_TYPE], vertex[VProps.TYPE]) + self.assertEqual(EntityCategory.ALARM, vertex[VProps.VITRAGE_CATEGORY]) + self.assertEqual(event[DSProps.ENTITY_TYPE], + vertex[VProps.VITRAGE_TYPE]) self.assertEqual(event[AodhProps.NAME], vertex[VProps.NAME]) self.assertEqual(event[AodhProps.SEVERITY], vertex[VProps.SEVERITY]) self.assertEqual(event[AodhProps.DESCRIPTION], @@ -50,7 +51,7 @@ class AodhTransformerBaseTest(base.BaseTest): self.assertEqual(event[AodhProps.STATE_TIMESTAMP], vertex[AodhProps.STATE_TIMESTAMP]) self.assertEqual(event[DSProps.SAMPLE_DATE], - vertex[VProps.SAMPLE_TIMESTAMP]) + vertex[VProps.VITRAGE_SAMPLE_TIMESTAMP]) event_status = event[AodhProps.STATE] if event_status == AodhState.OK: @@ -59,8 +60,8 @@ class AodhTransformerBaseTest(base.BaseTest): else: self.assertEqual(AlarmProps.ACTIVE_STATE, vertex[VProps.STATE]) - self.assertFalse(vertex[VProps.IS_PLACEHOLDER]) - self.assertFalse(vertex[VProps.IS_DELETED]) + self.assertFalse(vertex[VProps.VITRAGE_IS_PLACEHOLDER]) + self.assertFalse(vertex[VProps.VITRAGE_IS_DELETED]) def _validate_action(self, alarm, wrapper): if DSProps.EVENT_TYPE in alarm \ @@ -94,12 +95,12 @@ class AodhTransformerBaseTest(base.BaseTest): alarm_vertex_id): # validate neighbor vertex self.assertEqual(EntityCategory.RESOURCE, - alarm_neighbor.vertex[VProps.CATEGORY]) + alarm_neighbor.vertex[VProps.VITRAGE_CATEGORY]) self.assertEqual(NOVA_INSTANCE_DATASOURCE, - alarm_neighbor.vertex[VProps.TYPE]) + alarm_neighbor.vertex[VProps.VITRAGE_TYPE]) self.assertEqual(resource_id, alarm_neighbor.vertex[VProps.ID]) - self.assertFalse(alarm_neighbor.vertex[VProps.IS_PLACEHOLDER]) - self.assertFalse(alarm_neighbor.vertex[VProps.IS_DELETED]) + self.assertFalse(alarm_neighbor.vertex[VProps.VITRAGE_IS_PLACEHOLDER]) + self.assertFalse(alarm_neighbor.vertex[VProps.VITRAGE_IS_DELETED]) # Validate neighbor edge edge = alarm_neighbor.edge @@ -108,7 +109,7 @@ class AodhTransformerBaseTest(base.BaseTest): self.assertEqual(edge.label, EdgeLabel.ON) def _convert_dist_to_vertex(self, neighbor): - ver_id = neighbor[VProps.CATEGORY] + \ - TransformerBase.KEY_SEPARATOR + neighbor[VProps.TYPE] + \ + ver_id = neighbor[VProps.VITRAGE_CATEGORY] + \ + TransformerBase.KEY_SEPARATOR + neighbor[VProps.VITRAGE_TYPE] + \ TransformerBase.KEY_SEPARATOR + neighbor[VProps.ID] return Vertex(vertex_id=ver_id, properties=neighbor) diff --git a/vitrage/tests/unit/datasources/cinder/test_cinder_volume_transformer.py b/vitrage/tests/unit/datasources/cinder/test_cinder_volume_transformer.py index 6d0d57911..29a806d62 100644 --- a/vitrage/tests/unit/datasources/cinder/test_cinder_volume_transformer.py +++ b/vitrage/tests/unit/datasources/cinder/test_cinder_volume_transformer.py @@ -65,9 +65,9 @@ class TestCinderVolumeTransformer(base.BaseTest): timestamp = datetime.datetime.utcnow() properties = { VProps.ID: volume_id, - VProps.TYPE: CINDER_VOLUME_DATASOURCE, - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.SAMPLE_TIMESTAMP: timestamp + VProps.VITRAGE_TYPE: CINDER_VOLUME_DATASOURCE, + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_SAMPLE_TIMESTAMP: timestamp } transformer = self.transformers[CINDER_VOLUME_DATASOURCE] @@ -82,20 +82,20 @@ class TestCinderVolumeTransformer(base.BaseTest): volume_id) self.assertEqual(tuple(observed_id_values), expected_id_values) - observed_time = placeholder.get(VProps.SAMPLE_TIMESTAMP) + observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) self.assertEqual(observed_time, timestamp) - observed_type = placeholder.get(VProps.TYPE) + observed_type = placeholder.get(VProps.VITRAGE_TYPE) self.assertEqual(observed_type, CINDER_VOLUME_DATASOURCE) observed_entity_id = placeholder.get(VProps.ID) self.assertEqual(observed_entity_id, volume_id) - observed_category = placeholder.get(VProps.CATEGORY) - self.assertEqual(observed_category, EntityCategory.RESOURCE) + observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) + self.assertEqual(observed_vitrage_category, EntityCategory.RESOURCE) - is_placeholder = placeholder.get(VProps.IS_PLACEHOLDER) - self.assertEqual(is_placeholder, True) + vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) + self.assertEqual(vitrage_is_placeholder, True) def test_key_values(self): LOG.debug('Cinder Volume transformer test: get key values') @@ -164,8 +164,10 @@ class TestCinderVolumeTransformer(base.BaseTest): is_update_event = tbase.is_update_event(event) - self.assertEqual(EntityCategory.RESOURCE, vertex[VProps.CATEGORY]) - self.assertEqual(event[DSProps.ENTITY_TYPE], vertex[VProps.TYPE]) + self.assertEqual(EntityCategory.RESOURCE, + vertex[VProps.VITRAGE_CATEGORY]) + self.assertEqual(event[DSProps.ENTITY_TYPE], + vertex[VProps.VITRAGE_TYPE]) id_field_path = 'volume_id' if is_update_event else 'id' self.assertEqual( @@ -173,7 +175,7 @@ class TestCinderVolumeTransformer(base.BaseTest): vertex[VProps.ID]) self.assertEqual(event[DSProps.SAMPLE_DATE], - vertex[VProps.SAMPLE_TIMESTAMP]) + vertex[VProps.VITRAGE_SAMPLE_TIMESTAMP]) name_field_path = 'display_name' self.assertEqual( @@ -195,8 +197,8 @@ class TestCinderVolumeTransformer(base.BaseTest): tbase.extract_field_value(event, volume_type_field_path), vertex[CinderProps.VOLUME_TYPE]) - self.assertFalse(vertex[VProps.IS_PLACEHOLDER]) - self.assertFalse(vertex[VProps.IS_DELETED]) + self.assertFalse(vertex[VProps.VITRAGE_IS_PLACEHOLDER]) + self.assertFalse(vertex[VProps.VITRAGE_IS_DELETED]) def _validate_neighbors(self, neighbors, volume_vertex_id, event): instance_counter = 0 @@ -220,12 +222,13 @@ class TestCinderVolumeTransformer(base.BaseTest): volume_vertex_id): # validate neighbor vertex self.assertEqual(EntityCategory.RESOURCE, - instance_neighbor.vertex[VProps.CATEGORY]) + instance_neighbor.vertex[VProps.VITRAGE_CATEGORY]) self.assertEqual(NOVA_INSTANCE_DATASOURCE, - instance_neighbor.vertex[VProps.TYPE]) + instance_neighbor.vertex[VProps.VITRAGE_TYPE]) self.assertEqual(instance_id, instance_neighbor.vertex[VProps.ID]) - self.assertTrue(instance_neighbor.vertex[VProps.IS_PLACEHOLDER]) - self.assertFalse(instance_neighbor.vertex[VProps.IS_DELETED]) + self.assertTrue( + instance_neighbor.vertex[VProps.VITRAGE_IS_PLACEHOLDER]) + self.assertFalse(instance_neighbor.vertex[VProps.VITRAGE_IS_DELETED]) # Validate neighbor edge edge = instance_neighbor.edge diff --git a/vitrage/tests/unit/datasources/consistency/test_consistency_transformer.py b/vitrage/tests/unit/datasources/consistency/test_consistency_transformer.py index 4bf29c6cb..3b2278e95 100644 --- a/vitrage/tests/unit/datasources/consistency/test_consistency_transformer.py +++ b/vitrage/tests/unit/datasources/consistency/test_consistency_transformer.py @@ -101,5 +101,6 @@ class TestConsistencyTransformer(base.BaseTest): vertex_id = vertex.vertex_id self.assertIsNotNone(vertex_id) - sample_timestamp = vertex.get(VProps.SAMPLE_TIMESTAMP, None) - self.assertIsNotNone(sample_timestamp) + vitrage_sample_timestamp = \ + vertex.get(VProps.VITRAGE_SAMPLE_TIMESTAMP, None) + self.assertIsNotNone(vitrage_sample_timestamp) diff --git a/vitrage/tests/unit/datasources/heat/test_heat_stack_transformer.py b/vitrage/tests/unit/datasources/heat/test_heat_stack_transformer.py index c664f29c8..bceca7de2 100644 --- a/vitrage/tests/unit/datasources/heat/test_heat_stack_transformer.py +++ b/vitrage/tests/unit/datasources/heat/test_heat_stack_transformer.py @@ -66,9 +66,9 @@ class TestHeatStackTransformer(base.BaseTest): timestamp = datetime.datetime.utcnow() properties = { VProps.ID: stack_id, - VProps.TYPE: HEAT_STACK_DATASOURCE, - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.SAMPLE_TIMESTAMP: timestamp + VProps.VITRAGE_TYPE: HEAT_STACK_DATASOURCE, + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_SAMPLE_TIMESTAMP: timestamp } transformer = self.transformers[HEAT_STACK_DATASOURCE] @@ -83,20 +83,20 @@ class TestHeatStackTransformer(base.BaseTest): stack_id) self.assertEqual(tuple(observed_id_values), expected_id_values) - observed_time = placeholder.get(VProps.SAMPLE_TIMESTAMP) + observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) self.assertEqual(observed_time, timestamp) - observed_type = placeholder.get(VProps.TYPE) + observed_type = placeholder.get(VProps.VITRAGE_TYPE) self.assertEqual(observed_type, HEAT_STACK_DATASOURCE) observed_entity_id = placeholder.get(VProps.ID) self.assertEqual(observed_entity_id, stack_id) - observed_category = placeholder.get(VProps.CATEGORY) - self.assertEqual(observed_category, EntityCategory.RESOURCE) + observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) + self.assertEqual(observed_vitrage_category, EntityCategory.RESOURCE) - is_placeholder = placeholder.get(VProps.IS_PLACEHOLDER) - self.assertEqual(is_placeholder, True) + vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) + self.assertEqual(vitrage_is_placeholder, True) def test_key_values(self): LOG.debug('Heat Stack transformer test: get key values') @@ -165,8 +165,10 @@ class TestHeatStackTransformer(base.BaseTest): is_update_event = tbase.is_update_event(event) - self.assertEqual(EntityCategory.RESOURCE, vertex[VProps.CATEGORY]) - self.assertEqual(event[DSProps.ENTITY_TYPE], vertex[VProps.TYPE]) + self.assertEqual(EntityCategory.RESOURCE, + vertex[VProps.VITRAGE_CATEGORY]) + self.assertEqual(event[DSProps.ENTITY_TYPE], + vertex[VProps.VITRAGE_TYPE]) id_field_path = 'stack_identity' if is_update_event else 'id' self.assertEqual( @@ -174,7 +176,7 @@ class TestHeatStackTransformer(base.BaseTest): vertex[VProps.ID]) self.assertEqual(event[DSProps.SAMPLE_DATE], - vertex[VProps.SAMPLE_TIMESTAMP]) + vertex[VProps.VITRAGE_SAMPLE_TIMESTAMP]) name_field_path = 'stack_name' self.assertEqual( @@ -186,8 +188,8 @@ class TestHeatStackTransformer(base.BaseTest): tbase.extract_field_value(event, state_field_path), vertex[VProps.STATE]) - self.assertFalse(vertex[VProps.IS_PLACEHOLDER]) - self.assertFalse(vertex[VProps.IS_DELETED]) + self.assertFalse(vertex[VProps.VITRAGE_IS_PLACEHOLDER]) + self.assertFalse(vertex[VProps.VITRAGE_IS_DELETED]) def _validate_neighbors(self, neighbors, stack_vertex_id, event): self.assertEqual(2, len(neighbors)) @@ -211,12 +213,13 @@ class TestHeatStackTransformer(base.BaseTest): stack_vertex_id): # validate neighbor vertex self.assertEqual(EntityCategory.RESOURCE, - instance_neighbor.vertex[VProps.CATEGORY]) + instance_neighbor.vertex[VProps.VITRAGE_CATEGORY]) self.assertEqual(datasource_type, - instance_neighbor.vertex[VProps.TYPE]) + instance_neighbor.vertex[VProps.VITRAGE_TYPE]) self.assertEqual(instance_id, instance_neighbor.vertex[VProps.ID]) - self.assertTrue(instance_neighbor.vertex[VProps.IS_PLACEHOLDER]) - self.assertFalse(instance_neighbor.vertex[VProps.IS_DELETED]) + self.assertTrue( + instance_neighbor.vertex[VProps.VITRAGE_IS_PLACEHOLDER]) + self.assertFalse(instance_neighbor.vertex[VProps.VITRAGE_IS_DELETED]) # Validate neighbor edge edge = instance_neighbor.edge diff --git a/vitrage/tests/unit/datasources/nagios/test_nagios_transformer.py b/vitrage/tests/unit/datasources/nagios/test_nagios_transformer.py index 5ed0a5c76..91a4cad1a 100644 --- a/vitrage/tests/unit/datasources/nagios/test_nagios_transformer.py +++ b/vitrage/tests/unit/datasources/nagios/test_nagios_transformer.py @@ -100,7 +100,7 @@ class NagiosTransformerTest(base.BaseTest): neighbor = neighbors[0] # Right now we are support only host as a resource - if neighbor.vertex[VProps.TYPE] == NOVA_HOST_DATASOURCE: + if neighbor.vertex[VProps.VITRAGE_TYPE] == NOVA_HOST_DATASOURCE: self._validate_host_neighbor(neighbors[0], alarm) self._validate_action(alarm, wrapper) @@ -117,8 +117,9 @@ class NagiosTransformerTest(base.BaseTest): def _validate_vertex(self, vertex, event): - self.assertEqual(EntityCategory.ALARM, vertex[VProps.CATEGORY]) - self.assertEqual(event[DSProps.ENTITY_TYPE], vertex[VProps.TYPE]) + self.assertEqual(EntityCategory.ALARM, vertex[VProps.VITRAGE_CATEGORY]) + self.assertEqual(event[DSProps.ENTITY_TYPE], + vertex[VProps.VITRAGE_TYPE]) self.assertEqual(event[NagiosProperties.SERVICE], vertex[VProps.NAME]) self.assertEqual(datetime_utils.change_to_utc_time_and_format( event[NagiosProperties.LAST_CHECK], @@ -143,8 +144,8 @@ class NagiosTransformerTest(base.BaseTest): self.assertEqual(event[NagiosProperties.STATUS_INFO], vertex[VProps.INFO]) - self.assertFalse(vertex[VProps.IS_DELETED]) - self.assertFalse(vertex[VProps.IS_PLACEHOLDER]) + self.assertFalse(vertex[VProps.VITRAGE_IS_DELETED]) + self.assertFalse(vertex[VProps.VITRAGE_IS_PLACEHOLDER]) def _validate_host_neighbor(self, neighbor, event): @@ -156,13 +157,15 @@ class NagiosTransformerTest(base.BaseTest): self.assertEqual(NOVA_HOST_DATASOURCE, key_fields[1]) self.assertEqual(event[NagiosProperties.RESOURCE_NAME], key_fields[2]) - self.assertFalse(host_vertex[VProps.IS_DELETED]) - self.assertTrue(host_vertex[VProps.IS_PLACEHOLDER]) + self.assertFalse(host_vertex[VProps.VITRAGE_IS_DELETED]) + self.assertTrue(host_vertex[VProps.VITRAGE_IS_PLACEHOLDER]) - self.assertEqual(EntityCategory.RESOURCE, host_vertex[VProps.CATEGORY]) + self.assertEqual(EntityCategory.RESOURCE, + host_vertex[VProps.VITRAGE_CATEGORY]) self.assertEqual(event[NagiosProperties.RESOURCE_NAME], host_vertex[VProps.ID]) - self.assertEqual(NOVA_HOST_DATASOURCE, host_vertex[VProps.TYPE]) + self.assertEqual(NOVA_HOST_DATASOURCE, + host_vertex[VProps.VITRAGE_TYPE]) edge = neighbor.edge self.assertEqual(EdgeLabel.ON, edge.label) diff --git a/vitrage/tests/unit/datasources/nova/test_nova_host_transformer.py b/vitrage/tests/unit/datasources/nova/test_nova_host_transformer.py index 879e8a958..0fb39b777 100644 --- a/vitrage/tests/unit/datasources/nova/test_nova_host_transformer.py +++ b/vitrage/tests/unit/datasources/nova/test_nova_host_transformer.py @@ -67,9 +67,9 @@ class NovaHostTransformerTest(base.BaseTest): # Test action properties = { VProps.ID: host_name, - VProps.TYPE: NOVA_HOST_DATASOURCE, - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.SAMPLE_TIMESTAMP: timestamp + VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE, + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_SAMPLE_TIMESTAMP: timestamp } placeholder = \ host_transformer.create_neighbor_placeholder_vertex(**properties) @@ -82,20 +82,20 @@ class NovaHostTransformerTest(base.BaseTest): host_name) self.assertEqual(tuple(observed_id_values), expected_id_values) - observed_time = placeholder.get(VProps.SAMPLE_TIMESTAMP) + observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) self.assertEqual(observed_time, timestamp) - observed_subtype = placeholder.get(VProps.TYPE) + observed_subtype = placeholder.get(VProps.VITRAGE_TYPE) self.assertEqual(observed_subtype, NOVA_HOST_DATASOURCE) observed_entity_id = placeholder.get(VProps.ID) self.assertEqual(observed_entity_id, host_name) - observed_category = placeholder.get(VProps.CATEGORY) - self.assertEqual(observed_category, EntityCategory.RESOURCE) + observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) + self.assertEqual(observed_vitrage_category, EntityCategory.RESOURCE) - is_placeholder = placeholder.get(VProps.IS_PLACEHOLDER) - self.assertEqual(is_placeholder, True) + vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) + self.assertEqual(vitrage_is_placeholder, True) def test_key_values(self): @@ -149,9 +149,9 @@ class NovaHostTransformerTest(base.BaseTest): zt = self.transformers[NOVA_ZONE_DATASOURCE] properties = { VProps.ID: zone_name, - VProps.TYPE: NOVA_ZONE_DATASOURCE, - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.SAMPLE_TIMESTAMP: time + VProps.VITRAGE_TYPE: NOVA_ZONE_DATASOURCE, + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_SAMPLE_TIMESTAMP: time } expected_neighbor = \ zt.create_neighbor_placeholder_vertex(**properties) @@ -175,27 +175,27 @@ class NovaHostTransformerTest(base.BaseTest): self.assertEqual(expected_id, observed_id) self.assertEqual( EntityCategory.RESOURCE, - vertex[VProps.CATEGORY] + vertex[VProps.VITRAGE_CATEGORY] ) self.assertEqual( NOVA_HOST_DATASOURCE, - vertex[VProps.TYPE] + vertex[VProps.VITRAGE_TYPE] ) expected_timestamp = event[DSProps.SAMPLE_DATE] - observed_timestamp = vertex[VProps.SAMPLE_TIMESTAMP] + observed_timestamp = vertex[VProps.VITRAGE_SAMPLE_TIMESTAMP] self.assertEqual(expected_timestamp, observed_timestamp) expected_name = extract_value(event, '_info', 'host_name') observed_name = vertex[VProps.NAME] self.assertEqual(expected_name, observed_name) - is_placeholder = vertex[VProps.IS_PLACEHOLDER] - self.assertFalse(is_placeholder) + vitrage_is_placeholder = vertex[VProps.VITRAGE_IS_PLACEHOLDER] + self.assertFalse(vitrage_is_placeholder) - is_deleted = vertex[VProps.IS_DELETED] - self.assertFalse(is_deleted) + vitrage_is_deleted = vertex[VProps.VITRAGE_IS_DELETED] + self.assertFalse(vitrage_is_deleted) def test_extract_event_action(self): LOG.debug('Test extract event action') diff --git a/vitrage/tests/unit/datasources/nova/test_nova_instance_transformer.py b/vitrage/tests/unit/datasources/nova/test_nova_instance_transformer.py index 32d192d5b..3934a758b 100644 --- a/vitrage/tests/unit/datasources/nova/test_nova_instance_transformer.py +++ b/vitrage/tests/unit/datasources/nova/test_nova_instance_transformer.py @@ -64,9 +64,9 @@ class NovaInstanceTransformerTest(base.BaseTest): timestamp = datetime.datetime.utcnow() properties = { VProps.ID: instance_id, - VProps.TYPE: NOVA_INSTANCE_DATASOURCE, - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.SAMPLE_TIMESTAMP: timestamp + VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE, + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_SAMPLE_TIMESTAMP: timestamp } transformer = self.transformers[NOVA_INSTANCE_DATASOURCE] @@ -81,20 +81,20 @@ class NovaInstanceTransformerTest(base.BaseTest): instance_id) self.assertEqual(tuple(observed_id_values), expected_id_values) - observed_time = placeholder.get(VProps.SAMPLE_TIMESTAMP) + observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) self.assertEqual(observed_time, timestamp) - observed_type = placeholder.get(VProps.TYPE) + observed_type = placeholder.get(VProps.VITRAGE_TYPE) self.assertEqual(observed_type, NOVA_INSTANCE_DATASOURCE) observed_entity_id = placeholder.get(VProps.ID) self.assertEqual(observed_entity_id, instance_id) - observed_category = placeholder.get(VProps.CATEGORY) - self.assertEqual(observed_category, EntityCategory.RESOURCE) + observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) + self.assertEqual(observed_vitrage_category, EntityCategory.RESOURCE) - is_placeholder = placeholder.get(VProps.IS_PLACEHOLDER) - self.assertEqual(is_placeholder, True) + vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) + self.assertEqual(vitrage_is_placeholder, True) def test_snapshot_event_transform(self): LOG.debug('Test tactual transform action for ' @@ -173,10 +173,10 @@ class NovaInstanceTransformerTest(base.BaseTest): self.assertEqual( EntityCategory.RESOURCE, - vertex[VProps.CATEGORY] + vertex[VProps.VITRAGE_CATEGORY] ) self.assertEqual(NOVA_INSTANCE_DATASOURCE, - vertex[VProps.TYPE]) + vertex[VProps.VITRAGE_TYPE]) expected_project = extract_value(event, 'tenant_id') observed_project = vertex[VProps.PROJECT_ID] @@ -188,7 +188,7 @@ class NovaInstanceTransformerTest(base.BaseTest): self.assertEqual(expected_state, observed_state) expected_timestamp = event[DSProps.SAMPLE_DATE] - observed_timestamp = vertex[VProps.SAMPLE_TIMESTAMP] + observed_timestamp = vertex[VProps.VITRAGE_SAMPLE_TIMESTAMP] self.assertEqual(expected_timestamp, observed_timestamp) name = 'hostname' if is_update_event else 'name' @@ -196,11 +196,11 @@ class NovaInstanceTransformerTest(base.BaseTest): observed_name = vertex[VProps.NAME] self.assertEqual(expected_name, observed_name) - is_placeholder = vertex[VProps.IS_PLACEHOLDER] - self.assertFalse(is_placeholder) + vitrage_is_placeholder = vertex[VProps.VITRAGE_IS_PLACEHOLDER] + self.assertFalse(vitrage_is_placeholder) - is_deleted = vertex[VProps.IS_DELETED] - self.assertFalse(is_deleted) + vitrage_is_deleted = vertex[VProps.VITRAGE_IS_DELETED] + self.assertFalse(vitrage_is_deleted) def _validate_host_neighbor(self, h_neighbor, event): @@ -214,9 +214,9 @@ class NovaInstanceTransformerTest(base.BaseTest): ht = self.transformers[NOVA_HOST_DATASOURCE] properties = { VProps.ID: host_name, - VProps.TYPE: NOVA_HOST_DATASOURCE, - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.SAMPLE_TIMESTAMP: time + VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE, + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_SAMPLE_TIMESTAMP: time } expected_neighbor = \ ht.create_neighbor_placeholder_vertex(**properties) @@ -313,7 +313,7 @@ class NovaInstanceTransformerTest(base.BaseTest): self.assertEqual(host_vertex_id, neighbor.vertex.vertex_id) self.assertEqual( time, - neighbor.vertex.get(VProps.SAMPLE_TIMESTAMP) + neighbor.vertex.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) ) # test relation edge diff --git a/vitrage/tests/unit/datasources/nova/test_nova_zone_transformer.py b/vitrage/tests/unit/datasources/nova/test_nova_zone_transformer.py index 5182e42fa..61f5a1820 100644 --- a/vitrage/tests/unit/datasources/nova/test_nova_zone_transformer.py +++ b/vitrage/tests/unit/datasources/nova/test_nova_zone_transformer.py @@ -68,9 +68,9 @@ class NovaZoneTransformerTest(base.BaseTest): # Test action properties = { VProps.ID: zone_name, - VProps.TYPE: NOVA_ZONE_DATASOURCE, - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.SAMPLE_TIMESTAMP: timestamp + VProps.VITRAGE_TYPE: NOVA_ZONE_DATASOURCE, + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_SAMPLE_TIMESTAMP: timestamp } placeholder = \ zone_transformer.create_neighbor_placeholder_vertex(**properties) @@ -82,20 +82,20 @@ class NovaZoneTransformerTest(base.BaseTest): _key_values(NOVA_ZONE_DATASOURCE, zone_name) self.assertEqual(tuple(observed_id_values), expected_id_values) - observed_time = placeholder.get(VProps.SAMPLE_TIMESTAMP) + observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) self.assertEqual(observed_time, timestamp) - observed_subtype = placeholder.get(VProps.TYPE) + observed_subtype = placeholder.get(VProps.VITRAGE_TYPE) self.assertEqual(observed_subtype, NOVA_ZONE_DATASOURCE) observed_entity_id = placeholder.get(VProps.ID) self.assertEqual(observed_entity_id, zone_name) - observed_category = placeholder.get(VProps.CATEGORY) - self.assertEqual(observed_category, EntityCategory.RESOURCE) + observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) + self.assertEqual(observed_vitrage_category, EntityCategory.RESOURCE) - is_placeholder = placeholder.get(VProps.IS_PLACEHOLDER) - self.assertEqual(is_placeholder, True) + vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) + self.assertEqual(vitrage_is_placeholder, True) def test_key_values(self): LOG.debug('Zone transformer test: get key values') @@ -146,7 +146,7 @@ class NovaZoneTransformerTest(base.BaseTest): cluster_neighbors_counter = 0 for neighbor in neighbors: - vertex_type = neighbor.vertex.get(VProps.TYPE) + vertex_type = neighbor.vertex.get(VProps.VITRAGE_TYPE) if OPENSTACK_CLUSTER == vertex_type: cluster_neighbors_counter += 1 @@ -192,11 +192,11 @@ class NovaZoneTransformerTest(base.BaseTest): host_vertex.get(VProps.STATE) ) - is_placeholder = host_vertex[VProps.IS_PLACEHOLDER] - self.assertFalse(is_placeholder) + vitrage_is_placeholder = host_vertex[VProps.VITRAGE_IS_PLACEHOLDER] + self.assertFalse(vitrage_is_placeholder) - is_deleted = host_vertex[VProps.IS_DELETED] - self.assertFalse(is_deleted) + vitrage_is_deleted = host_vertex[VProps.VITRAGE_IS_DELETED] + self.assertFalse(vitrage_is_deleted) # Validate neighbor edge edge = host_neighbor.edge @@ -209,15 +209,15 @@ class NovaZoneTransformerTest(base.BaseTest): self.assertEqual(cluster_neighbor.vertex[VProps.VITRAGE_ID], cluster_neighbor.vertex.vertex_id) self.assertEqual(False, - cluster_neighbor.vertex[VProps.IS_DELETED]) + cluster_neighbor.vertex[VProps.VITRAGE_IS_DELETED]) self.assertEqual(EntityCategory.RESOURCE, - cluster_neighbor.vertex[VProps.CATEGORY]) + cluster_neighbor.vertex[VProps.VITRAGE_CATEGORY]) self.assertEqual(CLUSTER_ID, cluster_neighbor.vertex[VProps.ID]) - self.assertEqual(False, - cluster_neighbor.vertex[VProps.IS_PLACEHOLDER]) + self.assertEqual(False, cluster_neighbor.vertex[ + VProps.VITRAGE_IS_PLACEHOLDER]) self.assertEqual(OPENSTACK_CLUSTER, - cluster_neighbor.vertex[VProps.TYPE]) + cluster_neighbor.vertex[VProps.VITRAGE_TYPE]) # Validate neighbor edge edge = cluster_neighbor.edge @@ -236,13 +236,13 @@ class NovaZoneTransformerTest(base.BaseTest): self.assertEqual(expected_id, observed_id) self.assertEqual(EntityCategory.RESOURCE, - vertex[VProps.CATEGORY]) + vertex[VProps.VITRAGE_CATEGORY]) self.assertEqual(NOVA_ZONE_DATASOURCE, - vertex[VProps.TYPE]) + vertex[VProps.VITRAGE_TYPE]) expected_timestamp = event[DSProps.SAMPLE_DATE] - observed_timestamp = vertex[VProps.SAMPLE_TIMESTAMP] + observed_timestamp = vertex[VProps.VITRAGE_SAMPLE_TIMESTAMP] self.assertEqual(expected_timestamp, observed_timestamp) expected_name = extract_value(event, 'zoneName') @@ -259,8 +259,8 @@ class NovaZoneTransformerTest(base.BaseTest): observed_state = vertex[VProps.STATE] self.assertEqual(expected_state, observed_state) - is_placeholder = vertex[VProps.IS_PLACEHOLDER] - self.assertFalse(is_placeholder) + vitrage_is_placeholder = vertex[VProps.VITRAGE_IS_PLACEHOLDER] + self.assertFalse(vitrage_is_placeholder) - is_deleted = vertex[VProps.IS_DELETED] - self.assertFalse(is_deleted) + vitrage_is_deleted = vertex[VProps.VITRAGE_IS_DELETED] + self.assertFalse(vitrage_is_deleted) diff --git a/vitrage/tests/unit/datasources/static/test_static_transformer.py b/vitrage/tests/unit/datasources/static/test_static_transformer.py index c598fc879..c37423105 100644 --- a/vitrage/tests/unit/datasources/static/test_static_transformer.py +++ b/vitrage/tests/unit/datasources/static/test_static_transformer.py @@ -57,10 +57,10 @@ class TestStaticTransformer(base.BaseTest): def test_create_placeholder_vertex(self): properties = { - VProps.TYPE: self.entity_type, + VProps.VITRAGE_TYPE: self.entity_type, VProps.ID: self.entity_id, - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.SAMPLE_TIMESTAMP: self.timestamp + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_SAMPLE_TIMESTAMP: self.timestamp } placeholder = self.transformer.create_neighbor_placeholder_vertex( **properties) @@ -69,20 +69,20 @@ class TestStaticTransformer(base.BaseTest): expected_entity_id = 'RESOURCE:static:12345' self.assertEqual(observed_entity_id, expected_entity_id) - observed_time = placeholder.get(VProps.SAMPLE_TIMESTAMP) + observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) self.assertEqual(observed_time, self.timestamp) - observed_subtype = placeholder.get(VProps.TYPE) + observed_subtype = placeholder.get(VProps.VITRAGE_TYPE) self.assertEqual(observed_subtype, self.entity_type) observed_entity_id = placeholder.get(VProps.ID) self.assertEqual(observed_entity_id, self.entity_id) - observed_category = placeholder.get(VProps.CATEGORY) - self.assertEqual(observed_category, EntityCategory.RESOURCE) + observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) + self.assertEqual(observed_vitrage_category, EntityCategory.RESOURCE) - is_placeholder = placeholder.get(VProps.IS_PLACEHOLDER) - self.assertEqual(is_placeholder, True) + vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) + self.assertEqual(vitrage_is_placeholder, True) def test_snapshot_transform(self): vals_list = mock_driver.simple_static_generators(snapshot_events=1) @@ -106,17 +106,19 @@ class TestStaticTransformer(base.BaseTest): def _validate_vertex(self, vertex, event): self._validate_common_props(vertex, event) - self.assertEqual(vertex[VProps.SAMPLE_TIMESTAMP], + self.assertEqual(vertex[VProps.VITRAGE_SAMPLE_TIMESTAMP], event[DSProps.SAMPLE_DATE]) for k, v in event.get(StaticFields.METADATA, {}): self.assertEqual(vertex[k], v) def _validate_common_props(self, vertex, event): - self.assertEqual(vertex[VProps.CATEGORY], EntityCategory.RESOURCE) - self.assertEqual(vertex[VProps.TYPE], event[VProps.TYPE]) - self.assertEqual(vertex[VProps.ID], event[VProps.ID]) - self.assertFalse(vertex[VProps.IS_DELETED]) + self.assertEqual(vertex[VProps.VITRAGE_CATEGORY], + EntityCategory.RESOURCE) + self.assertEqual(vertex[VProps.VITRAGE_TYPE], + event[StaticFields.TYPE]) + self.assertEqual(vertex[VProps.ID], event[StaticFields.ID]) + self.assertFalse(vertex[VProps.VITRAGE_IS_DELETED]) def _validate_neighbors(self, neighbors, vertex_id, event): for i in range(len(neighbors)): @@ -139,4 +141,4 @@ class TestStaticTransformer(base.BaseTest): def _validate_neighbor_vertex_props(self, vertex, event): self._validate_common_props(vertex, event) - self.assertTrue(vertex[VProps.IS_PLACEHOLDER]) + self.assertTrue(vertex[VProps.VITRAGE_IS_PLACEHOLDER]) diff --git a/vitrage/tests/unit/datasources/static_physical/test_static_physical_driver.py b/vitrage/tests/unit/datasources/static_physical/test_static_physical_driver.py index d5889f6ae..db4640d21 100644 --- a/vitrage/tests/unit/datasources/static_physical/test_static_physical_driver.py +++ b/vitrage/tests/unit/datasources/static_physical/test_static_physical_driver.py @@ -20,7 +20,7 @@ from vitrage.common.constants import DatasourceAction from vitrage.common.constants import DatasourceOpts as DSOpts from vitrage.common.constants import DatasourceProperties as DSProps from vitrage.common.constants import GraphAction -from vitrage.common.constants import VertexProperties as VProps +from vitrage.datasources.static import StaticFields from vitrage.datasources.static_physical import driver from vitrage.datasources.static_physical import STATIC_PHYSICAL_DATASOURCE from vitrage.datasources.static_physical import SWITCH @@ -111,25 +111,25 @@ class TestStaticPhysicalDriver(base.BaseTest): GraphAction.UPDATE_ENTITY) # Test Assertions - status = any(change[VProps.TYPE] == SWITCH and - change[VProps.ID] == '12345' for change in changes) + status = any(change[StaticFields.TYPE] == SWITCH and + change[StaticFields.ID] == '12345' for change in changes) self.assertEqual(False, status) - status = any(change[VProps.TYPE] == SWITCH and - change[VProps.ID] == '23456' and + status = any(change[StaticFields.TYPE] == SWITCH and + change[StaticFields.ID] == '23456' and change[DSProps.EVENT_TYPE] == GraphAction.DELETE_ENTITY for change in changes) self.assertEqual(True, status) - status = any(change[VProps.TYPE] == SWITCH and - change[VProps.ID] == '34567' for change in changes) + status = any(change[StaticFields.TYPE] == SWITCH and + change[StaticFields.ID] == '34567' for change in changes) self.assertEqual(True, status) - status = any(change[VProps.TYPE] == SWITCH and - change[VProps.ID] == '45678' for change in changes) + status = any(change[StaticFields.TYPE] == SWITCH and + change[StaticFields.ID] == '45678' for change in changes) self.assertEqual(True, status) - status = any(change[VProps.TYPE] == SWITCH and - change[VProps.ID] == '56789' for change in changes) + status = any(change[StaticFields.TYPE] == SWITCH and + change[StaticFields.ID] == '56789' for change in changes) self.assertEqual(True, status) self.assertEqual(4, len(changes)) diff --git a/vitrage/tests/unit/datasources/static_physical/test_static_physical_transformer.py b/vitrage/tests/unit/datasources/static_physical/test_static_physical_transformer.py index e26f8f788..946ea8ec4 100644 --- a/vitrage/tests/unit/datasources/static_physical/test_static_physical_transformer.py +++ b/vitrage/tests/unit/datasources/static_physical/test_static_physical_transformer.py @@ -25,6 +25,7 @@ from vitrage.common.constants import UpdateMethod from vitrage.common.constants import VertexProperties as VProps from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE from vitrage.datasources.nova.host.transformer import HostTransformer +from vitrage.datasources.static import StaticFields from vitrage.datasources.static_physical import STATIC_PHYSICAL_DATASOURCE from vitrage.datasources.static_physical.transformer \ import StaticPhysicalTransformer @@ -66,10 +67,10 @@ class TestStaticPhysicalTransformer(base.BaseTest): # Test action properties = { - VProps.TYPE: switch_type, + VProps.VITRAGE_TYPE: switch_type, VProps.ID: switch_name, - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.SAMPLE_TIMESTAMP: timestamp + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_SAMPLE_TIMESTAMP: timestamp } placeholder = \ static_transformer.create_neighbor_placeholder_vertex(**properties) @@ -82,20 +83,20 @@ class TestStaticPhysicalTransformer(base.BaseTest): switch_type, switch_name) self.assertEqual(tuple(observed_id_values), expected_id_values) - observed_time = placeholder.get(VProps.SAMPLE_TIMESTAMP) + observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) self.assertEqual(observed_time, timestamp) - observed_subtype = placeholder.get(VProps.TYPE) + observed_subtype = placeholder.get(VProps.VITRAGE_TYPE) self.assertEqual(observed_subtype, switch_type) observed_entity_id = placeholder.get(VProps.ID) self.assertEqual(observed_entity_id, switch_name) - observed_category = placeholder.get(VProps.CATEGORY) - self.assertEqual(observed_category, EntityCategory.RESOURCE) + observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) + self.assertEqual(observed_vitrage_category, EntityCategory.RESOURCE) - is_placeholder = placeholder.get(VProps.IS_PLACEHOLDER) - self.assertEqual(is_placeholder, True) + vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) + self.assertEqual(vitrage_is_placeholder, True) def test_key_values(self): LOG.debug('Static Physical transformer test: get key values') @@ -171,20 +172,22 @@ class TestStaticPhysicalTransformer(base.BaseTest): self.assertEqual(edge.label, EdgeLabel.CONTAINS) def _validate_common_vertex_props(self, vertex, event): - self.assertEqual(EntityCategory.RESOURCE, vertex[VProps.CATEGORY]) - self.assertEqual(event[VProps.TYPE], vertex[VProps.TYPE]) - self.assertEqual(event[VProps.ID], vertex[VProps.ID]) + self.assertEqual(EntityCategory.RESOURCE, + vertex[VProps.VITRAGE_CATEGORY]) + self.assertEqual(event[StaticFields.TYPE], + vertex[VProps.VITRAGE_TYPE]) + self.assertEqual(event[StaticFields.ID], vertex[VProps.ID]) def _validate_switch_vertex_props(self, vertex, event): self._validate_common_vertex_props(vertex, event) self.assertEqual(event[DSProps.SAMPLE_DATE], - vertex[VProps.SAMPLE_TIMESTAMP]) + vertex[VProps.VITRAGE_SAMPLE_TIMESTAMP]) self.assertEqual(event[VProps.NAME], vertex[VProps.NAME]) self.assertEqual(event[VProps.STATE], vertex[VProps.STATE]) - self.assertFalse(vertex[VProps.IS_PLACEHOLDER]) - self.assertFalse(vertex[VProps.IS_DELETED]) + self.assertFalse(vertex[VProps.VITRAGE_IS_PLACEHOLDER]) + self.assertFalse(vertex[VProps.VITRAGE_IS_DELETED]) def _validate_host_vertex_props(self, vertex, event): self._validate_common_vertex_props(vertex, event) - self.assertTrue(vertex[VProps.IS_PLACEHOLDER]) - self.assertFalse(vertex[VProps.IS_DELETED]) + self.assertTrue(vertex[VProps.VITRAGE_IS_PLACEHOLDER]) + self.assertFalse(vertex[VProps.VITRAGE_IS_DELETED]) diff --git a/vitrage/tests/unit/datasources/test_alarm_transformer_base.py b/vitrage/tests/unit/datasources/test_alarm_transformer_base.py index 0c23439c3..d084541ba 100644 --- a/vitrage/tests/unit/datasources/test_alarm_transformer_base.py +++ b/vitrage/tests/unit/datasources/test_alarm_transformer_base.py @@ -36,8 +36,9 @@ class BaseAlarmTransformerTest(BaseTransformerTest): expected_name, expected_datasource_name) - self.assertEqual(EntityCategory.ALARM, vertex[VProps.CATEGORY]) - self.assertEqual(expected_sample_time, vertex[VProps.SAMPLE_TIMESTAMP]) + self.assertEqual(EntityCategory.ALARM, vertex[VProps.VITRAGE_CATEGORY]) + self.assertEqual(expected_sample_time, + vertex[VProps.VITRAGE_SAMPLE_TIMESTAMP]) if self._is_erroneous(vertex): self.assertEqual(AlarmProps.ACTIVE_STATE, vertex[VProps.STATE]) @@ -55,9 +56,10 @@ class BaseAlarmTransformerTest(BaseTransformerTest): host_transformer = self.transformers[NOVA_HOST_DATASOURCE] properties = { VProps.ID: host_name, - VProps.TYPE: NOVA_HOST_DATASOURCE, - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.SAMPLE_TIMESTAMP: wrapper.vertex[VProps.SAMPLE_TIMESTAMP], + VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE, + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_SAMPLE_TIMESTAMP: + wrapper.vertex[VProps.VITRAGE_SAMPLE_TIMESTAMP], } expected_neighbor = host_transformer.\ create_neighbor_placeholder_vertex(**properties) diff --git a/vitrage/tests/unit/datasources/test_transformer_base.py b/vitrage/tests/unit/datasources/test_transformer_base.py index 5fed85564..8c7d40278 100644 --- a/vitrage/tests/unit/datasources/test_transformer_base.py +++ b/vitrage/tests/unit/datasources/test_transformer_base.py @@ -23,6 +23,6 @@ class BaseTransformerTest(base.BaseTest): vertex, expected_name, expected_datasource_name): - self.assertFalse(vertex[VProps.IS_PLACEHOLDER]) - self.assertEqual(expected_datasource_name, vertex[VProps.TYPE]) + self.assertFalse(vertex[VProps.VITRAGE_IS_PLACEHOLDER]) + self.assertEqual(expected_datasource_name, vertex[VProps.VITRAGE_TYPE]) self.assertEqual(expected_name, vertex[VProps.NAME]) diff --git a/vitrage/tests/unit/datasources/zabbix/test_zabbix_transformer.py b/vitrage/tests/unit/datasources/zabbix/test_zabbix_transformer.py index 312ced535..c778933fa 100644 --- a/vitrage/tests/unit/datasources/zabbix/test_zabbix_transformer.py +++ b/vitrage/tests/unit/datasources/zabbix/test_zabbix_transformer.py @@ -103,7 +103,7 @@ class ZabbixTransformerTest(base.BaseTest): neighbor = neighbors[0] # Right now we are support only host as a resource - if neighbor.vertex[VProps.TYPE] == NOVA_HOST_DATASOURCE: + if neighbor.vertex[VProps.VITRAGE_TYPE] == NOVA_HOST_DATASOURCE: self._validate_host_neighbor(neighbors[0], alarm) self._validate_action(alarm, wrapper) @@ -120,8 +120,9 @@ class ZabbixTransformerTest(base.BaseTest): def _validate_vertex(self, vertex, event): - self.assertEqual(EntityCategory.ALARM, vertex[VProps.CATEGORY]) - self.assertEqual(event[DSProps.ENTITY_TYPE], vertex[VProps.TYPE]) + self.assertEqual(EntityCategory.ALARM, vertex[VProps.VITRAGE_CATEGORY]) + self.assertEqual(event[DSProps.ENTITY_TYPE], + vertex[VProps.VITRAGE_TYPE]) self.assertEqual(event[ZabbixProps.DESCRIPTION], vertex[VProps.NAME]) @@ -138,8 +139,8 @@ class ZabbixTransformerTest(base.BaseTest): event[ZabbixProps.PRIORITY]) self.assertEqual(event_severity, vertex[VProps.SEVERITY]) - self.assertFalse(vertex[VProps.IS_DELETED]) - self.assertFalse(vertex[VProps.IS_PLACEHOLDER]) + self.assertFalse(vertex[VProps.VITRAGE_IS_DELETED]) + self.assertFalse(vertex[VProps.VITRAGE_IS_PLACEHOLDER]) def _validate_host_neighbor(self, neighbor, event): @@ -151,13 +152,15 @@ class ZabbixTransformerTest(base.BaseTest): self.assertEqual(NOVA_HOST_DATASOURCE, key_fields[1]) self.assertEqual(event[ZabbixProps.RESOURCE_NAME], key_fields[2]) - self.assertFalse(host_vertex[VProps.IS_DELETED]) - self.assertTrue(host_vertex[VProps.IS_PLACEHOLDER]) + self.assertFalse(host_vertex[VProps.VITRAGE_IS_DELETED]) + self.assertTrue(host_vertex[VProps.VITRAGE_IS_PLACEHOLDER]) - self.assertEqual(EntityCategory.RESOURCE, host_vertex[VProps.CATEGORY]) + 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.TYPE]) + self.assertEqual(NOVA_HOST_DATASOURCE, + host_vertex[VProps.VITRAGE_TYPE]) edge = neighbor.edge self.assertEqual(EdgeLabel.ON, edge.label) diff --git a/vitrage/tests/unit/entity_graph/base.py b/vitrage/tests/unit/entity_graph/base.py index 79d80cbf2..758b90f6e 100644 --- a/vitrage/tests/unit/entity_graph/base.py +++ b/vitrage/tests/unit/entity_graph/base.py @@ -152,13 +152,13 @@ class TestEntityGraphUnitBase(base.BaseTest): def _create_alarm(vitrage_id, alarm_type, project_id=None, metadata=None): return graph_utils.create_vertex( vitrage_id, + vitrage_category=EntityCategory.ALARM, + vitrage_type=alarm_type, + vitrage_sample_timestamp=None, + vitrage_is_deleted=False, + vitrage_is_placeholder=False, entity_id=vitrage_id, - entity_category=EntityCategory.ALARM, - entity_type=alarm_type, entity_state='active', - is_deleted=False, - sample_timestamp=None, - is_placeholder=False, project_id=project_id, metadata=metadata ) @@ -167,13 +167,13 @@ class TestEntityGraphUnitBase(base.BaseTest): def _create_resource(vitrage_id, resource_type, project_id=None): return graph_utils.create_vertex( vitrage_id, + vitrage_category=EntityCategory.RESOURCE, + vitrage_type=resource_type, + vitrage_sample_timestamp=None, + vitrage_is_deleted=False, + vitrage_is_placeholder=False, entity_id=vitrage_id, - entity_category=EntityCategory.RESOURCE, - entity_type=resource_type, entity_state='active', - is_deleted=False, - sample_timestamp=None, - is_placeholder=False, project_id=project_id ) diff --git a/vitrage/tests/unit/entity_graph/processor/base.py b/vitrage/tests/unit/entity_graph/processor/base.py index a203d608e..8b608b929 100644 --- a/vitrage/tests/unit/entity_graph/processor/base.py +++ b/vitrage/tests/unit/entity_graph/processor/base.py @@ -14,7 +14,7 @@ from oslo_config import cfg -from vitrage.common.constants import VertexProperties +from vitrage.common.constants import VertexProperties as VProps from vitrage.entity_graph import transformer_manager from vitrage.graph import driver as graph from vitrage.tests.unit.entity_graph.base import TestEntityGraphUnitBase @@ -32,20 +32,24 @@ class TestBaseProcessor(TestEntityGraphUnitBase): cls.transform = transformer_manager.TransformerManager(cls.conf) @staticmethod - def _update_vertex_to_graph(entity_graph, category, type_, id_, - is_deleted, is_placeholder_data, + def _update_vertex_to_graph(entity_graph, + vitrage_category, + vitrage_type, + id_, + vitrage_is_deleted, + vitrage_is_placeholder, additional_prop): # create vertex properties prop = {key: value for key, value in additional_prop.items()} - prop[VertexProperties.CATEGORY] = category - prop[VertexProperties.TYPE] = type_ - prop[VertexProperties.ID] = id_ - prop[VertexProperties.IS_DELETED] = is_deleted - prop[VertexProperties.IS_PLACEHOLDER] = is_placeholder_data + prop[VProps.VITRAGE_CATEGORY] = vitrage_category + prop[VProps.VITRAGE_TYPE] = vitrage_type + prop[VProps.ID] = id_ + prop[VProps.VITRAGE_IS_DELETED] = vitrage_is_deleted + prop[VProps.VITRAGE_IS_PLACEHOLDER] = vitrage_is_placeholder # TODO(Alexey): change back to original method # vertex_id = self.transform.get_key(prop) - vertex_id = category + "_" + type_ + "_" + id_ + vertex_id = vitrage_category + "_" + vitrage_type + "_" + id_ vertex = graph.Vertex(vertex_id, prop) entity_graph.add_vertex(vertex) diff --git a/vitrage/tests/unit/entity_graph/processor/test_processor.py b/vitrage/tests/unit/entity_graph/processor/test_processor.py index c24133ac6..1d3c70f25 100644 --- a/vitrage/tests/unit/entity_graph/processor/test_processor.py +++ b/vitrage/tests/unit/entity_graph/processor/test_processor.py @@ -92,7 +92,7 @@ class TestProcessor(TestEntityGraphUnitBase): # update instance event with state running vertex.properties[VProps.STATE] = 'RUNNING' - vertex.properties[VProps.SAMPLE_TIMESTAMP] = str(utcnow()) + vertex.properties[VProps.VITRAGE_SAMPLE_TIMESTAMP] = str(utcnow()) processor.update_entity(vertex, neighbors) # check state @@ -148,9 +148,9 @@ class TestProcessor(TestEntityGraphUnitBase): 'backup') mock_neighbor = graph_utils.create_vertex( "asdjashdkahsdashdalksjhd", + vitrage_category="RESOURCE", + vitrage_type="nova.instance", entity_id="wtw64768476", - entity_category="RESOURCE", - entity_type="nova.instance", entity_state="AVAILABLE", ) new_neighbors = [Neighbor(mock_neighbor, new_edge)] @@ -187,7 +187,7 @@ class TestProcessor(TestEntityGraphUnitBase): vertex2.vertex_id, 'backup') self.assertEqual(3, processor.entity_graph.num_edges()) - self.assertEqual(True, edge_from_graph[EProps.IS_DELETED]) + self.assertEqual(True, edge_from_graph[EProps.VITRAGE_IS_DELETED]) def test_remove_deleted_entity(self): # setup @@ -195,7 +195,7 @@ class TestProcessor(TestEntityGraphUnitBase): spec_type=self.INSTANCE_SPEC, datasource_action=DSAction.INIT_SNAPSHOT) self.assertEqual(1, processor.entity_graph.num_edges()) - vertex[VProps.IS_DELETED] = True + vertex[VProps.VITRAGE_IS_DELETED] = True processor.entity_graph.update_vertex(vertex) # action @@ -235,9 +235,9 @@ class TestProcessor(TestEntityGraphUnitBase): # update instance event with state running (neighbor_vertex, neighbor_edge) = neighbors[0] old_label = neighbor_edge.label - neighbor_vertex[VProps.IS_PLACEHOLDER] = False + neighbor_vertex[VProps.VITRAGE_IS_PLACEHOLDER] = False processor.entity_graph.update_vertex(neighbor_vertex) - neighbor_vertex[VProps.IS_PLACEHOLDER] = True + neighbor_vertex[VProps.VITRAGE_IS_PLACEHOLDER] = True neighbor_edge.label = 'new label' processor._update_neighbors(vertex, neighbors) @@ -254,9 +254,9 @@ class TestProcessor(TestEntityGraphUnitBase): vertex.vertex_id, neighbor_edge.label) self.assertIsNotNone(old_edge) - self.assertEqual(old_edge[EProps.IS_DELETED], True) + self.assertEqual(old_edge[EProps.VITRAGE_IS_DELETED], True) self.assertIsNotNone(new_edge) - self.assertEqual(new_edge[EProps.IS_DELETED], False) + self.assertEqual(new_edge[EProps.VITRAGE_IS_DELETED], False) # update instance with the same neighbor processor._update_neighbors(vertex, neighbors) @@ -291,7 +291,7 @@ class TestProcessor(TestEntityGraphUnitBase): neighbor_edge.label) self.assertIsNone(old_edge) self.assertIsNotNone(new_edge) - self.assertEqual(new_edge[EProps.IS_DELETED], False) + self.assertEqual(new_edge[EProps.VITRAGE_IS_DELETED], False) # update instance with the same neighbor processor._update_neighbors(vertex, neighbors) @@ -314,7 +314,7 @@ class TestProcessor(TestEntityGraphUnitBase): self.NUM_VERTICES_AFTER_DELETION, self.NUM_EDGES_AFTER_DELETION) - def test_calculate_aggregated_state(self): + def test_calculate_vitrage_aggregated_state(self): # setup instances = [] for i in range(6): @@ -324,67 +324,67 @@ class TestProcessor(TestEntityGraphUnitBase): # action # state already exists and its updated instances[0][0][VProps.STATE] = 'SUSPENDED' - instances[0][1]._calculate_aggregated_state(instances[0][0], - GraphAction.UPDATE_ENTITY) + instances[0][1]._calculate_vitrage_aggregated_state( + instances[0][0], GraphAction.UPDATE_ENTITY) # vitrage state doesn't exist and its updated instances[1][0][VProps.STATE] = None instances[1][1].entity_graph.update_vertex(instances[1][0]) instances[1][0][VProps.VITRAGE_STATE] = 'SUBOPTIMAL' - instances[1][1]._calculate_aggregated_state(instances[1][0], - GraphAction.UPDATE_ENTITY) + instances[1][1]._calculate_vitrage_aggregated_state( + instances[1][0], GraphAction.UPDATE_ENTITY) # state exists and vitrage state changes instances[2][0][VProps.VITRAGE_STATE] = 'SUBOPTIMAL' - instances[2][1]._calculate_aggregated_state(instances[2][0], - GraphAction.UPDATE_ENTITY) + instances[2][1]._calculate_vitrage_aggregated_state( + instances[2][0], GraphAction.UPDATE_ENTITY) # vitrage state exists and state changes instances[3][0][VProps.STATE] = None instances[3][0][VProps.VITRAGE_STATE] = 'SUBOPTIMAL' instances[3][1].entity_graph.update_vertex(instances[3][0]) instances[3][0][VProps.STATE] = 'SUSPENDED' - instances[3][1]._calculate_aggregated_state(instances[3][0], - GraphAction.UPDATE_ENTITY) + instances[3][1]._calculate_vitrage_aggregated_state( + instances[3][0], GraphAction.UPDATE_ENTITY) # state and vitrage state exists and state changes instances[4][0][VProps.VITRAGE_STATE] = 'SUBOPTIMAL' instances[4][1].entity_graph.update_vertex(instances[4][0]) instances[4][0][VProps.STATE] = 'SUSPENDED' - instances[4][1]._calculate_aggregated_state(instances[4][0], - GraphAction.UPDATE_ENTITY) + instances[4][1]._calculate_vitrage_aggregated_state( + instances[4][0], GraphAction.UPDATE_ENTITY) # state and vitrage state exists and vitrage state changes instances[5][0][VProps.VITRAGE_STATE] = 'SUBOPTIMAL' instances[5][1].entity_graph.update_vertex(instances[5][0]) - instances[5][1]._calculate_aggregated_state(instances[5][0], - GraphAction.UPDATE_ENTITY) + instances[5][1]._calculate_vitrage_aggregated_state( + instances[5][0], GraphAction.UPDATE_ENTITY) # test assertions self.assertEqual('SUSPENDED', - instances[0][0][VProps.AGGREGATED_STATE]) + instances[0][0][VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, - instances[0][0][VProps.OPERATIONAL_STATE]) + instances[0][0][VProps.VITRAGE_OPERATIONAL_STATE]) self.assertEqual('SUBOPTIMAL', - instances[1][0][VProps.AGGREGATED_STATE]) + instances[1][0][VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, - instances[1][0][VProps.OPERATIONAL_STATE]) + instances[1][0][VProps.VITRAGE_OPERATIONAL_STATE]) self.assertEqual('SUBOPTIMAL', - instances[2][0][VProps.AGGREGATED_STATE]) + instances[2][0][VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, - instances[2][0][VProps.OPERATIONAL_STATE]) + instances[2][0][VProps.VITRAGE_OPERATIONAL_STATE]) self.assertEqual('SUSPENDED', - instances[3][0][VProps.AGGREGATED_STATE]) + instances[3][0][VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, - instances[3][0][VProps.OPERATIONAL_STATE]) + instances[3][0][VProps.VITRAGE_OPERATIONAL_STATE]) self.assertEqual('SUSPENDED', - instances[4][0][VProps.AGGREGATED_STATE]) + instances[4][0][VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, - instances[4][0][VProps.OPERATIONAL_STATE]) + instances[4][0][VProps.VITRAGE_OPERATIONAL_STATE]) self.assertEqual('SUBOPTIMAL', - instances[5][0][VProps.AGGREGATED_STATE]) + instances[5][0][VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, - instances[5][0][VProps.OPERATIONAL_STATE]) + instances[5][0][VProps.VITRAGE_OPERATIONAL_STATE]) def _create_and_check_entity(self, processor=None, **kwargs): # create instance event with host neighbor @@ -413,6 +413,6 @@ class TestProcessor(TestEntityGraphUnitBase): else: deleted_edges = processor.entity_graph.get_edges( vertex_id, - attr_filter={VProps.IS_DELETED: True}) + attr_filter={VProps.VITRAGE_IS_DELETED: True}) self.assertEqual(num_edges + len(deleted_edges), processor.entity_graph.num_edges()) diff --git a/vitrage/tests/unit/entity_graph/states/test_datasource_info_mapper.py b/vitrage/tests/unit/entity_graph/states/test_datasource_info_mapper.py index fccdae6a1..d1aee0b8a 100644 --- a/vitrage/tests/unit/entity_graph/states/test_datasource_info_mapper.py +++ b/vitrage/tests/unit/entity_graph/states/test_datasource_info_mapper.py @@ -99,55 +99,57 @@ class TestDatasourceInfoMapper(base.BaseTest): missing_states + erroneous_values self.assertEqual(num_valid_datasources, len(conf.datasources.types)) - def test_operational_state_exists(self): + def test_vitrage_operational_state_exists(self): # setup state_manager = DatasourceInfoMapper(self.conf) # action - operational_state = \ - state_manager.operational_state(NOVA_INSTANCE_DATASOURCE, - 'BUILDING') + vitrage_operational_state = \ + state_manager.vitrage_operational_state(NOVA_INSTANCE_DATASOURCE, + 'BUILDING') # test assertions - self.assertEqual(OperationalResourceState.TRANSIENT, operational_state) + self.assertEqual(OperationalResourceState.TRANSIENT, + vitrage_operational_state) - def test_operational_state_not_exists(self): + def test_vitrage_operational_state_not_exists(self): # setup state_manager = DatasourceInfoMapper(self.conf) # action - operational_state = \ - state_manager.operational_state(NOVA_INSTANCE_DATASOURCE, - 'NON EXISTING STATE') + vitrage_operational_state = \ + state_manager.vitrage_operational_state(NOVA_INSTANCE_DATASOURCE, + 'NON EXISTING STATE') # test assertions - self.assertEqual(OperationalResourceState.NA, operational_state) + self.assertEqual(OperationalResourceState.NA, + vitrage_operational_state) - def test_operational_state_datasource_not_exists_and_state_not_exist(self): + def test_vitrage_operational_state_DS_not_exists_and_state_not_exist(self): # setup state_manager = DatasourceInfoMapper(self.conf) # action - operational_state = \ - state_manager.operational_state('NON EXISTING DATASOURCE', - 'BUILDING') + vitrage_operational_state = \ + state_manager.vitrage_operational_state('NON EXISTING DATASOURCE', + 'BUILDING') # test assertions self.assertEqual(OperationalResourceState.NA, - operational_state) + vitrage_operational_state) - def test_operational_state_datasource_not_exists_and_state_exist(self): + def test_vitrage_operational_state_DS_not_exists_and_state_exist(self): # setup state_manager = DatasourceInfoMapper(self.conf) # action - operational_state = \ - state_manager.operational_state('NON EXISTING DATASOURCE', - 'AVAILABLE') + vitrage_operational_state = \ + state_manager.vitrage_operational_state('NON EXISTING DATASOURCE', + 'AVAILABLE') # test assertions self.assertEqual(OperationalResourceState.OK, - operational_state) + vitrage_operational_state) def test_state_priority(self): # setup @@ -186,110 +188,115 @@ class TestDatasourceInfoMapper(base.BaseTest): self.assertEqual(10, state_priority) - def test_aggregated_state(self): + def test_vitrage_aggregated_state(self): # setup state_manager = DatasourceInfoMapper(self.conf) metadata1 = {VProps.VITRAGE_STATE: 'SUSPENDED'} new_vertex1 = create_vertex('12345', + vitrage_category=EntityCategory.RESOURCE, + vitrage_type=NOVA_INSTANCE_DATASOURCE, entity_state='ACTIVE', - entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_INSTANCE_DATASOURCE, metadata=metadata1) metadata2 = {VProps.VITRAGE_STATE: 'ACTIVE'} new_vertex2 = create_vertex('23456', + vitrage_category=EntityCategory.RESOURCE, + vitrage_type=NOVA_INSTANCE_DATASOURCE, entity_state='SUSPENDED', - entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_INSTANCE_DATASOURCE, metadata=metadata2) # action - state_manager.aggregated_state(new_vertex1, None) - state_manager.aggregated_state(new_vertex2, None) + state_manager.vitrage_aggregated_state(new_vertex1, None) + state_manager.vitrage_aggregated_state(new_vertex2, None) # test assertions - self.assertEqual('SUSPENDED', new_vertex1[VProps.AGGREGATED_STATE]) + self.assertEqual('SUSPENDED', + new_vertex1[VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, - new_vertex1[VProps.OPERATIONAL_STATE]) - self.assertEqual('SUSPENDED', new_vertex2[VProps.AGGREGATED_STATE]) + new_vertex1[VProps.VITRAGE_OPERATIONAL_STATE]) + self.assertEqual('SUSPENDED', + new_vertex2[VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, - new_vertex2[VProps.OPERATIONAL_STATE]) + new_vertex2[VProps.VITRAGE_OPERATIONAL_STATE]) - def test_aggregated_state_functionalities(self): + def test_vitrage_aggregated_state_functionalities(self): # setup state_manager = DatasourceInfoMapper(self.conf) new_vertex1 = create_vertex('12345', - entity_state='ACTIVE', - entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_INSTANCE_DATASOURCE) + vitrage_category=EntityCategory.RESOURCE, + vitrage_type=NOVA_INSTANCE_DATASOURCE, + entity_state='ACTIVE') metadata2 = {VProps.VITRAGE_STATE: 'SUBOPTIMAL'} new_vertex2 = create_vertex('23456', - entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_INSTANCE_DATASOURCE, + vitrage_category=EntityCategory.RESOURCE, + vitrage_type=NOVA_INSTANCE_DATASOURCE, metadata=metadata2) metadata3 = {VProps.VITRAGE_STATE: 'SUBOPTIMAL'} new_vertex3 = create_vertex('34567', - entity_state='ACTIVE', - entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_INSTANCE_DATASOURCE) + vitrage_category=EntityCategory.RESOURCE, + vitrage_type=NOVA_INSTANCE_DATASOURCE, + entity_state='ACTIVE') graph_vertex3 = create_vertex('34567', + vitrage_category=EntityCategory.RESOURCE, + vitrage_type=NOVA_INSTANCE_DATASOURCE, entity_state='SUSPENDED', - entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_INSTANCE_DATASOURCE, metadata=metadata3) # action - state_manager.aggregated_state(new_vertex1, - None) - state_manager.aggregated_state(new_vertex2, - None) - state_manager.aggregated_state(new_vertex3, - graph_vertex3) + state_manager.vitrage_aggregated_state(new_vertex1, + None) + state_manager.vitrage_aggregated_state(new_vertex2, + None) + state_manager.vitrage_aggregated_state(new_vertex3, + graph_vertex3) # test assertions - self.assertEqual('ACTIVE', new_vertex1[VProps.AGGREGATED_STATE]) + self.assertEqual('ACTIVE', + new_vertex1[VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.OK, - new_vertex1[VProps.OPERATIONAL_STATE]) - self.assertEqual('SUBOPTIMAL', new_vertex2[VProps.AGGREGATED_STATE]) + new_vertex1[VProps.VITRAGE_OPERATIONAL_STATE]) + self.assertEqual('SUBOPTIMAL', + new_vertex2[VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, - new_vertex2[VProps.OPERATIONAL_STATE]) - self.assertEqual('SUBOPTIMAL', new_vertex3[VProps.AGGREGATED_STATE]) + new_vertex2[VProps.VITRAGE_OPERATIONAL_STATE]) + self.assertEqual('SUBOPTIMAL', + new_vertex3[VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, - new_vertex3[VProps.OPERATIONAL_STATE]) + new_vertex3[VProps.VITRAGE_OPERATIONAL_STATE]) - def test_aggregated_state_datasource_not_exists(self): + def test_vitrage_aggregated_state_datasource_not_exists(self): # setup state_manager = DatasourceInfoMapper(self.conf) metadata = {VProps.VITRAGE_STATE: 'SUSPENDED'} new_vertex = create_vertex('12345', + vitrage_category=EntityCategory.RESOURCE, + vitrage_type='NON EXISTING DATASOURCE', entity_state='ACTIVE', - entity_category=EntityCategory.RESOURCE, - entity_type='NON EXISTING DATASOURCE', metadata=metadata) # action - state_manager.aggregated_state(new_vertex, None) + state_manager.vitrage_aggregated_state(new_vertex, None) # test assertions self.assertEqual('ACTIVE', - new_vertex[VProps.AGGREGATED_STATE]) + new_vertex[VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.OK, - new_vertex[VProps.OPERATIONAL_STATE]) + new_vertex[VProps.VITRAGE_OPERATIONAL_STATE]) - def test_aggregated_state_datasource_not_exists_and_wrong_state(self): + def test_vitrage_aggregated_state_DS_not_exists_and_wrong_state(self): # setup state_manager = DatasourceInfoMapper(self.conf) metadata = {VProps.VITRAGE_STATE: 'SUSPENDED'} new_vertex = create_vertex('12345', + vitrage_category=EntityCategory.RESOURCE, + vitrage_type='NON EXISTING DATASOURCE', entity_state='NON EXISTING STATE', - entity_category=EntityCategory.RESOURCE, - entity_type='NON EXISTING DATASOURCE', metadata=metadata) # action - state_manager.aggregated_state(new_vertex, None) + state_manager.vitrage_aggregated_state(new_vertex, None) # test assertions self.assertEqual('NON EXISTING STATE', - new_vertex[VProps.AGGREGATED_STATE]) + new_vertex[VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.NA, - new_vertex[VProps.OPERATIONAL_STATE]) + new_vertex[VProps.VITRAGE_OPERATIONAL_STATE]) diff --git a/vitrage/tests/unit/evaluator/recipes/test_raise_alarm.py b/vitrage/tests/unit/evaluator/recipes/test_raise_alarm.py index 728fdaf34..92386296e 100644 --- a/vitrage/tests/unit/evaluator/recipes/test_raise_alarm.py +++ b/vitrage/tests/unit/evaluator/recipes/test_raise_alarm.py @@ -31,7 +31,7 @@ class RaiseAlarmRecipeTest(base.BaseTest): @classmethod def setUpClass(cls): - cls.target_props = {VProps.TYPE: NOVA_HOST_DATASOURCE} + cls.target_props = {VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE} cls.target_vertex = Vertex('RESOURCE:nova.host:test1', cls.target_props) cls.targets = {TFields.TARGET: cls.target_vertex} @@ -66,7 +66,7 @@ class RaiseAlarmRecipeTest(base.BaseTest): alarm_vitrage_resource_type = \ add_vertex_step_params[VProps.VITRAGE_RESOURCE_TYPE] - self.assertEqual(self.target_vertex.properties[VProps.TYPE], + self.assertEqual(self.target_vertex.properties[VProps.VITRAGE_TYPE], alarm_vitrage_resource_type) def test_get_undo_recipe(self): @@ -97,5 +97,5 @@ class RaiseAlarmRecipeTest(base.BaseTest): alarm_vitrage_resource_type = \ remove_vertex_step_params[VProps.VITRAGE_RESOURCE_TYPE] - self.assertEqual(self.target_vertex.properties[VProps.TYPE], + self.assertEqual(self.target_vertex.properties[VProps.VITRAGE_TYPE], alarm_vitrage_resource_type) diff --git a/vitrage/tests/unit/evaluator/test_equivalence_data.py b/vitrage/tests/unit/evaluator/test_equivalence_data.py index dad012208..168a5e037 100644 --- a/vitrage/tests/unit/evaluator/test_equivalence_data.py +++ b/vitrage/tests/unit/evaluator/test_equivalence_data.py @@ -12,6 +12,12 @@ # License for the specific language governing permissions and limitations # under the License. +from vitrage.common.constants import EntityCategory +from vitrage.common.constants import VertexProperties as VProps +from vitrage.datasources.nagios import NAGIOS_DATASOURCE +from vitrage.datasources.zabbix import ZABBIX_DATASOURCE +from vitrage.evaluator.actions.evaluator_event_transformer \ + import VITRAGE_DATASOURCE from vitrage.evaluator.equivalence_data import EquivalenceData from vitrage.tests import base from vitrage.tests.mocks import utils @@ -34,15 +40,15 @@ class EquivalenceTemplateTest(base.BaseTest): expected = [ frozenset([ - frozenset([('category', 'ALARM'), - ('type', 'nagios'), - ('name', 'host_problem')]), - frozenset([('category', 'ALARM'), - ('type', 'zabbix'), - ('name', 'host_fail')]), - frozenset([('category', 'ALARM'), - ('type', 'vitrage'), - ('name', 'host_down')]) + frozenset([(VProps.VITRAGE_CATEGORY, EntityCategory.ALARM), + (VProps.VITRAGE_TYPE, NAGIOS_DATASOURCE), + (VProps.NAME, 'host_problem')]), + frozenset([(VProps.VITRAGE_CATEGORY, EntityCategory.ALARM), + (VProps.VITRAGE_TYPE, ZABBIX_DATASOURCE), + (VProps.NAME, 'host_fail')]), + frozenset([(VProps.VITRAGE_CATEGORY, EntityCategory.ALARM), + (VProps.VITRAGE_TYPE, VITRAGE_DATASOURCE), + (VProps.NAME, 'host_down')]) ]), ] diff --git a/vitrage/tests/unit/evaluator/test_scenario_repository.py b/vitrage/tests/unit/evaluator/test_scenario_repository.py index 65467869f..ccc9d17c6 100644 --- a/vitrage/tests/unit/evaluator/test_scenario_repository.py +++ b/vitrage/tests/unit/evaluator/test_scenario_repository.py @@ -11,10 +11,13 @@ # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. + import os from oslo_config import cfg +from vitrage.common.constants import EntityCategory +from vitrage.common.constants import VertexProperties as VProps from vitrage.evaluator.scenario_repository import ScenarioRepository from vitrage.evaluator.template_validation.template_syntax_validator import \ syntax_validation @@ -117,11 +120,11 @@ class EquivalentScenarioTest(base.BaseTest): def test_expansion(self): entity_scenarios = self.scenario_repository.entity_scenarios - for entity_key, scenarios in entity_scenarios.items(): - if ('category', 'ALARM') in entity_key: + for key, scenarios in entity_scenarios.items(): + if (VProps.VITRAGE_CATEGORY, EntityCategory.ALARM) in key: # scenarios expanded on the other alarm self.assertEqual(len(scenarios), 2) - if ('category', 'RESOURCE') in entity_key: + if (VProps.VITRAGE_CATEGORY, EntityCategory.RESOURCE) in key: # Scenarios expanded on the two alarms. Each alarm is expanded # to two equivalent alarms. Thus 2 x 2 = 4 in total self.assertEqual(len(scenarios), 4) diff --git a/vitrage/tests/unit/evaluator/test_template_data.py b/vitrage/tests/unit/evaluator/test_template_data.py index 2852cda13..edef01ba8 100644 --- a/vitrage/tests/unit/evaluator/test_template_data.py +++ b/vitrage/tests/unit/evaluator/test_template_data.py @@ -12,6 +12,10 @@ # License for the specific language governing permissions and limitations # under the License. +from vitrage.common.constants import EntityCategory +from vitrage.common.constants import VertexProperties as VProps +from vitrage.datasources.nagios import NAGIOS_DATASOURCE +from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE from vitrage.evaluator.template_data import ActionSpecs from vitrage.evaluator.template_data import ConditionVar from vitrage.evaluator.template_data import EdgeDescription @@ -43,23 +47,30 @@ class BasicTemplateTest(base.BaseTest): definitions = template_definition[TFields.DEFINITIONS] # Assertions - entities_definition = definitions[TFields.ENTITIES] - self._validate_entities(entities, entities_definition) + for definition in definitions[TFields.ENTITIES]: + for key, value in definition['entity'].items(): + new_key = TemplateData.PROPS_CONVERSION[key] if key in \ + TemplateData.PROPS_CONVERSION else key + del definition['entity'][key] + definition['entity'][new_key] = value + self._validate_entities(entities, definitions[TFields.ENTITIES]) relate_def = definitions[TFields.RELATIONSHIPS] self._validate_relationships(relationships, relate_def, entities) self._validate_scenarios(scenarios, entities) expected_entities = { - 'alarm': Vertex(vertex_id='alarm', - properties={'category': 'ALARM', - 'type': 'nagios', - 'name': 'host_problem' - }), - 'resource': Vertex(vertex_id='resource', - properties={'category': 'RESOURCE', - 'type': 'nova.host' - }) + 'alarm': Vertex( + vertex_id='alarm', + properties={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE, + VProps.NAME: 'host_problem' + }), + 'resource': Vertex( + vertex_id='resource', + properties={VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE + }) } expected_relationships = { @@ -120,7 +131,7 @@ class BasicTemplateTest(base.BaseTest): self.assertIsInstance(entity, Vertex) self.assertEqual(entity_id, entity.vertex_id) self.assertIsNotNone(entity.properties) - self.assertIn(TFields.CATEGORY, entity.properties) + self.assertIn(VProps.VITRAGE_CATEGORY, entity.properties) self.assertEqual(len(entities), len(entities_def)) diff --git a/vitrage/tests/unit/evaluator/test_template_syntax_validator.py b/vitrage/tests/unit/evaluator/test_template_syntax_validator.py index a0b5af2c3..c9199728f 100644 --- a/vitrage/tests/unit/evaluator/test_template_syntax_validator.py +++ b/vitrage/tests/unit/evaluator/test_template_syntax_validator.py @@ -126,7 +126,7 @@ class TemplateSyntaxValidatorTest(base.BaseTest): entity[TemplateFields.ENTITY][TemplateFields.TEMPLATE_ID] = '_a123' self._test_execution_with_correct_result(template) - def test_validate_entity_with_invalid_category_value(self): + def test_validate_entity_with_invalid_vitrage_category_value(self): template = self.clone_template definitions = template[TemplateFields.DEFINITIONS] diff --git a/vitrage/tests/unit/graph/base.py b/vitrage/tests/unit/graph/base.py index 2f692daff..9046b0bcb 100644 --- a/vitrage/tests/unit/graph/base.py +++ b/vitrage/tests/unit/graph/base.py @@ -59,31 +59,31 @@ cluster_vitrage_id = EntityCategory.RESOURCE + ':' + \ CLUSTER_ID v_node = graph_utils.create_vertex( vitrage_id=cluster_vitrage_id, - entity_id='111111111111', - entity_type=OPENSTACK_CLUSTER, - entity_category=RESOURCE) + vitrage_category=RESOURCE, + vitrage_type=OPENSTACK_CLUSTER, + entity_id='111111111111') v_host = graph_utils.create_vertex( vitrage_id=NOVA_HOST_DATASOURCE + '222222222222', - entity_id='222222222222', - entity_type=NOVA_HOST_DATASOURCE, - entity_category=RESOURCE) + vitrage_category=RESOURCE, + vitrage_type=NOVA_HOST_DATASOURCE, + entity_id='222222222222') v_instance = graph_utils.create_vertex( vitrage_id=NOVA_INSTANCE_DATASOURCE + '333333333333', - entity_id='333333333333', - entity_type=NOVA_INSTANCE_DATASOURCE, - entity_category=RESOURCE) + vitrage_category=RESOURCE, + vitrage_type=NOVA_INSTANCE_DATASOURCE, + entity_id='333333333333') v_alarm = graph_utils.create_vertex( vitrage_id=ALARM + '444444444444', + vitrage_category=ALARM, + vitrage_type=ALARM_ON_VM, entity_id='444444444444', - entity_type=ALARM_ON_VM, - entity_category=ALARM, metadata={VProps.RESOURCE_ID: '333333333333', VProps.NAME: 'anotheralarm'}) v_switch = graph_utils.create_vertex( vitrage_id=SWITCH + '1212121212', - entity_id='1212121212', - entity_type=SWITCH, - entity_category=RESOURCE) + vitrage_category=RESOURCE, + vitrage_type=SWITCH, + entity_id='1212121212') e_node_to_host = graph_utils.create_edge( source_id=v_node.vertex_id, @@ -102,9 +102,9 @@ def add_connected_vertex(graph, entity_type, entity_subtype, entity_id, metadata=None): vertex = graph_utils.create_vertex( vitrage_id=entity_subtype + str(entity_id), + vitrage_category=entity_type, + vitrage_type=entity_subtype, entity_id=entity_id, - entity_category=entity_type, - entity_type=entity_subtype, metadata=metadata) edge = graph_utils.create_edge( source_id=other_vertex.vertex_id if reverse else vertex.vertex_id, diff --git a/vitrage/tests/unit/graph/test_graph.py b/vitrage/tests/unit/graph/test_graph.py index 8bbed9731..91ac0751a 100644 --- a/vitrage/tests/unit/graph/test_graph.py +++ b/vitrage/tests/unit/graph/test_graph.py @@ -49,13 +49,14 @@ class TestGraph(GraphTestBase): self.assertEqual(2, len(graph_copy), 'graph copy __len__') updated_vertex = g.get_vertex(v_host.vertex_id) - updated_vertex[VProps.CATEGORY] = ALARM + updated_vertex[VProps.VITRAGE_CATEGORY] = ALARM g.update_vertex(updated_vertex) v_from_g = g.get_vertex(v_host.vertex_id) v_from_graph_copy = graph_copy.get_vertex(v_host.vertex_id) - self.assertEqual(ALARM, v_from_g[VProps.CATEGORY], + self.assertEqual(ALARM, v_from_g[VProps.VITRAGE_CATEGORY], 'graph vertex changed after update') - self.assertEqual(NOVA_HOST_DATASOURCE, v_from_graph_copy[VProps.TYPE], + self.assertEqual(NOVA_HOST_DATASOURCE, + v_from_graph_copy[VProps.VITRAGE_TYPE], 'graph copy vertex unchanged after update') def test_vertex_crud(self): @@ -64,7 +65,8 @@ class TestGraph(GraphTestBase): v = g.get_vertex(v_node.vertex_id) self.assertEqual(v_node[VProps.ID], v[VProps.ID], 'vertex properties are saved') - self.assertEqual(v_node[VProps.CATEGORY], v[VProps.CATEGORY], + self.assertEqual(v_node[VProps.VITRAGE_CATEGORY], + v[VProps.VITRAGE_CATEGORY], 'vertex properties are saved') self.assertEqual(v_node.vertex_id, v.vertex_id, 'vertex vertex_id is saved') @@ -72,14 +74,15 @@ class TestGraph(GraphTestBase): # Changing the referenced item updated_v = v updated_v['KUKU'] = 'KUKU' - updated_v[VProps.CATEGORY] = 'CHANGED' + updated_v[VProps.VITRAGE_CATEGORY] = 'CHANGED' # Get it again v = g.get_vertex(v_node.vertex_id) self.assertIsNone(v.get('KUKU', None), 'Change should not affect graph item') - self.assertFalse(v.get(EProps.IS_DELETED, None), + self.assertFalse(v.get(EProps.VITRAGE_IS_DELETED, None), 'Change should not affect graph item') - self.assertEqual(v_node[VProps.CATEGORY], v[VProps.CATEGORY], + self.assertEqual(v_node[VProps.VITRAGE_CATEGORY], + v[VProps.VITRAGE_CATEGORY], 'Change should not affect graph item') # Update the graph item and see changes take place g.update_vertex(updated_v) @@ -87,7 +90,8 @@ class TestGraph(GraphTestBase): v = g.get_vertex(v_node.vertex_id) self.assertEqual(updated_v['KUKU'], v['KUKU'], 'Graph item should change after update') - self.assertEqual(updated_v[VProps.CATEGORY], v[VProps.CATEGORY], + self.assertEqual(updated_v[VProps.VITRAGE_CATEGORY], + v[VProps.VITRAGE_CATEGORY], 'Graph item should change after update') # Update the graph item and see changes take place @@ -101,17 +105,18 @@ class TestGraph(GraphTestBase): # check metadata another_vertex = utils.create_vertex( vitrage_id='123', + vitrage_category=NOVA_INSTANCE_DATASOURCE, entity_id='456', - entity_category=NOVA_INSTANCE_DATASOURCE, metadata={'some_meta': 'DATA', - 'type': 'nova.instance', - 'resource_id': 'sdg7849ythksjdg'} + VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE, + VProps.RESOURCE_ID: 'sdg7849ythksjdg'} ) g.add_vertex(another_vertex) v = g.get_vertex(another_vertex.vertex_id) self.assertEqual(another_vertex[VProps.ID], v[VProps.ID], 'vertex properties are saved') - self.assertEqual(another_vertex[VProps.CATEGORY], v[VProps.CATEGORY], + self.assertEqual(another_vertex[VProps.VITRAGE_CATEGORY], + v[VProps.VITRAGE_CATEGORY], 'vertex properties are saved') self.assertEqual('DATA', v['some_meta'], 'vertex properties are saved') @@ -131,7 +136,7 @@ class TestGraph(GraphTestBase): g.add_vertex(v_node) v_node_copy = g.get_vertex(v_node.vertex_id) v_node_copy[VProps.NAME] = 'test_node' - v_node_copy[VProps.CATEGORY] = 'super_node' + v_node_copy[VProps.VITRAGE_CATEGORY] = 'super_node' g.add_vertex(v_host) v_host_copy = g.get_vertex(v_host.vertex_id) @@ -143,7 +148,7 @@ class TestGraph(GraphTestBase): # Test Assertions updated_v_node = g.get_vertex(v_node.vertex_id) self.assertEqual('test_node', updated_v_node[VProps.NAME]) - self.assertEqual('super_node', updated_v_node[VProps.CATEGORY]) + self.assertEqual('super_node', updated_v_node[VProps.VITRAGE_CATEGORY]) updated_v_host = g.get_vertex(v_host.vertex_id) self.assertEqual('test_host', updated_v_host[VProps.NAME]) @@ -184,12 +189,12 @@ class TestGraph(GraphTestBase): # Changing the referenced item updated_e = e - updated_e[EProps.IS_DELETED] = 'KUKU' + updated_e[EProps.VITRAGE_IS_DELETED] = 'KUKU' updated_e[EProps.UPDATE_TIMESTAMP] = 'CHANGED' # Get it again e = g.get_edge(v_node.vertex_id, v_host.vertex_id, label) - self.assertFalse(e.get(EProps.IS_DELETED, None), + self.assertFalse(e.get(EProps.VITRAGE_IS_DELETED, None), 'Change should not affect graph item') self.assertEqual(e_node_to_host[EProps.UPDATE_TIMESTAMP], e[EProps.UPDATE_TIMESTAMP], @@ -198,19 +203,19 @@ class TestGraph(GraphTestBase): g.update_edge(updated_e) # Get it again e = g.get_edge(v_node.vertex_id, v_host.vertex_id, label) - self.assertEqual(updated_e[EProps.IS_DELETED], - e[EProps.IS_DELETED], + self.assertEqual(updated_e[EProps.VITRAGE_IS_DELETED], + e[EProps.VITRAGE_IS_DELETED], 'Graph item should change after update') self.assertEqual(updated_e[EProps.UPDATE_TIMESTAMP], e[EProps.UPDATE_TIMESTAMP], 'Graph item should change after update') # Update the graph item and see changes take place - updated_e[EProps.IS_DELETED] = None + updated_e[EProps.VITRAGE_IS_DELETED] = None g.update_edge(updated_e) # Get it again e = g.get_edge(v_node.vertex_id, v_host.vertex_id, label) - self.assertNotIn(EProps.IS_DELETED, e.properties, + self.assertNotIn(EProps.VITRAGE_IS_DELETED, e.properties, 'Update value to None should entirely remove the key') # check metadata @@ -256,8 +261,8 @@ class TestGraph(GraphTestBase): v4 = v_alarm v5 = utils.create_vertex( vitrage_id='kuku', - entity_type=NOVA_HOST_DATASOURCE, - entity_category=EntityCategory.RESOURCE) + vitrage_category=EntityCategory.RESOURCE, + vitrage_type=NOVA_HOST_DATASOURCE) g = NXGraph('test_neighbors') g.add_vertex(v1) @@ -301,7 +306,7 @@ class TestGraph(GraphTestBase): v1_neighbors = g.neighbors( v_id=v1.vertex_id, - vertex_attr_filter={VProps.TYPE: NOVA_HOST_DATASOURCE}) + vertex_attr_filter={VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE}) self._assert_set_equal({v2}, v1_neighbors, 'Check V1 neighbors, vertex property filter') @@ -330,7 +335,7 @@ class TestGraph(GraphTestBase): v_id=v1.vertex_id, direction=Direction.IN, edge_attr_filter={EProps.RELATIONSHIP_TYPE: relationship_c}, - vertex_attr_filter={VProps.TYPE: NOVA_HOST_DATASOURCE}) + vertex_attr_filter={VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE}) self._assert_set_equal( {v2}, v1_neighbors, 'Check V1 neighbors, vertex/edge property filter and direction') @@ -343,14 +348,14 @@ class TestGraph(GraphTestBase): v2_neighbors = g.neighbors( v_id=v2.vertex_id, - vertex_attr_filter={VProps.CATEGORY: NOVA_HOST_DATASOURCE}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: NOVA_HOST_DATASOURCE}) self._assert_set_equal({}, v2_neighbors, 'Check v2 neighbors, vertex property filter') v2_neighbors = g.neighbors( v_id=v2.vertex_id, - vertex_attr_filter={VProps.CATEGORY: [NOVA_HOST_DATASOURCE, - ALARM]}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: [NOVA_HOST_DATASOURCE, + ALARM]}) self._assert_set_equal({v4}, v2_neighbors, 'Check v2 neighbors, vertex property filter') @@ -360,11 +365,11 @@ class TestGraph(GraphTestBase): EProps.RELATIONSHIP_TYPE: [relationship_a, relationship_b] }, vertex_attr_filter={ - VProps.CATEGORY: [RESOURCE, ALARM], - VProps.TYPE: [NOVA_HOST_DATASOURCE, - NOVA_INSTANCE_DATASOURCE, - ALARM_ON_VM, - ALARM_ON_HOST] + VProps.VITRAGE_CATEGORY: [RESOURCE, ALARM], + VProps.VITRAGE_TYPE: [NOVA_HOST_DATASOURCE, + NOVA_INSTANCE_DATASOURCE, + ALARM_ON_VM, + ALARM_ON_HOST] } ) self._assert_set_equal({v3, v4}, v2_neighbors, @@ -378,13 +383,13 @@ class TestGraph(GraphTestBase): v3_neighbors = g.neighbors( v_id=v3.vertex_id, - vertex_attr_filter={VProps.CATEGORY: NOVA_HOST_DATASOURCE}, + vertex_attr_filter={VProps.VITRAGE_CATEGORY: NOVA_HOST_DATASOURCE}, direction=Direction.OUT) self._assert_set_equal({}, v3_neighbors, 'Check neighbors for vertex without any') v5_neighbors = g.neighbors( v_id=v5.vertex_id, - vertex_attr_filter={VProps.CATEGORY: NOVA_HOST_DATASOURCE}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: NOVA_HOST_DATASOURCE}) self._assert_set_equal({}, v5_neighbors, 'Check neighbors for not connected vertex') @@ -399,20 +404,20 @@ class TestGraph(GraphTestBase): 'get_vertices __len__ all vertices') node_vertices = g.get_vertices( - vertex_attr_filter={VProps.TYPE: OPENSTACK_CLUSTER}) + vertex_attr_filter={VProps.VITRAGE_TYPE: OPENSTACK_CLUSTER}) self.assertEqual(1, len(node_vertices), 'get_vertices __len__ node vertices') found_vertex = node_vertices.pop() - self.assertEqual(OPENSTACK_CLUSTER, found_vertex[VProps.TYPE], + self.assertEqual(OPENSTACK_CLUSTER, found_vertex[VProps.VITRAGE_TYPE], 'get_vertices check node vertex') node_vertices = g.get_vertices( - vertex_attr_filter={VProps.TYPE: OPENSTACK_CLUSTER, - VProps.CATEGORY: RESOURCE}) + vertex_attr_filter={VProps.VITRAGE_TYPE: OPENSTACK_CLUSTER, + VProps.VITRAGE_CATEGORY: RESOURCE}) self.assertEqual(1, len(node_vertices), 'get_vertices __len__ node vertices') found_vertex = node_vertices.pop() - self.assertEqual(OPENSTACK_CLUSTER, found_vertex[VProps.TYPE], + self.assertEqual(OPENSTACK_CLUSTER, found_vertex[VProps.VITRAGE_TYPE], 'get_vertices check node vertex') def _check_callback_result(self, result, msg, exp_prev, exp_curr): @@ -472,7 +477,7 @@ class TestGraph(GraphTestBase): e_node_to_host) updated_vertex = g.get_vertex(v_host.vertex_id) - updated_vertex[VProps.CATEGORY] = ALARM + updated_vertex[VProps.VITRAGE_CATEGORY] = ALARM g.update_vertex(updated_vertex) self._check_callback_result(self.result, 'update vertex', v_host, updated_vertex) diff --git a/vitrage/tests/unit/graph/test_graph_algo.py b/vitrage/tests/unit/graph/test_graph_algo.py index 9518a0c24..442114cfa 100644 --- a/vitrage/tests/unit/graph/test_graph_algo.py +++ b/vitrage/tests/unit/graph/test_graph_algo.py @@ -53,7 +53,7 @@ class GraphAlgorithmTest(GraphTestBase): def test_graph_query_vertices(self): ga = self.entity_graph.algo - query = {'==': {VProps.TYPE: OPENSTACK_CLUSTER}} + query = {'==': {VProps.VITRAGE_TYPE: OPENSTACK_CLUSTER}} subgraph = ga.graph_query_vertices(query) self.assertEqual( 1, # For Cluster @@ -61,8 +61,8 @@ class GraphAlgorithmTest(GraphTestBase): query = { 'or': [ - {'==': {VProps.TYPE: NOVA_HOST_DATASOURCE}}, - {'==': {VProps.TYPE: OPENSTACK_CLUSTER}} + {'==': {VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE}}, + {'==': {VProps.VITRAGE_TYPE: OPENSTACK_CLUSTER}} ] } @@ -73,10 +73,10 @@ class GraphAlgorithmTest(GraphTestBase): query = { 'or': [ - {'==': {VProps.TYPE: NOVA_INSTANCE_DATASOURCE}}, - {'==': {VProps.CATEGORY: ALARM}}, - {'==': {VProps.TYPE: NOVA_HOST_DATASOURCE}}, - {'==': {VProps.TYPE: OPENSTACK_CLUSTER}} + {'==': {VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE}}, + {'==': {VProps.VITRAGE_CATEGORY: ALARM}}, + {'==': {VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE}}, + {'==': {VProps.VITRAGE_TYPE: OPENSTACK_CLUSTER}} ] } subgraph = ga.graph_query_vertices(query) @@ -90,7 +90,7 @@ class GraphAlgorithmTest(GraphTestBase): # Get first host ID neighboring_hosts = self.entity_graph.neighbors( - v_node.vertex_id, {VProps.TYPE: NOVA_HOST_DATASOURCE}) + v_node.vertex_id, {VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE}) first_host_id = neighboring_hosts.pop().vertex_id query = {'!=': {'NOTHING': 'IS EVERYTHING'}} @@ -106,8 +106,8 @@ class GraphAlgorithmTest(GraphTestBase): query = { 'or': [ - {'==': {VProps.TYPE: SWITCH}}, - {'==': {VProps.TYPE: NOVA_HOST_DATASOURCE}}, + {'==': {VProps.VITRAGE_TYPE: SWITCH}}, + {'==': {VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE}}, ] } subgraph = ga.graph_query_vertices( @@ -135,9 +135,9 @@ class GraphAlgorithmTest(GraphTestBase): query = { 'and': [ - {'!=': {VProps.TYPE: ALARM_ON_VM}}, - {'!=': {VProps.TYPE: ALARM_ON_HOST}}, - {'!=': {VProps.CATEGORY: ALARM}} + {'!=': {VProps.VITRAGE_TYPE: ALARM_ON_VM}}, + {'!=': {VProps.VITRAGE_TYPE: ALARM_ON_HOST}}, + {'!=': {VProps.VITRAGE_CATEGORY: ALARM}} ] } subgraph = ga.graph_query_vertices(query_dict=query, depth=3) @@ -150,8 +150,8 @@ class GraphAlgorithmTest(GraphTestBase): query = { 'or': [ - {'==': {VProps.TYPE: OPENSTACK_CLUSTER}}, - {'==': {VProps.CATEGORY: ALARM}}, + {'==': {VProps.VITRAGE_TYPE: OPENSTACK_CLUSTER}}, + {'==': {VProps.VITRAGE_CATEGORY: ALARM}}, ] } subgraph = ga.graph_query_vertices(query_dict=query, depth=3) @@ -166,28 +166,30 @@ class GraphAlgorithmTest(GraphTestBase): subgraph = ga.graph_query_vertices( query_dict=query, depth=5, edge_query_dict=edge_query) alarms = subgraph.get_vertices( - vertex_attr_filter={VProps.CATEGORY: ALARM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: ALARM}) self.assertEqual(len(alarms), 0, 'We filtered the ON relationship,' ' so no alarms should exist') - # check that the is_deleted=True edges are deleted from the graph - hosts_query = {VProps.CATEGORY: 'RESOURCE', - VProps.TYPE: NOVA_HOST_DATASOURCE} + # check that the vitrage_is_deleted=True edges are deleted from the + # graph + hosts_query = {VProps.VITRAGE_CATEGORY: RESOURCE, + VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE} hosts = self.entity_graph.get_vertices( vertex_attr_filter=hosts_query) - instances_query = {VProps.CATEGORY: 'RESOURCE', - VProps.TYPE: NOVA_INSTANCE_DATASOURCE} + instances_query = {VProps.VITRAGE_CATEGORY: RESOURCE, + VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE} instances = self.entity_graph.get_vertices( vertex_attr_filter=instances_query) instance_edges = self.entity_graph.get_edges(instances[0].vertex_id) for edge in instance_edges: - if 'nova.host' in edge.source_id: + if NOVA_HOST_DATASOURCE in edge.source_id: host_instance_edge = edge - host_instance_edge[VProps.IS_DELETED] = True + host_instance_edge[VProps.VITRAGE_IS_DELETED] = True self.entity_graph.update_edge(host_instance_edge) - edges_query = {'relationship_type': 'contains', 'is_deleted': False} + edges_query = {EProps.RELATIONSHIP_TYPE: EdgeLabel.CONTAINS, + VProps.VITRAGE_IS_DELETED: False} if host_instance_edge.source_id != hosts[0].vertex_id: new_edge = Edge(hosts[0].vertex_id, instances[0].vertex_id, EdgeLabel.CONTAINS, properties=edges_query) @@ -198,7 +200,7 @@ class GraphAlgorithmTest(GraphTestBase): self.entity_graph.update_edge(new_edge) query = {'!=': {'NOTHING': 'IS EVERYTHING'}} - edge_query = {'==': {EProps.IS_DELETED: False}} + edge_query = {'==': {EProps.VITRAGE_IS_DELETED: False}} subgraph = ga.graph_query_vertices( query_dict=query, depth=5, edge_query_dict=edge_query) self.assertEqual(self.entity_graph.num_edges() - 1, @@ -207,12 +209,12 @@ class GraphAlgorithmTest(GraphTestBase): 'should exist') # Undo changes made by this test - host_instance_edge[VProps.IS_DELETED] = False + host_instance_edge[VProps.VITRAGE_IS_DELETED] = False self.entity_graph.update_edge(host_instance_edge) self.entity_graph.remove_edge(new_edge) def test_no_match_graph_query_vertices(self): - query = {'==': {VProps.TYPE: 'test'}} + query = {'==': {VProps.VITRAGE_TYPE: 'test'}} subgraph = self.entity_graph.algo.graph_query_vertices(query) self.assertEqual( 0, @@ -235,28 +237,29 @@ class GraphAlgorithmTest(GraphTestBase): # Create a template for template matching template_graph = NXGraph('template_graph') t_v_host_alarm = graph_utils.create_vertex( - vitrage_id='1', entity_category=ALARM, entity_type=ALARM_ON_HOST) + vitrage_id='1', vitrage_category=ALARM, vitrage_type=ALARM_ON_HOST) t_v_alarm_fail = graph_utils.create_vertex( - vitrage_id='1', entity_category=ALARM, entity_type='fail') + vitrage_id='1', vitrage_category=ALARM, vitrage_type='fail') t_v_host = graph_utils.create_vertex( vitrage_id='2', - entity_category=RESOURCE, - entity_type=NOVA_HOST_DATASOURCE) + vitrage_category=RESOURCE, + vitrage_type=NOVA_HOST_DATASOURCE) t_v_vm = graph_utils.create_vertex( vitrage_id='3', - entity_category=RESOURCE, - entity_type=NOVA_INSTANCE_DATASOURCE) + vitrage_category=RESOURCE, + vitrage_type=NOVA_INSTANCE_DATASOURCE) t_v_vm_alarm = graph_utils.create_vertex( - vitrage_id='4', entity_category=ALARM, entity_type=ALARM_ON_VM) + vitrage_id='4', vitrage_category=ALARM, vitrage_type=ALARM_ON_VM) t_v_switch = graph_utils.create_vertex( - vitrage_id='5', entity_category=RESOURCE, entity_type=SWITCH) + vitrage_id='5', vitrage_category=RESOURCE, vitrage_type=SWITCH) t_v_node = graph_utils.create_vertex( vitrage_id='6', - entity_category=RESOURCE, - entity_type=OPENSTACK_CLUSTER) + vitrage_category=RESOURCE, + vitrage_type=OPENSTACK_CLUSTER) t_v_node_not_in_graph = graph_utils.create_vertex( - vitrage_id='7', entity_category=RESOURCE, - entity_type=OPENSTACK_CLUSTER + ' not in graph') + vitrage_id='7', + vitrage_category=RESOURCE, + vitrage_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) @@ -563,28 +566,28 @@ class GraphAlgorithmTest(GraphTestBase): # Create a template for template matching template_graph = NXGraph('template_graph') t_v_alarm_fail = graph_utils.create_vertex( - vitrage_id='1', entity_category=ALARM, entity_type='fail') + vitrage_id='1', vitrage_category=ALARM, vitrage_type='fail') t_v_host = graph_utils.create_vertex( vitrage_id='2', - entity_category=RESOURCE, - entity_type=NOVA_HOST_DATASOURCE) + vitrage_category=RESOURCE, + vitrage_type=NOVA_HOST_DATASOURCE) t_v_vm = graph_utils.create_vertex( vitrage_id='3', - entity_category=RESOURCE, - entity_type=NOVA_INSTANCE_DATASOURCE) + vitrage_category=RESOURCE, + vitrage_type=NOVA_INSTANCE_DATASOURCE) t_v_vm_alarm = graph_utils.create_vertex( - vitrage_id='4', entity_category=ALARM, entity_type=ALARM_ON_VM) + vitrage_id='4', vitrage_category=ALARM, vitrage_type=ALARM_ON_VM) e_host_contains_vm = graph_utils.create_edge( t_v_host.vertex_id, t_v_vm.vertex_id, ELabel.CONTAINS) e_alarm_not_on_vm = graph_utils.create_edge( t_v_vm_alarm.vertex_id, t_v_vm.vertex_id, ELabel.ON) e_alarm_not_on_vm[NEG_CONDITION] = True - e_alarm_not_on_vm[EProps.IS_DELETED] = True + e_alarm_not_on_vm[EProps.VITRAGE_IS_DELETED] = True e_alarm_not_on_host = graph_utils.create_edge( t_v_alarm_fail.vertex_id, t_v_host.vertex_id, ELabel.ON) e_alarm_not_on_host[NEG_CONDITION] = True - e_alarm_not_on_host[EProps.IS_DELETED] = True + e_alarm_not_on_host[EProps.VITRAGE_IS_DELETED] = True for v in [t_v_alarm_fail, t_v_host, t_v_vm, t_v_vm_alarm]: del(v[VProps.VITRAGE_ID]) @@ -626,16 +629,17 @@ class GraphAlgorithmTest(GraphTestBase): temp_ga = temp_entity_graph.algo vms = temp_entity_graph.neighbors( host.vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: NOVA_INSTANCE_DATASOURCE}) + vertex_attr_filter={ + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE}) ################################################################### # Use case 1: remove alarms of specific vm ################################################################### alarms = temp_entity_graph.neighbors( vms[0].vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: ALARM_ON_VM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: ALARM_ON_VM}) for alarm in alarms: temp_entity_graph.remove_vertex(alarm) @@ -664,18 +668,19 @@ class GraphAlgorithmTest(GraphTestBase): ################################################################### vms = temp_entity_graph.neighbors( host.vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: NOVA_INSTANCE_DATASOURCE}) + vertex_attr_filter={ + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE}) alarms = temp_entity_graph.neighbors( vms[1].vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: ALARM_ON_VM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: ALARM_ON_VM}) for alarm in alarms: - alarm[VProps.IS_DELETED] = True + alarm[VProps.VITRAGE_IS_DELETED] = True temp_entity_graph.update_vertex(alarm) edges = temp_entity_graph.get_edges(alarm.vertex_id) for edge in edges: - edge[EProps.IS_DELETED] = True + edge[EProps.VITRAGE_IS_DELETED] = True temp_entity_graph.update_edge(edge) mappings = temp_ga.sub_graph_matching(template_graph, @@ -691,12 +696,12 @@ class GraphAlgorithmTest(GraphTestBase): ################################################################### alarms = temp_entity_graph.neighbors( vms[2].vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: ALARM_ON_VM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: ALARM_ON_VM}) for alarm in alarms: edges = temp_entity_graph.get_edges(alarm.vertex_id) for edge in edges: - edge[EProps.IS_DELETED] = True + edge[EProps.VITRAGE_IS_DELETED] = True temp_entity_graph.update_edge(edge) mappings = temp_ga.sub_graph_matching(template_graph, @@ -713,10 +718,10 @@ class GraphAlgorithmTest(GraphTestBase): ################################################################### alarms = temp_entity_graph.neighbors( vms[3].vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: ALARM_ON_VM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: ALARM_ON_VM}) deleted_vertex = alarms[0] - deleted_vertex[VProps.IS_DELETED] = True + deleted_vertex[VProps.VITRAGE_IS_DELETED] = True temp_entity_graph.update_vertex(deleted_vertex) mappings = temp_ga.sub_graph_matching(template_graph, Mapping(t_v_vm_alarm, @@ -735,11 +740,11 @@ class GraphAlgorithmTest(GraphTestBase): ################################################################### alarms = temp_entity_graph.neighbors( vms[4].vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: ALARM_ON_VM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: ALARM_ON_VM}) edges = list(temp_entity_graph.get_edges(alarms[0].vertex_id)) deleted_edge = edges[0] - deleted_edge[EProps.IS_DELETED] = True + deleted_edge[EProps.VITRAGE_IS_DELETED] = True temp_entity_graph.update_edge(deleted_edge) mappings = temp_ga.sub_graph_matching(template_graph, Mapping(e_alarm_not_on_vm, @@ -754,16 +759,16 @@ class GraphAlgorithmTest(GraphTestBase): ################################################################### # Use case 6: event arrived on deleted alarm edge on vm, that has - # other is_deleted alarms on it + # other vitrage_is_deleted alarms on it ################################################################### alarms = temp_entity_graph.neighbors( vms[5].vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: ALARM_ON_VM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: ALARM_ON_VM}) for alarm in alarms: edges = temp_entity_graph.get_edges(alarm.vertex_id) for edge in edges: - edge[EProps.IS_DELETED] = True + edge[EProps.VITRAGE_IS_DELETED] = True temp_entity_graph.update_edge(edge) deleted_edge = \ list(temp_entity_graph.get_edges(alarms[0].vertex_id))[0] @@ -792,15 +797,15 @@ class GraphAlgorithmTest(GraphTestBase): template_graph = NXGraph('template_graph') t_v_vm = graph_utils.create_vertex( vitrage_id='1', - entity_category=RESOURCE, - entity_type=NOVA_INSTANCE_DATASOURCE) + vitrage_category=RESOURCE, + vitrage_type=NOVA_INSTANCE_DATASOURCE) t_v_vm_alarm = graph_utils.create_vertex( - vitrage_id='2', entity_category=ALARM, entity_type=ALARM_ON_VM) + vitrage_id='2', vitrage_category=ALARM, vitrage_type=ALARM_ON_VM) e_alarm_not_on_vm = graph_utils.create_edge( t_v_vm_alarm.vertex_id, t_v_vm.vertex_id, ELabel.ON) e_alarm_not_on_vm[NEG_CONDITION] = True - e_alarm_not_on_vm[EProps.IS_DELETED] = True + e_alarm_not_on_vm[EProps.VITRAGE_IS_DELETED] = True for v in [t_v_vm, t_v_vm_alarm]: del(v[VProps.VITRAGE_ID]) @@ -817,8 +822,9 @@ class GraphAlgorithmTest(GraphTestBase): temp_ga = temp_entity_graph.algo vms = temp_entity_graph.neighbors( graph_host.vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: NOVA_INSTANCE_DATASOURCE}) + vertex_attr_filter={ + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE}) ################################################################### # Use case 1: find subgraphs (when edges are deleted) with event on @@ -826,12 +832,12 @@ class GraphAlgorithmTest(GraphTestBase): ################################################################### alarms = temp_entity_graph.neighbors( vms[0].vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: ALARM_ON_VM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: ALARM_ON_VM}) for alarm in alarms: edges = temp_entity_graph.get_edges(alarm.vertex_id) for edge in edges: - edge[EProps.IS_DELETED] = True + edge[EProps.VITRAGE_IS_DELETED] = True temp_entity_graph.update_edge(edge) graph_alarm_edge = \ @@ -860,10 +866,10 @@ class GraphAlgorithmTest(GraphTestBase): ################################################################### alarms = temp_entity_graph.neighbors( vms[1].vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: ALARM_ON_VM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: ALARM_ON_VM}) for alarm in alarms: - alarm[VProps.IS_DELETED] = True + alarm[VProps.VITRAGE_IS_DELETED] = True temp_entity_graph.update_vertex(alarm) graph_alarm_edge = \ @@ -892,14 +898,14 @@ class GraphAlgorithmTest(GraphTestBase): ################################################################### alarms = temp_entity_graph.neighbors( vms[2].vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: ALARM_ON_VM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: ALARM_ON_VM}) for alarm in alarms: - alarm[VProps.IS_DELETED] = True + alarm[VProps.VITRAGE_IS_DELETED] = True temp_entity_graph.update_vertex(alarm) edges = temp_entity_graph.get_edges(alarm.vertex_id) for edge in edges: - edge[EProps.IS_DELETED] = True + edge[EProps.VITRAGE_IS_DELETED] = True temp_entity_graph.update_edge(edge) graph_alarm_edge = \ @@ -931,10 +937,10 @@ class GraphAlgorithmTest(GraphTestBase): ################################################################### alarms = temp_entity_graph.neighbors( vms[3].vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: ALARM_ON_VM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: ALARM_ON_VM}) graph_alarm = alarms[0] - graph_alarm[VProps.IS_DELETED] = True + graph_alarm[VProps.VITRAGE_IS_DELETED] = True graph_alarm_edge = \ list(temp_entity_graph.get_edges(alarms[0].vertex_id))[0] @@ -963,12 +969,12 @@ class GraphAlgorithmTest(GraphTestBase): ################################################################### alarms = temp_entity_graph.neighbors( vms[4].vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: ALARM_ON_VM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: ALARM_ON_VM}) graph_alarm_edge = \ list(temp_entity_graph.get_edges(alarms[0].vertex_id))[0] - graph_alarm_edge[EProps.IS_DELETED] = True + graph_alarm_edge[EProps.VITRAGE_IS_DELETED] = True temp_entity_graph.update_edge(graph_alarm_edge) mappings = temp_ga.sub_graph_matching( @@ -986,14 +992,14 @@ class GraphAlgorithmTest(GraphTestBase): ################################################################### alarms = temp_entity_graph.neighbors( vms[5].vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: ALARM_ON_VM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: ALARM_ON_VM}) - alarms[0][VProps.IS_DELETED] = True + alarms[0][VProps.VITRAGE_IS_DELETED] = True temp_entity_graph.update_vertex(alarms[0]) graph_alarm_edge = \ list(temp_entity_graph.get_edges(alarms[0].vertex_id))[0] - graph_alarm_edge[EProps.IS_DELETED] = True + graph_alarm_edge[EProps.VITRAGE_IS_DELETED] = True temp_entity_graph.update_edge(graph_alarm_edge) mappings = temp_ga.sub_graph_matching( @@ -1020,25 +1026,25 @@ class GraphAlgorithmTest(GraphTestBase): template_graph = NXGraph('template_graph') t_v_network = graph_utils.create_vertex( vitrage_id='1', - entity_category=RESOURCE, - entity_type=NEUTRON_NETWORK_DATASOURCE) + vitrage_category=RESOURCE, + vitrage_type=NEUTRON_NETWORK_DATASOURCE) t_v_vm = graph_utils.create_vertex( vitrage_id='2', - entity_category=RESOURCE, - entity_type=NOVA_INSTANCE_DATASOURCE) + vitrage_category=RESOURCE, + vitrage_type=NOVA_INSTANCE_DATASOURCE) t_v_alarm = graph_utils.create_vertex( - vitrage_id='3', entity_category=ALARM, entity_type=ALARM_ON_VM) + vitrage_id='3', vitrage_category=ALARM, vitrage_type=ALARM_ON_VM) t_v_stack = graph_utils.create_vertex( vitrage_id='4', - entity_category=RESOURCE, - entity_type=HEAT_STACK_DATASOURCE) + vitrage_category=RESOURCE, + vitrage_type=HEAT_STACK_DATASOURCE) e_network_connect_vm = graph_utils.create_edge( t_v_network.vertex_id, t_v_vm.vertex_id, ELabel.CONNECT) e_alarm_not_on_vm = graph_utils.create_edge( t_v_alarm.vertex_id, t_v_vm.vertex_id, ELabel.ON) e_alarm_not_on_vm[NEG_CONDITION] = True - e_alarm_not_on_vm[EProps.IS_DELETED] = True + e_alarm_not_on_vm[EProps.VITRAGE_IS_DELETED] = True e_alarm_on_stack = graph_utils.create_edge( t_v_alarm.vertex_id, t_v_stack.vertex_id, ELabel.ON) e_stack_connect_network = graph_utils.create_edge( @@ -1070,24 +1076,25 @@ class GraphAlgorithmTest(GraphTestBase): temp_ga = temp_entity_graph.algo vms = temp_entity_graph.neighbors( graph_host.vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: NOVA_INSTANCE_DATASOURCE}) + vertex_attr_filter={ + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE}) ################################################################### # Use case 1: alarm connected to vm ################################################################### alarms = temp_entity_graph.neighbors( vms[0].vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: ALARM_ON_VM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: ALARM_ON_VM}) # Action for alarm in alarms[1:len(alarms)]: - alarm[VProps.IS_DELETED] = True + alarm[VProps.VITRAGE_IS_DELETED] = True temp_entity_graph.update_vertex(alarm) edges = temp_entity_graph.get_edges(alarm.vertex_id) for edge in edges: - edge[EProps.IS_DELETED] = True + edge[EProps.VITRAGE_IS_DELETED] = True temp_entity_graph.update_edge(edge) # build problematic subgraph in entity graph @@ -1122,18 +1129,19 @@ class GraphAlgorithmTest(GraphTestBase): 'Template - Two not connected vertices (vm <- alarm)') ################################################################### - # Use case 2: alarm not connected to vm (with edge is_deleted=True) + # Use case 2: alarm not connected to vm (with edge + # vitrage_is_deleted=True) ################################################################### alarms = temp_entity_graph.neighbors( vms[1].vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: ALARM_ON_VM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: ALARM_ON_VM}) # Action for alarm in alarms: edges = temp_entity_graph.get_edges(alarm.vertex_id) for edge in edges: - edge[EProps.IS_DELETED] = True + edge[EProps.VITRAGE_IS_DELETED] = True temp_entity_graph.update_edge(edge) # build problematic subgraph in entity graph @@ -1172,8 +1180,8 @@ class GraphAlgorithmTest(GraphTestBase): ################################################################### alarms = temp_entity_graph.neighbors( vms[2].vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: ALARM_ON_VM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: ALARM_ON_VM}) # Action for alarm in alarms: @@ -1213,17 +1221,17 @@ class GraphAlgorithmTest(GraphTestBase): 'Template - Two not connected vertices (vm <- alarm)') ################################################################### - # Use case 4: alarm not connected to vm (with edge is_deleted=True) - # and other connected alarms exist + # Use case 4: alarm not connected to vm (with edge + # vitrage_is_deleted=True) and other connected alarms exist ################################################################### alarms = temp_entity_graph.neighbors( vms[3].vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: ALARM_ON_VM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: ALARM_ON_VM}) # Action edges = [e for e in temp_entity_graph.get_edges(alarms[0].vertex_id)] - edges[0][EProps.IS_DELETED] = True + edges[0][EProps.VITRAGE_IS_DELETED] = True temp_entity_graph.update_edge(edge) # build problematic subgraph in entity graph @@ -1289,8 +1297,8 @@ class GraphAlgorithmTest(GraphTestBase): ################################################################### alarms = temp_entity_graph.neighbors( vms[4].vertex_id, - vertex_attr_filter={VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: ALARM_ON_VM}) + vertex_attr_filter={VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: ALARM_ON_VM}) # Action edges = [e for e in temp_entity_graph.get_edges(alarms[0].vertex_id)] @@ -1360,8 +1368,8 @@ class GraphAlgorithmTest(GraphTestBase): num): stack_vertex = graph_utils.create_vertex( vitrage_id='stack' + str(num), - entity_category=RESOURCE, - entity_type=HEAT_STACK_DATASOURCE) + vitrage_category=RESOURCE, + vitrage_type=HEAT_STACK_DATASOURCE) temp_entity_graph.update_vertex(stack_vertex) alarm_stack_edge = graph_utils.create_edge( @@ -1370,8 +1378,8 @@ class GraphAlgorithmTest(GraphTestBase): network_vertex = graph_utils.create_vertex( vitrage_id='network' + str(num), - entity_category=RESOURCE, - entity_type=NEUTRON_NETWORK_DATASOURCE) + vitrage_category=RESOURCE, + vitrage_type=NEUTRON_NETWORK_DATASOURCE) temp_entity_graph.update_vertex(network_vertex) network_stack_edge = graph_utils.create_edge( diff --git a/vitrage/tests/unit/notifier/snmp_notifier/common.py b/vitrage/tests/unit/notifier/snmp_notifier/common.py index 0deb1bba4..19c578bcf 100644 --- a/vitrage/tests/unit/notifier/snmp_notifier/common.py +++ b/vitrage/tests/unit/notifier/snmp_notifier/common.py @@ -12,12 +12,11 @@ # License for the specific language governing permissions and limitations # under the License. +from vitrage.common.constants import EntityCategory from vitrage.common.constants import VertexProperties as VProps - false_ = 'False' name_ = 'VM network problem' -category_ = 'ALARM' critical_ = 'CRITICAL' GENERAL_OID = '1.3.6.1.4.1' @@ -30,14 +29,14 @@ SEVERITY_OID = '3' ALERT_OID = '.100000' -alarm_data = {VProps.CATEGORY: category_, +alarm_data = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, VProps.NAME: name_, - VProps.RESOURCE + '_' + VProps.IS_DELETED: false_, - VProps.RESOURCE + '_' + VProps.IS_PLACEHOLDER: false_, - VProps.IS_DELETED: false_, - VProps.OPERATIONAL_SEVERITY: critical_, + VProps.RESOURCE + '_' + VProps.VITRAGE_IS_DELETED: false_, + VProps.RESOURCE + '_' + VProps.VITRAGE_IS_PLACEHOLDER: false_, + VProps.VITRAGE_IS_DELETED: false_, + VProps.VITRAGE_OPERATIONAL_SEVERITY: critical_, VProps.RESOURCE: - {VProps.IS_PLACEHOLDER: false_, - VProps.IS_DELETED: false_}} + {VProps.VITRAGE_IS_PLACEHOLDER: false_, + VProps.VITRAGE_IS_DELETED: false_}} alert_details = {'oid': ALERT_OID, 'alarm_name': 'vitrageDeducedTest'} diff --git a/vitrage/tests/unit/notifier/snmp_notifier/test_snmp_notifier.py b/vitrage/tests/unit/notifier/snmp_notifier/test_snmp_notifier.py index a916deffb..dda0962f4 100644 --- a/vitrage/tests/unit/notifier/snmp_notifier/test_snmp_notifier.py +++ b/vitrage/tests/unit/notifier/snmp_notifier/test_snmp_notifier.py @@ -13,6 +13,7 @@ # under the License. +from vitrage.common.constants import EntityCategory from vitrage.common.constants import VertexProperties as VProps from vitrage.graph import Vertex from vitrage.notifier.plugins.snmp.snmp_notifier import SnmpNotifier @@ -24,13 +25,13 @@ class SnmpNotifierTest(base.BaseTest): @classmethod def setUpClass(cls): - cls.resource_props = {VProps.IS_DELETED: common.false_, - VProps.IS_PLACEHOLDER: common.false_} - cls.props = {VProps.IS_DELETED: common.false_, + cls.resource_props = {VProps.VITRAGE_IS_DELETED: common.false_, + VProps.VITRAGE_IS_PLACEHOLDER: common.false_} + cls.props = {VProps.VITRAGE_IS_DELETED: common.false_, VProps.NAME: common.name_, VProps.RESOURCE: cls.resource_props, - VProps.CATEGORY: common.category_, - VProps.OPERATIONAL_SEVERITY: common.critical_} + VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_OPERATIONAL_SEVERITY: common.critical_} cls.alarm_vertex = Vertex('RESOURCE:nova.instance:test1', cls.props) def test_parse_alarm(self): @@ -38,13 +39,17 @@ class SnmpNotifierTest(base.BaseTest): self.assert_is_not_empty(alarm_data) - self.assertEqual(alarm_data.get(VProps.IS_DELETED), common.false_) + self.assertEqual(alarm_data.get(VProps.VITRAGE_IS_DELETED), + common.false_) self.assertEqual(alarm_data.get(VProps.NAME), common.name_) - self.assertEqual(alarm_data.get(VProps.CATEGORY), common.category_) - self.assertEqual(alarm_data.get(VProps.OPERATIONAL_SEVERITY), + self.assertEqual(alarm_data.get(VProps.VITRAGE_CATEGORY), + EntityCategory.ALARM) + self.assertEqual(alarm_data.get(VProps.VITRAGE_OPERATIONAL_SEVERITY), common.critical_) self.assertEqual(alarm_data.get(VProps.RESOURCE + '_' + - VProps.IS_DELETED), common.false_) + VProps.VITRAGE_IS_DELETED), + common.false_) self.assertEqual(alarm_data.get(VProps.RESOURCE + '_' + - VProps.IS_PLACEHOLDER), common.false_) + VProps.VITRAGE_IS_PLACEHOLDER), + common.false_) diff --git a/vitrage/tests/unit/notifier/snmp_notifier/test_snmp_sender_with_severity_map.py b/vitrage/tests/unit/notifier/snmp_notifier/test_snmp_sender_with_severity_map.py index 4b084df09..eca77bfad 100644 --- a/vitrage/tests/unit/notifier/snmp_notifier/test_snmp_sender_with_severity_map.py +++ b/vitrage/tests/unit/notifier/snmp_notifier/test_snmp_sender_with_severity_map.py @@ -60,13 +60,13 @@ class SnmpNotifierTest(base.BaseTest): self.assertEqual(len(var_lst), 3) self.assertIn(VProps.NAME, oids) - self.assertIn(VProps.IS_DELETED, oids) - self.assertIn(VProps.OPERATIONAL_SEVERITY, oids) + self.assertIn(VProps.VITRAGE_IS_DELETED, oids) + self.assertIn(VProps.VITRAGE_OPERATIONAL_SEVERITY, oids) self.assertIn(sender.SEVERITY, oids) self.assertIn(VProps.NAME, var_lst) - self.assertIn(VProps.IS_DELETED, var_lst) - self.assertIn(VProps.OPERATIONAL_SEVERITY, var_lst) + self.assertIn(VProps.VITRAGE_IS_DELETED, var_lst) + self.assertIn(VProps.VITRAGE_OPERATIONAL_SEVERITY, var_lst) def test_var_binds(self): @@ -84,10 +84,12 @@ class SnmpNotifierTest(base.BaseTest): var_binds) self.assertIn((oid_with_alarm_objects + '.' + common.IS_DELETED_OID, OctetString(common.alarm_data.get - (VProps.IS_DELETED, sender.NA))), var_binds) + (VProps.VITRAGE_IS_DELETED, sender.NA))), + var_binds) self.assertIn((oid_with_alarm_objects + '.' + common.SEVERITY_OID, OctetString(common.alarm_data.get - (VProps.OPERATIONAL_SEVERITY, sender.NA))), + (VProps.VITRAGE_OPERATIONAL_SEVERITY, + sender.NA))), var_binds) def test_get_severity_oid(self): diff --git a/vitrage/tests/unit/notifier/snmp_notifier/test_snmp_sender_without_severity_map.py b/vitrage/tests/unit/notifier/snmp_notifier/test_snmp_sender_without_severity_map.py index 6c7e13792..6c5c43ceb 100644 --- a/vitrage/tests/unit/notifier/snmp_notifier/test_snmp_sender_without_severity_map.py +++ b/vitrage/tests/unit/notifier/snmp_notifier/test_snmp_sender_without_severity_map.py @@ -59,13 +59,13 @@ class SnmpNotifierTest(base.BaseTest): self.assertEqual(len(var_lst), 3) self.assertIn(VProps.NAME, oids) - self.assertIn(VProps.IS_DELETED, oids) - self.assertIn(VProps.OPERATIONAL_SEVERITY, oids) + self.assertIn(VProps.VITRAGE_IS_DELETED, oids) + self.assertIn(VProps.VITRAGE_OPERATIONAL_SEVERITY, oids) self.assertIn(sender.ALARM_OID, oids) self.assertIn(VProps.NAME, var_lst) - self.assertIn(VProps.IS_DELETED, var_lst) - self.assertIn(VProps.OPERATIONAL_SEVERITY, var_lst) + self.assertIn(VProps.VITRAGE_IS_DELETED, var_lst) + self.assertIn(VProps.VITRAGE_OPERATIONAL_SEVERITY, var_lst) def test_get_severity_oid(self): diff --git a/vitrage/tests/unit/notifier/test_notifier.py b/vitrage/tests/unit/notifier/test_notifier.py index 98ac2befb..7dcaa7000 100644 --- a/vitrage/tests/unit/notifier/test_notifier.py +++ b/vitrage/tests/unit/notifier/test_notifier.py @@ -18,11 +18,13 @@ test_vitrage graph Tests for `vitrage` graph driver """ + import copy from vitrage.common.constants import EntityCategory from vitrage.common.constants import NotifierEventTypes as NType from vitrage.common.constants import VertexProperties as VProps +from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE from vitrage.entity_graph.processor.notifier import _get_notification_type from vitrage.evaluator.actions import evaluator_event_transformer as evaluator from vitrage.graph import Vertex @@ -30,54 +32,54 @@ from vitrage.tests import base resource = Vertex('123', { - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: 'some_resource_type', - VProps.IS_DELETED: False, - VProps.IS_PLACEHOLDER: False, + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: 'some_resource_type', + VProps.VITRAGE_IS_DELETED: False, + VProps.VITRAGE_IS_PLACEHOLDER: False, }) deduced_alarm = Vertex('123', { - VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: evaluator.VITRAGE_TYPE, - VProps.IS_DELETED: False, - VProps.IS_PLACEHOLDER: False, + VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: evaluator.VITRAGE_DATASOURCE, + VProps.VITRAGE_IS_DELETED: False, + VProps.VITRAGE_IS_PLACEHOLDER: False, }) non_deduced_alarm = Vertex('123', { - VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: 'TEST_ALARM', - VProps.IS_DELETED: False, - VProps.IS_PLACEHOLDER: True, + VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: 'TEST_ALARM', + VProps.VITRAGE_IS_DELETED: False, + VProps.VITRAGE_IS_PLACEHOLDER: True, }) deleted_alarm = Vertex('123', { - VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: evaluator.VITRAGE_TYPE, - VProps.IS_DELETED: True, - VProps.IS_PLACEHOLDER: False, + VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: evaluator.VITRAGE_DATASOURCE, + VProps.VITRAGE_IS_DELETED: True, + VProps.VITRAGE_IS_PLACEHOLDER: False, }) placeholder_alarm = Vertex('123', { - VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: evaluator.VITRAGE_TYPE, - VProps.IS_DELETED: False, - VProps.IS_PLACEHOLDER: True, + VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: evaluator.VITRAGE_DATASOURCE, + VProps.VITRAGE_IS_DELETED: False, + VProps.VITRAGE_IS_PLACEHOLDER: True, }) host = Vertex('123', { - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: 'nova.host', - VProps.IS_DELETED: False, - VProps.IS_PLACEHOLDER: False, + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE, + VProps.VITRAGE_IS_DELETED: False, + VProps.VITRAGE_IS_PLACEHOLDER: False, }) forced_down_host = Vertex('123', { - VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: 'nova.host', - VProps.IS_DELETED: False, - VProps.IS_PLACEHOLDER: False, + VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE, + VProps.VITRAGE_IS_DELETED: False, + VProps.VITRAGE_IS_PLACEHOLDER: False, VProps.IS_MARKED_DOWN: True, }) @@ -139,7 +141,7 @@ class GraphTest(base.BaseTest): def test_notification_type_deleted_host(self): deleted_host = copy.deepcopy(forced_down_host) - deleted_host[VProps.IS_DELETED] = True + deleted_host[VProps.VITRAGE_IS_DELETED] = True ret = _get_notification_type(forced_down_host, deleted_host, True) self.assertEqual( NType.DEACTIVATE_MARK_DOWN_EVENT, @@ -147,7 +149,7 @@ class GraphTest(base.BaseTest): 'deleted host with forced_down should notify deactivate') deleted_host = copy.deepcopy(host) - deleted_host[VProps.IS_DELETED] = True + deleted_host[VProps.VITRAGE_IS_DELETED] = True ret = _get_notification_type(forced_down_host, deleted_host, True) self.assertEqual( NType.DEACTIVATE_MARK_DOWN_EVENT, @@ -155,7 +157,7 @@ class GraphTest(base.BaseTest): 'deleted host with forced_down should notify deactivate') deleted_host = copy.deepcopy(host) - deleted_host[VProps.IS_DELETED] = True + deleted_host[VProps.VITRAGE_IS_DELETED] = True ret = _get_notification_type(host, deleted_host, True) self.assertIsNone( self.get_first(ret), @@ -167,20 +169,20 @@ class GraphTest(base.BaseTest): 'A not new host should be ignored') deleted_host = copy.deepcopy(forced_down_host) - deleted_host[VProps.IS_DELETED] = True + deleted_host[VProps.VITRAGE_IS_DELETED] = True ret = _get_notification_type(deleted_host, forced_down_host, True) self.assertEqual(NType.ACTIVATE_MARK_DOWN_EVENT, self.get_first(ret), 'old host become not deleted should notify activate') deleted_host = copy.deepcopy(forced_down_host) - deleted_host[VProps.IS_DELETED] = True + deleted_host[VProps.VITRAGE_IS_DELETED] = True ret = _get_notification_type(deleted_host, host, True) self.assertIsNone(self.get_first(ret), 'old host become not deleted should not notify') placeholder_host = copy.deepcopy(forced_down_host) - placeholder_host[VProps.IS_PLACEHOLDER] = True + placeholder_host[VProps.VITRAGE_IS_PLACEHOLDER] = True ret = _get_notification_type(placeholder_host, forced_down_host, True) self.assertEqual(NType.ACTIVATE_MARK_DOWN_EVENT, self.get_first(ret), @@ -188,7 +190,7 @@ class GraphTest(base.BaseTest): def test_notification_type_placeholder_host(self): placeholder_host = copy.deepcopy(forced_down_host) - placeholder_host[VProps.IS_PLACEHOLDER] = True + placeholder_host[VProps.VITRAGE_IS_PLACEHOLDER] = True ret = _get_notification_type(None, placeholder_host, True) self.assertIsNone(self.get_first(ret), 'A not new host vertex should be ignored') diff --git a/vitrage_tempest_tests/tests/api/alarms/test_alarms.py b/vitrage_tempest_tests/tests/api/alarms/test_alarms.py index b851c38af..c17f361ee 100644 --- a/vitrage_tempest_tests/tests/api/alarms/test_alarms.py +++ b/vitrage_tempest_tests/tests/api/alarms/test_alarms.py @@ -72,7 +72,7 @@ class TestAlarms(BaseAlarmsTest): cli_items = cli_alarms.splitlines() api_by_type = self._filter_list_by_pairs_parameters( - api_alarms, [VProps.TYPE], [resource_type]) + api_alarms, [VProps.VITRAGE_TYPE], [resource_type]) cli_by_type = cli_alarms.count(' ' + resource_type + ' ') api_by_id = self._filter_list_by_pairs_parameters( diff --git a/vitrage_tempest_tests/tests/api/base.py b/vitrage_tempest_tests/tests/api/base.py index 68b499e97..c3e47933a 100644 --- a/vitrage_tempest_tests/tests/api/base.py +++ b/vitrage_tempest_tests/tests/api/base.py @@ -121,8 +121,9 @@ class BaseApiTest(base.BaseTestCase): def _get_host(self): topology = self.vitrage_client.topology.get(all_tenants=True) - host = filter(lambda item: item[VProps.TYPE] == NOVA_HOST_DATASOURCE, - topology['nodes']) + host = filter( + lambda item: item[VProps.VITRAGE_TYPE] == NOVA_HOST_DATASOURCE, + topology['nodes']) return host[0] def _create_instances(self, num_instances, set_public_network=False): @@ -247,29 +248,29 @@ class BaseApiTest(base.BaseTestCase): validation_data = [] # openstack.cluster - props = {VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: OPENSTACK_CLUSTER, + props = {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: OPENSTACK_CLUSTER, self.NUM_VERTICES_PER_TYPE: kwargs.get('cluster_entities', 1), self.NUM_EDGES_PER_TYPE: kwargs.get('cluster_edges', 1)} validation_data.append(props) # nova.zone - props = {VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: NOVA_ZONE_DATASOURCE, + props = {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_ZONE_DATASOURCE, self.NUM_VERTICES_PER_TYPE: kwargs.get('zone_entities', 1), self.NUM_EDGES_PER_TYPE: kwargs.get('zone_edges', 2)} validation_data.append(props) # nova.host - props = {VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: NOVA_HOST_DATASOURCE, + props = {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE, self.NUM_VERTICES_PER_TYPE: kwargs.get('host_entities', 1), self.NUM_EDGES_PER_TYPE: kwargs.get('host_edges', 1)} validation_data.append(props) # nova.instance - props = {VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: NOVA_INSTANCE_DATASOURCE, + props = {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE, self.NUM_VERTICES_PER_TYPE: kwargs.get( 'instance_entities', 0), self.NUM_EDGES_PER_TYPE: kwargs.get( @@ -277,8 +278,8 @@ class BaseApiTest(base.BaseTestCase): validation_data.append(props) # cinder.volume - props = {VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: CINDER_VOLUME_DATASOURCE, + props = {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: CINDER_VOLUME_DATASOURCE, self.NUM_VERTICES_PER_TYPE: kwargs.get( 'volume_entities', 0), self.NUM_EDGES_PER_TYPE: kwargs.get( @@ -286,8 +287,8 @@ class BaseApiTest(base.BaseTestCase): validation_data.append(props) # switch - props = {VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: SWITCH, + props = {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: SWITCH, self.NUM_VERTICES_PER_TYPE: kwargs.get( 'switch_entities', 0), self.NUM_EDGES_PER_TYPE: kwargs.get( @@ -295,8 +296,8 @@ class BaseApiTest(base.BaseTestCase): validation_data.append(props) # aodh - props = {VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: AODH_DATASOURCE, + props = {VProps.VITRAGE_CATEGORY: EntityCategory.ALARM, + VProps.VITRAGE_TYPE: AODH_DATASOURCE, self.NUM_VERTICES_PER_TYPE: kwargs.get( 'aodh_entities', 0), self.NUM_EDGES_PER_TYPE: kwargs.get( @@ -305,8 +306,8 @@ class BaseApiTest(base.BaseTestCase): # neutron.network if kwargs.get('network_entities') is not None: - props = {VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: NEUTRON_NETWORK_DATASOURCE, + props = {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NEUTRON_NETWORK_DATASOURCE, self.NUM_VERTICES_PER_TYPE: kwargs.get( 'network_entities', 0), self.NUM_EDGES_PER_TYPE: kwargs.get( @@ -315,8 +316,8 @@ class BaseApiTest(base.BaseTestCase): # neutron.port if kwargs.get('port_entities') is not None: - props = {VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: NEUTRON_PORT_DATASOURCE, + props = {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: NEUTRON_PORT_DATASOURCE, self.NUM_VERTICES_PER_TYPE: kwargs.get( 'port_entities', 0), self.NUM_EDGES_PER_TYPE: kwargs.get( @@ -324,8 +325,8 @@ class BaseApiTest(base.BaseTestCase): validation_data.append(props) # heat.stack - props = {VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: HEAT_STACK_DATASOURCE, + props = {VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, + VProps.VITRAGE_TYPE: HEAT_STACK_DATASOURCE, self.NUM_VERTICES_PER_TYPE: kwargs.get( 'stack_entities', 0), self.NUM_EDGES_PER_TYPE: kwargs.get( @@ -344,23 +345,23 @@ class BaseApiTest(base.BaseTestCase): for entity in entities: query = { - VProps.CATEGORY: entity[VProps.CATEGORY], - VProps.TYPE: entity[VProps.TYPE], - VProps.IS_DELETED: False, - VProps.IS_PLACEHOLDER: False + VProps.VITRAGE_CATEGORY: entity[VProps.VITRAGE_CATEGORY], + VProps.VITRAGE_TYPE: entity[VProps.VITRAGE_TYPE], + VProps.VITRAGE_IS_DELETED: False, + VProps.VITRAGE_IS_PLACEHOLDER: False } vertices = graph.get_vertices(vertex_attr_filter=query) self.assertEqual(entity[self.NUM_VERTICES_PER_TYPE], len(vertices), '%s%s' % ('Num vertices is incorrect for: ', - entity[VProps.TYPE])) + entity[VProps.VITRAGE_TYPE])) entity_num_edges = sum([len(graph.get_edges(vertex.vertex_id)) for vertex in vertices]) self.assertEqual(entity[self.NUM_EDGES_PER_TYPE], entity_num_edges, '%s%s' % ('Num edges is incorrect for: ', - entity[VProps.TYPE])) + entity[VProps.VITRAGE_TYPE])) self.assertEqual(num_entities, graph.num_vertices()) self.assertEqual(num_edges, graph.num_edges()) diff --git a/vitrage_tempest_tests/tests/api/event/test_events.py b/vitrage_tempest_tests/tests/api/event/test_events.py index fd8d5c6ea..a6aaf9316 100644 --- a/vitrage_tempest_tests/tests/api/event/test_events.py +++ b/vitrage_tempest_tests/tests/api/event/test_events.py @@ -94,12 +94,12 @@ class TestEvents(base.BaseTestCase): return False, api_alarms def _check_alarm(self, alarm, event_time, event_type, details): - self.assertEqual(EntityCategory.ALARM, alarm[VProps.CATEGORY]) + self.assertEqual(EntityCategory.ALARM, alarm[VProps.VITRAGE_CATEGORY]) self.assertEqual(event_type, alarm[VProps.NAME]) self.assertEqual(event_time, alarm[EventProps.TIME]) self.assertEqual(details['status'], alarm['status']) - self.assertFalse(alarm[VProps.IS_DELETED]) - self.assertFalse(alarm[VProps.IS_PLACEHOLDER]) + self.assertFalse(alarm[VProps.VITRAGE_IS_DELETED]) + self.assertFalse(alarm[VProps.VITRAGE_IS_PLACEHOLDER]) @staticmethod def _wait_for_status(max_waiting, func, **kwargs): diff --git a/vitrage_tempest_tests/tests/api/rca/base.py b/vitrage_tempest_tests/tests/api/rca/base.py index ed5046ce6..96c562854 100644 --- a/vitrage_tempest_tests/tests/api/rca/base.py +++ b/vitrage_tempest_tests/tests/api/rca/base.py @@ -25,7 +25,7 @@ from vitrage.entity_graph.mappings.operational_alarm_severity \ from vitrage.entity_graph.mappings.operational_resource_state \ import OperationalResourceState from vitrage.evaluator.actions.evaluator_event_transformer \ - import VITRAGE_TYPE + import VITRAGE_DATASOURCE from vitrage_tempest_tests.tests.api.alarms.base import BaseAlarmsTest import vitrage_tempest_tests.tests.utils as utils @@ -50,7 +50,7 @@ class BaseRcaTest(BaseAlarmsTest): list_alarms = self.vitrage_client.alarm.list(vitrage_id=None) expected_alarm = self._filter_list_by_pairs_parameters( - list_alarms, ['resource_id', VProps.TYPE], + list_alarms, ['resource_id', VProps.VITRAGE_TYPE], [resource_id, AODH_DATASOURCE]) if not expected_alarm: return None @@ -73,12 +73,12 @@ class BaseRcaTest(BaseAlarmsTest): LOG.info("The rca alarms list is : " + str(json.dumps(rca))) resource_alarm = self._filter_list_by_pairs_parameters( - rca, [VProps.TYPE, VProps.NAME], + rca, [VProps.VITRAGE_TYPE, VProps.NAME], [AODH_DATASOURCE, RCA_ALARM_NAME]) deduce_alarms = self._filter_list_by_pairs_parameters( - rca, [VProps.TYPE, VProps.NAME, VProps.SEVERITY], - [VITRAGE_TYPE, VITRAGE_ALARM_NAME, + rca, [VProps.VITRAGE_TYPE, VProps.NAME, VProps.SEVERITY], + [VITRAGE_DATASOURCE, VITRAGE_ALARM_NAME, OperationalAlarmSeverity.WARNING]) self.assertEqual(len(rca), 3) @@ -92,15 +92,15 @@ class BaseRcaTest(BaseAlarmsTest): deduce_alarms_1 = self._filter_list_by_pairs_parameters( alarms, - [VProps.TYPE, VProps.NAME, 'resource_type', 'resource_id'], - [VITRAGE_TYPE, VITRAGE_ALARM_NAME, + [VProps.VITRAGE_TYPE, VProps.NAME, 'resource_type', 'resource_id'], + [VITRAGE_DATASOURCE, VITRAGE_ALARM_NAME, NOVA_INSTANCE_DATASOURCE, utils.uni2str(instances[0].id)]) deduce_alarms_2 = self._filter_list_by_pairs_parameters( alarms, - [VProps.TYPE, VProps.NAME, 'resource_type', 'resource_id'], - [VITRAGE_TYPE, VITRAGE_ALARM_NAME, + [VProps.VITRAGE_TYPE, VProps.NAME, 'resource_type', 'resource_id'], + [VITRAGE_DATASOURCE, VITRAGE_ALARM_NAME, NOVA_INSTANCE_DATASOURCE, utils.uni2str(instances[1].id)]) @@ -132,8 +132,8 @@ class BaseRcaTest(BaseAlarmsTest): host = self._filter_list_by_pairs_parameters( topology, - [VProps.TYPE, VProps.ID, VProps.VITRAGE_STATE, - VProps.AGGREGATED_STATE], + [VProps.VITRAGE_TYPE, VProps.ID, VProps.VITRAGE_STATE, + VProps.VITRAGE_AGGREGATED_STATE], [NOVA_HOST_DATASOURCE, self._get_hostname(), OperationalResourceState.ERROR, @@ -141,8 +141,8 @@ class BaseRcaTest(BaseAlarmsTest): vm1 = self._filter_list_by_pairs_parameters( topology, - [VProps.TYPE, VProps.ID, VProps.VITRAGE_STATE, - VProps.AGGREGATED_STATE], + [VProps.VITRAGE_TYPE, VProps.ID, VProps.VITRAGE_STATE, + VProps.VITRAGE_AGGREGATED_STATE], [NOVA_INSTANCE_DATASOURCE, utils.uni2str(instances[0].id), OperationalResourceState.SUBOPTIMAL, @@ -150,8 +150,8 @@ class BaseRcaTest(BaseAlarmsTest): vm2 = self._filter_list_by_pairs_parameters( topology, - [VProps.TYPE, VProps.ID, VProps.VITRAGE_STATE, - VProps.AGGREGATED_STATE], + [VProps.VITRAGE_TYPE, VProps.ID, VProps.VITRAGE_STATE, + VProps.VITRAGE_AGGREGATED_STATE], [NOVA_INSTANCE_DATASOURCE, utils.uni2str(instances[1].id), OperationalResourceState.SUBOPTIMAL, @@ -189,7 +189,7 @@ class BaseRcaTest(BaseAlarmsTest): @staticmethod def _clean_timestamps(alist): try: - del alist[5][1][0][VProps.SAMPLE_TIMESTAMP] + del alist[5][1][0][VProps.VITRAGE_SAMPLE_TIMESTAMP] del alist[5][1][0][VProps.UPDATE_TIMESTAMP] except Exception: pass diff --git a/vitrage_tempest_tests/tests/api/resources/test_resources.py b/vitrage_tempest_tests/tests/api/resources/test_resources.py index 1b99ba6a9..52f89336b 100644 --- a/vitrage_tempest_tests/tests/api/resources/test_resources.py +++ b/vitrage_tempest_tests/tests/api/resources/test_resources.py @@ -11,11 +11,13 @@ # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. + import json import traceback from oslo_log import log as logging +from vitrage.common.constants import VertexProperties as VProps from vitrage.datasources import CINDER_VOLUME_DATASOURCE from vitrage.datasources import NOVA_INSTANCE_DATASOURCE from vitrage_tempest_tests.tests.api.base import BaseApiTest @@ -28,7 +30,11 @@ LOG = logging.getLogger(__name__) class TestResource(BaseApiTest): """Test class for Vitrage resource API tests.""" - properties = ('vitrage_id', 'type', 'id', 'state', 'aggregated_state') + properties = (VProps.VITRAGE_ID, + VProps.VITRAGE_TYPE, + VProps.ID, + VProps.STATE, + VProps.VITRAGE_AGGREGATED_STATE) @classmethod def setUpClass(cls): diff --git a/vitrage_tempest_tests/tests/api/topology/base.py b/vitrage_tempest_tests/tests/api/topology/base.py index 866acfd6a..2c84f5a2f 100644 --- a/vitrage_tempest_tests/tests/api/topology/base.py +++ b/vitrage_tempest_tests/tests/api/topology/base.py @@ -82,47 +82,47 @@ class BaseTopologyTest(BaseApiTest): item.pop(VProps.UPDATE_TIMESTAMP, None) for item in sorted_cli_graph[4][1]: - item.pop(VProps.SAMPLE_TIMESTAMP, None) + item.pop(VProps.VITRAGE_SAMPLE_TIMESTAMP, None) for item in sorted_api_graph[4][1]: - item.pop(VProps.SAMPLE_TIMESTAMP, None) + item.pop(VProps.VITRAGE_SAMPLE_TIMESTAMP, None) self.assertEqual(sorted_cli_graph, sorted_api_graph) @staticmethod def _graph_query(): - return '{"and": [{"==": {"category": "RESOURCE"}},' \ - '{"==": {"is_deleted": false}},' \ - '{"==": {"is_placeholder": false}},' \ - '{"or": [{"==": {"type": "openstack.cluster"}},' \ - '{"==": {"type": "nova.instance"}},' \ - '{"==": {"type": "nova.host"}},' \ - '{"==": {"type": "nova.zone"}}]}]}' + return '{"and": [{"==": {"vitrage_category": "RESOURCE"}},' \ + '{"==": {"vitrage_is_deleted": false}},' \ + '{"==": {"vitrage_is_placeholder": false}},' \ + '{"or": [{"==": {"vitrage_type": "openstack.cluster"}},' \ + '{"==": {"vitrage_type": "nova.instance"}},' \ + '{"==": {"vitrage_type": "nova.host"}},' \ + '{"==": {"vitrage_type": "nova.zone"}}]}]}' @staticmethod def _tree_query(): - return '{"and": [{"==": {"category": "RESOURCE"}},' \ - '{"==": {"is_deleted": false}},' \ - '{"==": {"is_placeholder": false}},' \ - '{"or": [{"==": {"type": "openstack.cluster"}},' \ - '{"==": {"type": "nova.host"}},' \ - '{"==": {"type": "nova.zone"}}]}]}' + return '{"and": [{"==": {"vitrage_category": "RESOURCE"}},' \ + '{"==": {"vitrage_is_deleted": false}},' \ + '{"==": {"vitrage_is_placeholder": false}},' \ + '{"or": [{"==": {"vitrage_type": "openstack.cluster"}},' \ + '{"==": {"vitrage_type": "nova.host"}},' \ + '{"==": {"vitrage_type": "nova.zone"}}]}]}' @staticmethod def _graph_no_match_query(): - return '{"and": [{"==": {"category": "test"}},' \ - '{"==": {"is_deleted": false}},' \ - '{"==": {"is_placeholder": false}},' \ - '{"or": [{"==": {"type": "openstack.cluster"}},' \ - '{"==": {"type": "nova.instance"}},' \ - '{"==": {"type": "nova.host"}},' \ - '{"==": {"type": "nova.zone"}}]}]}' + return '{"and": [{"==": {"vitrage_category": "test"}},' \ + '{"==": {"vitrage_is_deleted": false}},' \ + '{"==": {"vitrage_is_placeholder": false}},' \ + '{"or": [{"==": {"vitrage_type": "openstack.cluster"}},' \ + '{"==": {"vitrage_type": "nova.instance"}},' \ + '{"==": {"vitrage_type": "nova.host"}},' \ + '{"==": {"vitrage_type": "nova.zone"}}]}]}' @staticmethod def _tree_no_match_query(): - return '{"and": [{"==": {"category": "test"}},' \ - '{"==": {"is_deleted": false}},' \ - '{"==": {"is_placeholder": false}},' \ - '{"or": [{"==": {"type": "openstack.cluster"}},' \ - '{"==": {"type": "nova.host"}},' \ - '{"==": {"type": "nova.zone"}}]}]}' + return '{"and": [{"==": {"vitrage_category": "test"}},' \ + '{"==": {"vitrage_is_deleted": false}},' \ + '{"==": {"vitrage_is_placeholder": false}},' \ + '{"or": [{"==": {"vitrage_type": "openstack.cluster"}},' \ + '{"==": {"vitrage_type": "nova.host"}},' \ + '{"==": {"vitrage_type": "nova.zone"}}]}]}' diff --git a/vitrage_tempest_tests/tests/api/topology/test_topology.py b/vitrage_tempest_tests/tests/api/topology/test_topology.py index 826af0989..24dca2243 100644 --- a/vitrage_tempest_tests/tests/api/topology/test_topology.py +++ b/vitrage_tempest_tests/tests/api/topology/test_topology.py @@ -24,13 +24,13 @@ import unittest LOG = logging.getLogger(__name__) -NOVA_QUERY = '{"and": [{"==": {"category": "RESOURCE"}},' \ - '{"==": {"is_deleted": false}},' \ - '{"==": {"is_placeholder": false}},' \ - '{"or": [{"==": {"type": "openstack.cluster"}},' \ - '{"==": {"type": "nova.instance"}},' \ - '{"==": {"type": "nova.host"}},' \ - '{"==": {"type": "nova.zone"}}]}]}' +NOVA_QUERY = '{"and": [{"==": {"vitrage_category": "RESOURCE"}},' \ + '{"==": {"vitrage_is_deleted": false}},' \ + '{"==": {"vitrage_is_placeholder": false}},' \ + '{"or": [{"==": {"vitrage_type": "openstack.cluster"}},' \ + '{"==": {"vitrage_type": "nova.instance"}},' \ + '{"==": {"vitrage_type": "nova.host"}},' \ + '{"==": {"vitrage_type": "nova.zone"}}]}]}' CLUSTER_VERTEX_ID = 'RESOURCE:openstack.cluster:OpenStack Cluster'