From f6d367b69383b28d5f25923ba85aca9a998be2dc Mon Sep 17 00:00:00 2001 From: liathartal Date: Wed, 6 Apr 2016 12:44:58 +0000 Subject: [PATCH] rename refactor - replace 'synchronizer' and 'plugin' to 'datasource' and 'driver' Change-Id: I582bb6d1ab42c7dd9f38956bc043d09c04edbf88 --- devstack/plugin.sh | 32 ++-- devstack/settings | 3 +- etc/vitrage/vitrage-config-generator.conf | 2 +- etc/vitrage/vitrage.conf.sample | 50 +++---- vitrage/api/controllers/rest.py | 2 +- vitrage/cmd/graph.py | 8 +- vitrage/datasources/__init__.py | 48 ++++++ .../alarm_driver_base.py} | 11 +- .../alarm_properties.py} | 0 .../alarm_transformer_base.py} | 4 +- .../plugins => datasources}/aodh/__init__.py | 15 +- .../aodh/driver.py} | 32 ++-- .../aodh/properties.py | 0 .../aodh/transformer.py | 15 +- .../cinder/__init__.py | 0 .../cinder/volume/__init__.py | 14 +- .../cinder/volume/driver.py} | 18 +-- .../cinder/volume/transformer.py | 26 ++-- .../driver_base.py} | 2 +- .../{synchronizer => datasources}/launcher.py | 18 +-- .../listener_service.py | 40 ++--- .../nagios/__init__.py | 17 +-- .../plugins => datasources}/nagios/config.py | 0 .../nagios/driver.py} | 21 ++- .../plugins => datasources}/nagios/parser.py | 3 +- .../nagios/properties.py | 0 .../nagios/transformer.py | 22 ++- .../neutron/__init__.py | 0 .../plugins => datasources}/neutron/base.py | 4 +- .../neutron/network/__init__.py | 14 +- .../neutron/network/driver.py} | 8 +- .../neutron/network/transformer.py | 17 +-- .../neutron/port/__init__.py | 11 +- .../neutron/port/driver.py} | 8 +- .../neutron/port/transformer.py | 26 ++-- vitrage/datasources/nova/__init__.py | 1 + .../nova/host/__init__.py | 11 +- .../nova/host/driver.py} | 8 +- .../nova/host/transformer.py | 24 +-- .../nova/instance/__init__.py | 14 +- .../nova/instance/driver.py} | 16 +- .../nova/instance/transformer.py | 25 ++-- .../nova/nova_driver_base.py} | 6 +- .../nova/zone/__init__.py | 12 +- .../nova/zone/driver.py} | 10 +- .../nova/zone/transformer.py | 24 +-- .../resource_transformer_base.py} | 7 +- .../{synchronizer => datasources}/services.py | 36 ++--- .../static_physical/__init__.py | 20 +-- .../static_physical/driver.py} | 12 +- .../static_physical/transformer.py | 16 +- .../transformer_base.py | 16 +- vitrage/entity_graph/__init__.py | 7 +- .../api_handler/entity_graph_api.py | 14 +- vitrage/entity_graph/consistency/__init__.py | 4 +- .../consistency/consistency_enforcer.py | 4 +- vitrage/entity_graph/consistency/service.py | 4 +- vitrage/entity_graph/processor/processor.py | 4 +- vitrage/entity_graph/states/state_manager.py | 94 ++++++------ vitrage/entity_graph/transformer_manager.py | 12 +- .../actions/evaluator_event_transformer.py | 4 +- .../evaluator/actions/recipes/raise_alarm.py | 3 +- vitrage/opts.py | 27 ++-- vitrage/service.py | 6 +- vitrage/synchronizer/__init__.py | 22 --- vitrage/synchronizer/plugins/__init__.py | 46 ------ vitrage/synchronizer/test_client.py.template | 43 ------ vitrage/tests/functional/base.py | 10 +- .../functional/datasources}/__init__.py | 0 .../functional/datasources/aodh}/__init__.py | 0 .../aodh/test_aodh.py | 0 .../{data_sources => datasources}/base.py | 0 .../datasources/cinder}/__init__.py | 0 .../cinder/test_cinder_volume.py | 47 +++--- .../datasources/nagios}/__init__.py | 0 .../nagios/test_nagios.py | 44 +++--- .../neutron}/__init__.py | 0 .../neutron/test_neutron_network.py | 0 .../neutron/test_neutron_port.py | 0 .../aodh => datasources/nova}/__init__.py | 0 .../nova/test_nova_datasources.py} | 12 +- .../static_physical}/__init__.py | 0 .../static_physical/test_static_physical.py | 50 +++---- .../consistency/test_consistency.py | 46 +++--- .../entity_graph/processor/test_processor.py | 4 +- .../entity_graph/states/test_state_manager.py | 10 +- .../evaluator/test_action_executor.py | 35 ++--- .../evaluator/test_scenario_evaluator.py | 10 +- .../{mock_syncronizer.py => mock_driver.py} | 36 ++--- vitrage/tests/mocks/trace_generator.py | 95 ++++++------ .../erroneous_states}/nagios.yaml | 0 .../erroneous_states}/nova.host.yaml | 0 .../erroneous_states}/nova.instance.yaml | 0 .../nagios.yaml | 0 .../nova.host.yaml | 0 .../nova.instance.yaml | 0 .../nova.zone.yaml | 0 .../vitrage.yaml | 0 ...json => driver_host_snapshot_dynamic.json} | 0 ...json => driver_inst_snapshot_dynamic.json} | 0 ....json => driver_inst_snapshot_static.json} | 0 ...c.json => driver_inst_update_dynamic.json} | 0 ...on => driver_nagios_snapshot_dynamic.json} | 0 ...son => driver_nagios_snapshot_static.json} | 0 ...on => driver_switch_snapshot_dynamic.json} | 0 ...on => driver_volume_snapshot_dynamic.json} | 0 ...json => driver_volume_update_dynamic.json} | 0 ...json => driver_zone_snapshot_dynamic.json} | 0 .../switch_to_host_plugin.yaml | 2 +- .../switch_to_switch_plugin.yaml | 2 +- .../switch_to_host_plugin.yaml | 2 +- .../switch_to_switch_plugin.yaml | 2 +- .../nagios => unit/datasources}/__init__.py | 0 .../datasources/cinder}/__init__.py | 0 .../cinder/test_cinder_volume_transformer.py | 37 ++--- .../datasources/nagios}/__init__.py | 0 .../nagios/mock_driver.py} | 14 +- .../nagios/nagios_base_test.py | 2 +- .../nagios/test_nagios_config.py | 41 ++--- .../nagios/test_nagios_driver.py} | 141 +++++++++--------- .../nagios/test_nagios_parser.py | 6 +- .../nagios/test_nagios_transformer.py | 25 ++-- .../datasources/nova}/__init__.py | 0 .../nova/test_nova_host_transformer.py | 44 +++--- .../nova/test_nova_instance_transformers.py | 53 ++++--- .../nova/test_nova_zone_transformer.py | 49 +++--- .../static_physical}/__init__.py | 0 .../test_static_physical_driver.py} | 59 ++++---- .../test_static_physical_transformer.py | 23 +-- vitrage/tests/unit/entity_graph/base.py | 46 +++--- .../tests/unit/entity_graph/processor/base.py | 4 +- .../entity_graph/processor/test_processor.py | 6 +- .../entity_graph/states/test_state_manager.py | 90 +++++------ .../entity_graph/test_transformer_manager.py | 54 ++++--- .../evaluator/recipes/test_raise_alarm.py | 2 +- vitrage/tests/unit/graph/base.py | 20 +-- vitrage/tests/unit/graph/test_graph.py | 23 +-- vitrage/tests/unit/graph/test_graph_algo.py | 14 +- .../unit/synchronizer/plugins/__init__.py | 15 -- .../synchronizer/plugins/cinder/__init__.py | 15 -- .../synchronizer/plugins/nagios/__init__.py | 15 -- .../synchronizer/plugins/nova/__init__.py | 15 -- .../plugins/static_physical/__init__.py | 15 -- vitrage_tempest_tests/tests/base_mock.py | 6 +- 144 files changed, 1071 insertions(+), 1213 deletions(-) create mode 100644 vitrage/datasources/__init__.py rename vitrage/{synchronizer/plugins/base/alarm/synchronizer.py => datasources/alarm_driver_base.py} (92%) rename vitrage/{synchronizer/plugins/base/alarm/properties.py => datasources/alarm_properties.py} (100%) rename vitrage/{synchronizer/plugins/base/alarm/transformer.py => datasources/alarm_transformer_base.py} (93%) rename vitrage/{synchronizer/plugins => datasources}/aodh/__init__.py (67%) rename vitrage/{synchronizer/plugins/aodh/synchronizer.py => datasources/aodh/driver.py} (77%) rename vitrage/{synchronizer/plugins => datasources}/aodh/properties.py (100%) rename vitrage/{synchronizer/plugins => datasources}/aodh/transformer.py (90%) rename vitrage/{synchronizer/plugins => datasources}/cinder/__init__.py (100%) rename vitrage/{synchronizer/plugins => datasources}/cinder/volume/__init__.py (70%) rename vitrage/{synchronizer/plugins/cinder/volume/synchronizer.py => datasources/cinder/volume/driver.py} (71%) rename vitrage/{synchronizer/plugins => datasources}/cinder/volume/transformer.py (87%) rename vitrage/{synchronizer/plugins/synchronizer_base.py => datasources/driver_base.py} (99%) rename vitrage/{synchronizer => datasources}/launcher.py (77%) rename vitrage/{synchronizer/plugins => datasources}/listener_service.py (73%) rename vitrage/{synchronizer/plugins => datasources}/nagios/__init__.py (74%) rename vitrage/{synchronizer/plugins => datasources}/nagios/config.py (100%) rename vitrage/{synchronizer/plugins/nagios/synchronizer.py => datasources/nagios/driver.py} (85%) rename vitrage/{synchronizer/plugins => datasources}/nagios/parser.py (98%) rename vitrage/{synchronizer/plugins => datasources}/nagios/properties.py (100%) rename vitrage/{synchronizer/plugins => datasources}/nagios/transformer.py (86%) rename vitrage/{synchronizer/plugins => datasources}/neutron/__init__.py (100%) rename vitrage/{synchronizer/plugins => datasources}/neutron/base.py (87%) rename vitrage/{synchronizer/plugins => datasources}/neutron/network/__init__.py (66%) rename vitrage/{synchronizer/plugins/neutron/network/synchronizer.py => datasources/neutron/network/driver.py} (81%) rename vitrage/{synchronizer/plugins => datasources}/neutron/network/transformer.py (84%) rename vitrage/{synchronizer/plugins => datasources}/neutron/port/__init__.py (71%) rename vitrage/{synchronizer/plugins/neutron/port/synchronizer.py => datasources/neutron/port/driver.py} (82%) rename vitrage/{synchronizer/plugins => datasources}/neutron/port/transformer.py (87%) create mode 100644 vitrage/datasources/nova/__init__.py rename vitrage/{synchronizer/plugins => datasources}/nova/host/__init__.py (72%) rename vitrage/{synchronizer/plugins/nova/host/synchronizer.py => datasources/nova/host/driver.py} (84%) rename vitrage/{synchronizer/plugins => datasources}/nova/host/transformer.py (83%) rename vitrage/{synchronizer/plugins => datasources}/nova/instance/__init__.py (70%) rename vitrage/{synchronizer/plugins/nova/instance/synchronizer.py => datasources/nova/instance/driver.py} (75%) rename vitrage/{synchronizer/plugins => datasources}/nova/instance/transformer.py (85%) rename vitrage/{synchronizer/plugins/nova/base.py => datasources/nova/nova_driver_base.py} (83%) rename vitrage/{synchronizer/plugins => datasources}/nova/zone/__init__.py (73%) rename vitrage/{synchronizer/plugins/nova/zone/synchronizer.py => datasources/nova/zone/driver.py} (84%) rename vitrage/{synchronizer/plugins => datasources}/nova/zone/transformer.py (87%) rename vitrage/{synchronizer/plugins/base/resource/transformer.py => datasources/resource_transformer_base.py} (88%) rename vitrage/{synchronizer => datasources}/services.py (70%) rename vitrage/{synchronizer/plugins => datasources}/static_physical/__init__.py (65%) rename vitrage/{synchronizer/plugins/static_physical/synchronizer.py => datasources/static_physical/driver.py} (92%) rename vitrage/{synchronizer/plugins => datasources}/static_physical/transformer.py (91%) rename vitrage/{synchronizer/plugins => datasources}/transformer_base.py (93%) delete mode 100644 vitrage/synchronizer/__init__.py delete mode 100644 vitrage/synchronizer/plugins/__init__.py delete mode 100644 vitrage/synchronizer/test_client.py.template rename vitrage/{synchronizer/plugins/base => tests/functional/datasources}/__init__.py (100%) rename vitrage/{synchronizer/plugins/base/alarm => tests/functional/datasources/aodh}/__init__.py (100%) rename vitrage/tests/functional/{data_sources => datasources}/aodh/test_aodh.py (100%) rename vitrage/tests/functional/{data_sources => datasources}/base.py (100%) rename vitrage/{synchronizer/plugins/base/resource => tests/functional/datasources/cinder}/__init__.py (100%) rename vitrage/tests/functional/{data_sources => datasources}/cinder/test_cinder_volume.py (64%) rename vitrage/{synchronizer/plugins/nova => tests/functional/datasources/nagios}/__init__.py (100%) rename vitrage/tests/functional/{data_sources => datasources}/nagios/test_nagios.py (66%) rename vitrage/tests/functional/{data_sources => datasources/neutron}/__init__.py (100%) rename vitrage/tests/functional/{data_sources => datasources}/neutron/test_neutron_network.py (100%) rename vitrage/tests/functional/{data_sources => datasources}/neutron/test_neutron_port.py (100%) rename vitrage/tests/functional/{data_sources/aodh => datasources/nova}/__init__.py (100%) rename vitrage/tests/functional/{data_sources/nova/test_nova_plugins.py => datasources/nova/test_nova_datasources.py} (82%) rename vitrage/tests/functional/{data_sources/cinder => datasources/static_physical}/__init__.py (100%) rename vitrage/tests/functional/{data_sources => datasources}/static_physical/test_static_physical.py (64%) rename vitrage/tests/mocks/{mock_syncronizer.py => mock_driver.py} (90%) rename vitrage/tests/resources/{states_plugins/erroneous_states_plugins => datasources_states/erroneous_states}/nagios.yaml (100%) rename vitrage/tests/resources/{states_plugins/erroneous_states_plugins => datasources_states/erroneous_states}/nova.host.yaml (100%) rename vitrage/tests/resources/{states_plugins/erroneous_states_plugins => datasources_states/erroneous_states}/nova.instance.yaml (100%) rename vitrage/tests/resources/{states_plugins => datasources_states}/nagios.yaml (100%) rename vitrage/tests/resources/{states_plugins => datasources_states}/nova.host.yaml (100%) rename vitrage/tests/resources/{states_plugins => datasources_states}/nova.instance.yaml (100%) rename vitrage/tests/resources/{states_plugins => datasources_states}/nova.zone.yaml (100%) rename vitrage/tests/resources/{states_plugins => datasources_states}/vitrage.yaml (100%) rename vitrage/tests/resources/mock_configurations/synchronizer/{sync_host_snapshot_dynamic.json => driver_host_snapshot_dynamic.json} (100%) rename vitrage/tests/resources/mock_configurations/synchronizer/{sync_inst_snapshot_dynamic.json => driver_inst_snapshot_dynamic.json} (100%) rename vitrage/tests/resources/mock_configurations/synchronizer/{sync_inst_snapshot_static.json => driver_inst_snapshot_static.json} (100%) rename vitrage/tests/resources/mock_configurations/synchronizer/{sync_inst_update_dynamic.json => driver_inst_update_dynamic.json} (100%) rename vitrage/tests/resources/mock_configurations/synchronizer/{sync_nagios_snapshot_dynamic.json => driver_nagios_snapshot_dynamic.json} (100%) rename vitrage/tests/resources/mock_configurations/synchronizer/{sync_nagios_snapshot_static.json => driver_nagios_snapshot_static.json} (100%) rename vitrage/tests/resources/mock_configurations/synchronizer/{sync_switch_snapshot_dynamic.json => driver_switch_snapshot_dynamic.json} (100%) rename vitrage/tests/resources/mock_configurations/synchronizer/{sync_volume_snapshot_dynamic.json => driver_volume_snapshot_dynamic.json} (100%) rename vitrage/tests/resources/mock_configurations/synchronizer/{sync_volume_update_dynamic.json => driver_volume_update_dynamic.json} (100%) rename vitrage/tests/resources/mock_configurations/synchronizer/{sync_zone_snapshot_dynamic.json => driver_zone_snapshot_dynamic.json} (100%) rename vitrage/tests/resources/{static_plugins/changes_plugins => static_datasources/changes_datasources}/switch_to_host_plugin.yaml (96%) rename vitrage/tests/resources/{static_plugins/changes_plugins => static_datasources/changes_datasources}/switch_to_switch_plugin.yaml (91%) rename vitrage/tests/resources/{static_plugins => static_datasources}/switch_to_host_plugin.yaml (96%) rename vitrage/tests/resources/{static_plugins => static_datasources}/switch_to_switch_plugin.yaml (91%) rename vitrage/tests/{functional/data_sources/nagios => unit/datasources}/__init__.py (100%) rename vitrage/tests/{functional/data_sources/neutron => unit/datasources/cinder}/__init__.py (100%) rename vitrage/tests/unit/{synchronizer/plugins => datasources}/cinder/test_cinder_volume_transformer.py (87%) rename vitrage/tests/{functional/data_sources/nova => unit/datasources/nagios}/__init__.py (100%) rename vitrage/tests/unit/{synchronizer/plugins/nagios/mock_synchronizer.py => datasources/nagios/mock_driver.py} (71%) rename vitrage/tests/unit/{synchronizer/plugins => datasources}/nagios/nagios_base_test.py (95%) rename vitrage/tests/unit/{synchronizer/plugins => datasources}/nagios/test_nagios_config.py (84%) rename vitrage/tests/unit/{synchronizer/plugins/nagios/test_nagios_synchronizer.py => datasources/nagios/test_nagios_driver.py} (76%) rename vitrage/tests/unit/{synchronizer/plugins => datasources}/nagios/test_nagios_parser.py (93%) rename vitrage/tests/unit/{synchronizer/plugins => datasources}/nagios/test_nagios_transformer.py (86%) rename vitrage/tests/{functional/data_sources/static_physical => unit/datasources/nova}/__init__.py (100%) rename vitrage/tests/unit/{synchronizer/plugins => datasources}/nova/test_nova_host_transformer.py (83%) rename vitrage/tests/unit/{synchronizer/plugins => datasources}/nova/test_nova_instance_transformers.py (87%) rename vitrage/tests/unit/{synchronizer/plugins => datasources}/nova/test_nova_zone_transformer.py (85%) rename vitrage/tests/unit/{synchronizer => datasources/static_physical}/__init__.py (100%) rename vitrage/tests/unit/{synchronizer/plugins/static_physical/test_static_physical_synchronizer.py => datasources/static_physical/test_static_physical_driver.py} (68%) rename vitrage/tests/unit/{synchronizer/plugins => datasources}/static_physical/test_static_physical_transformer.py (89%) delete mode 100644 vitrage/tests/unit/synchronizer/plugins/__init__.py delete mode 100644 vitrage/tests/unit/synchronizer/plugins/cinder/__init__.py delete mode 100644 vitrage/tests/unit/synchronizer/plugins/nagios/__init__.py delete mode 100644 vitrage/tests/unit/synchronizer/plugins/nova/__init__.py delete mode 100644 vitrage/tests/unit/synchronizer/plugins/static_physical/__init__.py diff --git a/devstack/plugin.sh b/devstack/plugin.sh index 7911e7985..d39c9c278 100644 --- a/devstack/plugin.sh +++ b/devstack/plugin.sh @@ -100,14 +100,14 @@ function cleanup_vitrage { fi } -function disable_vitrage_plugin { +function disable_vitrage_datasource { - local enabled_plugins=",${VITRAGE_DEFAULT_PLUGINS}," - local plugin - for plugin in $@; do - enabled_plugins=${enabled_plugins//,$plugin,/,} + local enabled_datasources=",${VITRAGE_DEFAULT_DATASOURCES}," + local datasource + for datasource in $@; do + enabled_datasources=${enabled_datasources//,$datasource,/,} done - VITRAGE_DEFAULT_PLUGINS=$(_cleanup_service_list "$enabled_plugins") + VITRAGE_DEFAULT_DATSOURCES=$(_cleanup_service_list "$enabled_datasources") } @@ -134,29 +134,29 @@ function configure_vitrage { iniset $VITRAGE_CONF service_credentials region_name $REGION_NAME iniset $VITRAGE_CONF service_credentials auth_url $KEYSTONE_SERVICE_URI - # add default plugins - iniset $VITRAGE_CONF plugins plugin_type $VITRAGE_DEFAULT_PLUGINS + # add default datasources + iniset $VITRAGE_CONF datasources types $VITRAGE_DEFAULT_DATASOURCES - # remove neutron vitrage plugin if neutron plugin not installed + # remove neutron vitrage datasource if neutron datasource not installed if ! is_service_enabled neutron; then - disable_vitrage_plugin neutron.network neutron.port + disable_vitrage_datasource neutron.network neutron.port fi - # remove aodh vitrage plugin if aodh plugin not installed + # remove aodh vitrage datasource if aodh datasource not installed if ! is_service_enabled aodh; then - disable_vitrage_plugin aodh + disable_vitrage_datasource aodh fi # copy the mock sample files cp $VITRAGE_DIR/etc/vitrage/*.sample.json $VITRAGE_CONF_DIR # create some folders - mkdir -p $VITRAGE_CONF_DIR/states_plugins - mkdir -p $VITRAGE_CONF_DIR/static_plugins + mkdir -p $VITRAGE_CONF_DIR/datasources_states + mkdir -p $VITRAGE_CONF_DIR/static_datasources mkdir -p $VITRAGE_CONF_DIR/templates - # copy plugins - cp $VITRAGE_DIR/etc/vitrage/states_plugins/*.yaml $VITRAGE_CONF_DIR/states_plugins + # copy datasources + cp $VITRAGE_DIR/etc/vitrage/datasources_states/*.yaml $VITRAGE_CONF_DIR/datasources_states configure_auth_token_middleware $VITRAGE_CONF vitrage $VITRAGE_AUTH_CACHE_DIR diff --git a/devstack/settings b/devstack/settings index 7135b88f0..9f44adabe 100644 --- a/devstack/settings +++ b/devstack/settings @@ -20,8 +20,7 @@ VITRAGE_SERVICE_PROTOCOL=http VITRAGE_SERVICE_HOST=$SERVICE_HOST VITRAGE_SERVICE_PORT=${VITRAGE_SERVICE_PORT:-8999} VITRAGE_USE_MOD_WSGI=${VITRAGE_USE_MOD_WSGI:-${ENABLE_HTTPD_MOD_WSGI_SERVICES}} -VITRAGE_DEFAULT_PLUGINS=${VITRAGE_DEFAULT_PLUGINS:-nova.host,nova.instance, -nova.zone,nagios,static_physical,aodh,cinder.volume,neutron.network,neutron.port} +VITRAGE_DEFAULT_DATASOURCES=${VITRAGE_DEFAULT_DATASOURCES:-nova.host,nova.instance,nova.zone,nagios,static_physical,aodh,cinder.volume,neutron.network,neutron.port} # Tell Tempest this project is present diff --git a/etc/vitrage/vitrage-config-generator.conf b/etc/vitrage/vitrage-config-generator.conf index a30a987a8..8ab6fd51d 100644 --- a/etc/vitrage/vitrage-config-generator.conf +++ b/etc/vitrage/vitrage-config-generator.conf @@ -2,7 +2,7 @@ output_file = etc/vitrage/vitrage.conf wrap_width = 79 namespace = vitrage -namespace = plugins +namespace = datasources namespace = oslo.db namespace = oslo.log namespace = oslo.middleware diff --git a/etc/vitrage/vitrage.conf.sample b/etc/vitrage/vitrage.conf.sample index f8228bf8f..8939ed71a 100644 --- a/etc/vitrage/vitrage.conf.sample +++ b/etc/vitrage/vitrage.conf.sample @@ -112,16 +112,16 @@ [aodh] # -# From plugins +# From datasources # # Aodh plugin transformer class path (string value) -#transformer = vitrage.synchronizer.plugins.aodh.transformer.AodhTransformer +#transformer = vitrage.datasources.aodh.transformer.AodhTransformer # Aodh plugin synchronizer class path (string value) -#synchronizer = vitrage.synchronizer.plugins.aodh.synchronizer.AodhSynchronizer +#synchronizer = vitrage.datasources.aodh.driver.AodhDriver -# interval between checking changes in aodh plugin (integer value) +# interval between checking changes in aodh datasource (integer value) # Minimum value: 30 #changes_interval = 30 @@ -165,12 +165,12 @@ #min_time_to_delete = 60 # interval between consistency initialization checks for finding if all end -# messages from plugins were received (in seconds) (integer value) +# messages from data sources were received (in seconds) (integer value) # Minimum value: 1 #initialization_interval = 3 # maximum retries for consistency initialization for finding if all end -# messages from plugins were received (in seconds) (integer value) +# messages from data sources were received (in seconds) (integer value) # Minimum value: 1 #initialization_max_retries = 30 @@ -237,8 +237,8 @@ # From vitrage # -# A path for the configuration files of the plugins states (string value) -#states_plugins_dir = /etc/vitrage/states_plugins +# A path for the configuration files of the data sources states (string value) +#states_plugins_dir = /etc/vitrage/datasources_states [evaluator] @@ -392,16 +392,16 @@ [nagios] # -# From plugins +# From datasources # # Nagios plugin transformer class path (string value) -#transformer = vitrage.synchronizer.plugins.nagios.transformer.NagiosTransformer +#transformer = vitrage.datasources.nagios.transformer.NagiosTransformer -# Nagios plugin synchronizer class path (string value) -#synchronizer = vitrage.synchronizer.plugins.nagios.synchronizer.NagiosSynchronizer +# Nagios plugin driver class path (string value) +#synchronizer = vitrage.datasources.nagios.driver.NagiosDriver -# interval between checking changes in nagios plugin (integer value) +# interval between checking changes in nagios datasource (integer value) # Minimum value: 30 #changes_interval = 30 @@ -421,40 +421,40 @@ [nova.host] # -# From plugins +# From datasources # # Nova host transformer class path (string value) -#transformer = vitrage.synchronizer.plugins.nova.host.transformer.HostTransformer +#transformer = vitrage.datasources.nova.host.transformer.HostTransformer -# Nova host synchronizer class path (string value) -#synchronizer = vitrage.synchronizer.plugins.nova.host.synchronizer.HostSynchronizer +# Nova host driver class path (string value) +#synchronizer = vitrage.datasources.nova.host.driver.HostDriver [nova.instance] # -# From plugins +# From datasources # # Nova instance transformer class path (string value) -#transformer = vitrage.synchronizer.plugins.nova.instance.transformer.InstanceTransformer +#transformer = vitrage.datasources.nova.instance.transformer.InstanceTransformer -# Nova instance synchronizer class path (string value) -#synchronizer = vitrage.synchronizer.plugins.nova.instance.synchronizer.InstanceSynchronizer +# Nova instance driver class path (string value) +#synchronizer = vitrage.datasources.nova.instance.driver.InstanceDriver [nova.zone] # -# From plugins +# From datasources # # Nova zone transformer class path (string value) -#transformer = vitrage.synchronizer.plugins.nova.zone.transformer.ZoneTransformer +#transformer = vitrage.datasources.nova.zone.transformer.ZoneTransformer -# Nova zone synchronizer class path (string value) -#synchronizer = vitrage.synchronizer.plugins.nova.zone.synchronizer.ZoneSynchronizer +# Nova zone driver class path (string value) +#synchronizer = vitrage.datasources.nova.zone.driver.ZoneDriver [oslo_middleware] diff --git a/vitrage/api/controllers/rest.py b/vitrage/api/controllers/rest.py index fea939094..c1eca381f 100644 --- a/vitrage/api/controllers/rest.py +++ b/vitrage/api/controllers/rest.py @@ -20,7 +20,7 @@ import pecan as pecan from pecan import abort from pecan import rest -from vitrage.synchronizer.plugins import OPENSTACK_NODE +from vitrage.datasources import OPENSTACK_NODE LOG = log.getLogger(__name__) diff --git a/vitrage/cmd/graph.py b/vitrage/cmd/graph.py index 4241f3de1..c834caecc 100644 --- a/vitrage/cmd/graph.py +++ b/vitrage/cmd/graph.py @@ -19,6 +19,8 @@ import sys from oslo_service import service as os_service from vitrage.common.constants import EntityCategory +from vitrage.datasources import launcher as datasource_launcher +from vitrage.datasources import OPENSTACK_NODE from vitrage.entity_graph.api_handler import service as api_handler_svc from vitrage.entity_graph.consistency import service as consistency_svc from vitrage.entity_graph.initialization_status import InitializationStatus @@ -27,8 +29,6 @@ from vitrage.entity_graph import service as entity_graph_svc from vitrage.evaluator.scenario_evaluator import ScenarioEvaluator from vitrage.evaluator.scenario_repository import ScenarioRepository from vitrage import service -from vitrage.synchronizer import launcher as synchronizers_launcher -from vitrage.synchronizer.plugins import OPENSTACK_NODE def main(): @@ -42,9 +42,9 @@ def main(): conf, event_queue, evaluator, e_graph, initialization_status = init() launcher = os_service.ServiceLauncher(conf) - synchronizers = synchronizers_launcher.Launcher( + synchronizers = datasource_launcher.Launcher( conf, - synchronizers_launcher.create_send_to_queue_callback(event_queue)) + datasource_launcher.create_send_to_queue_callback(event_queue)) launcher.launch_service(entity_graph_svc.VitrageGraphService( conf, event_queue, evaluator, e_graph, initialization_status)) diff --git a/vitrage/datasources/__init__.py b/vitrage/datasources/__init__.py new file mode 100644 index 000000000..503e400ec --- /dev/null +++ b/vitrage/datasources/__init__.py @@ -0,0 +1,48 @@ +# Copyright 2016 - Nokia +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from oslo_config import cfg + +from vitrage.datasources.aodh import AODH_DATASOURCE +from vitrage.datasources.cinder.volume import CINDER_VOLUME_DATASOURCE +from vitrage.datasources.nagios import NAGIOS_DATASOURCE +from vitrage.datasources.neutron.network import NEUTRON_NETWORK_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.datasources.static_physical import STATIC_PHYSICAL_DATASOURCE + +OPENSTACK_NODE = 'openstack.node' + +# Register options for the service +OPTS = [ + + cfg.ListOpt('types', + default=[NOVA_HOST_DATASOURCE, + NOVA_INSTANCE_DATASOURCE, + NOVA_ZONE_DATASOURCE, + NAGIOS_DATASOURCE, + STATIC_PHYSICAL_DATASOURCE, + AODH_DATASOURCE, + CINDER_VOLUME_DATASOURCE, + NEUTRON_NETWORK_DATASOURCE], + help='Names of supported data sources'), + cfg.ListOpt('path', + default=['vitrage.datasources'], + help='base path for data sources'), + cfg.IntOpt('snapshots_interval', + default=600, + min=10, + help='interval between full snapshots') +] diff --git a/vitrage/synchronizer/plugins/base/alarm/synchronizer.py b/vitrage/datasources/alarm_driver_base.py similarity index 92% rename from vitrage/synchronizer/plugins/base/alarm/synchronizer.py rename to vitrage/datasources/alarm_driver_base.py index f399d7aa0..4258187ef 100644 --- a/vitrage/synchronizer/plugins/base/alarm/synchronizer.py +++ b/vitrage/datasources/alarm_driver_base.py @@ -13,14 +13,15 @@ # under the License. from oslo_log import log -from vitrage.synchronizer.plugins.synchronizer_base import SynchronizerBase + +from vitrage.datasources.driver_base import DriverBase LOG = log.getLogger(__name__) -class BaseAlarmSynchronizer(SynchronizerBase): +class AlarmDriverBase(DriverBase): def __init__(self): - super(SynchronizerBase, self).__init__() + super(DriverBase, self).__init__() self.cache = dict() def _sync_type(self): @@ -83,14 +84,14 @@ class BaseAlarmSynchronizer(SynchronizerBase): self._enrich_alarms(alarms) return self._filter_and_cache_alarms( alarms, - BaseAlarmSynchronizer._filter_get_all) + AlarmDriverBase._filter_get_all) def _get_changed_alarms(self): alarms = self._get_alarms() self._enrich_alarms(alarms) return self._filter_and_cache_alarms( alarms, - BaseAlarmSynchronizer._filter_get_changes) + AlarmDriverBase._filter_get_changes) def _filter_and_cache_alarms(self, alarms, filter_): alarms_to_update = [] diff --git a/vitrage/synchronizer/plugins/base/alarm/properties.py b/vitrage/datasources/alarm_properties.py similarity index 100% rename from vitrage/synchronizer/plugins/base/alarm/properties.py rename to vitrage/datasources/alarm_properties.py diff --git a/vitrage/synchronizer/plugins/base/alarm/transformer.py b/vitrage/datasources/alarm_transformer_base.py similarity index 93% rename from vitrage/synchronizer/plugins/base/alarm/transformer.py rename to vitrage/datasources/alarm_transformer_base.py index 24f1017d8..2e1fe2b15 100644 --- a/vitrage/synchronizer/plugins/base/alarm/transformer.py +++ b/vitrage/datasources/alarm_transformer_base.py @@ -19,12 +19,12 @@ from vitrage.common.constants import EventAction from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import SyncMode from vitrage.common.exception import VitrageTransformerError -from vitrage.synchronizer.plugins import transformer_base as tbase +from vitrage.datasources import transformer_base as tbase LOG = logging.getLogger(__name__) -class BaseAlarmTransformer(tbase.TransformerBase): +class AlarmTransformerBase(tbase.TransformerBase): def __init__(self, transformers): self.transformers = transformers diff --git a/vitrage/synchronizer/plugins/aodh/__init__.py b/vitrage/datasources/aodh/__init__.py similarity index 67% rename from vitrage/synchronizer/plugins/aodh/__init__.py rename to vitrage/datasources/aodh/__init__.py index 9024bcd93..c5029ceb1 100644 --- a/vitrage/synchronizer/plugins/aodh/__init__.py +++ b/vitrage/datasources/aodh/__init__.py @@ -14,22 +14,21 @@ from oslo_config import cfg -AODH_PLUGIN = 'aodh' +AODH_DATASOURCE = 'aodh' OPTS = [ cfg.StrOpt('transformer', - default='vitrage.synchronizer.plugins.aodh.' + default='vitrage.datasources.aodh.' 'transformer.AodhTransformer', - help='Aodh plugin transformer class path', + help='Aodh transformer class path', required=True), - cfg.StrOpt('synchronizer', - default='vitrage.synchronizer.plugins.aodh.synchronizer' - '.AodhSynchronizer', - help='Aodh plugin synchronizer class path', + cfg.StrOpt('driver', + default='vitrage.datasources.aodh.driver.AodhDriver', + help='Aodh driver class path', required=True), cfg.IntOpt('changes_interval', default=30, min=30, - help='interval between checking changes in aodh plugin', + help='interval between checking changes in aodh data source', required=True), ] diff --git a/vitrage/synchronizer/plugins/aodh/synchronizer.py b/vitrage/datasources/aodh/driver.py similarity index 77% rename from vitrage/synchronizer/plugins/aodh/synchronizer.py rename to vitrage/datasources/aodh/driver.py index a4db2a8fa..e5de21fc6 100644 --- a/vitrage/synchronizer/plugins/aodh/synchronizer.py +++ b/vitrage/datasources/aodh/driver.py @@ -15,23 +15,21 @@ from oslo_log import log from vitrage import clients -from vitrage.synchronizer.plugins.aodh import AODH_PLUGIN -from vitrage.synchronizer.plugins.aodh.properties import AodhProperties \ - as AodhProps -from vitrage.synchronizer.plugins.aodh.properties import AodhState -from vitrage.synchronizer.plugins.base.alarm.synchronizer \ - import BaseAlarmSynchronizer +from vitrage.datasources.alarm_driver_base import AlarmDriverBase +from vitrage.datasources.aodh import AODH_DATASOURCE +from vitrage.datasources.aodh.properties import AodhProperties as AodhProps +from vitrage.datasources.aodh.properties import AodhState LOG = log.getLogger(__name__) -class AodhSynchronizer(BaseAlarmSynchronizer): +class AodhDriver(AlarmDriverBase): def __init__(self, conf): - super(AodhSynchronizer, self).__init__() + super(AodhDriver, self).__init__() self.client = clients.ceilometer_client(conf) def _sync_type(self): - return AODH_PLUGIN + return AODH_DATASOURCE def _alarm_key(self, alarm): return alarm[AodhProps.NAME] @@ -60,19 +58,19 @@ class AodhSynchronizer(BaseAlarmSynchronizer): @staticmethod def _convert_event_alarm(alarm): - converted_alarm = AodhSynchronizer._convert_base_alarm(alarm) + converted_alarm = AodhDriver._convert_base_alarm(alarm) event_type, resource_id = \ - AodhSynchronizer._parse_event_rule(alarm.event_rule) + AodhDriver._parse_event_rule(alarm.event_rule) converted_alarm[AodhProps.EVENT_TYPE] = event_type converted_alarm[AodhProps.RESOURCE_ID] = resource_id return converted_alarm @staticmethod def _convert_threshold_alarm(alarm): - converted_alarm = AodhSynchronizer._convert_base_alarm(alarm) + converted_alarm = AodhDriver._convert_base_alarm(alarm) converted_alarm[AodhProps.STATE_TIMESTAMP] = alarm.state_timestamp converted_alarm[AodhProps.RESOURCE_ID] = \ - AodhSynchronizer._parse_threshold_rule(alarm.threshold_rule) + AodhDriver._parse_threshold_rule(alarm.threshold_rule) return converted_alarm @staticmethod @@ -96,12 +94,12 @@ class AodhSynchronizer(BaseAlarmSynchronizer): def _parse_event_rule(rule): event_type = rule[AodhProps.EVENT_TYPE] resource_id = \ - AodhSynchronizer._parse_resource_id(rule[AodhProps.QUERY]) + AodhDriver._parse_resource_id(rule[AodhProps.QUERY]) return event_type, resource_id @staticmethod def _parse_threshold_rule(rule): - return AodhSynchronizer._parse_resource_id(rule[AodhProps.QUERY]) + return AodhDriver._parse_resource_id(rule[AodhProps.QUERY]) @staticmethod def _parse_resource_id(query_fields): @@ -116,8 +114,8 @@ class AodhSynchronizer(BaseAlarmSynchronizer): def _convert_alarm(alarm): alarm_type = alarm.type if alarm_type == AodhProps.EVENT: - return AodhSynchronizer._convert_event_alarm(alarm) + return AodhDriver._convert_event_alarm(alarm) elif alarm_type == AodhProps.THRESHOLD: - return AodhSynchronizer._convert_threshold_alarm(alarm) + return AodhDriver._convert_threshold_alarm(alarm) else: LOG.info('Unsupported Aodh alarm of type %s' % alarm_type) diff --git a/vitrage/synchronizer/plugins/aodh/properties.py b/vitrage/datasources/aodh/properties.py similarity index 100% rename from vitrage/synchronizer/plugins/aodh/properties.py rename to vitrage/datasources/aodh/properties.py diff --git a/vitrage/synchronizer/plugins/aodh/transformer.py b/vitrage/datasources/aodh/transformer.py similarity index 90% rename from vitrage/synchronizer/plugins/aodh/transformer.py rename to vitrage/datasources/aodh/transformer.py index 33eb7b36c..e71d65846 100644 --- a/vitrage/synchronizer/plugins/aodh/transformer.py +++ b/vitrage/datasources/aodh/transformer.py @@ -18,20 +18,17 @@ from vitrage.common.constants import EntityCategory from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import VertexProperties as VProps from vitrage.common import datetime_utils +from vitrage.datasources.alarm_properties import AlarmProperties as AlarmProps +from vitrage.datasources.alarm_transformer_base import AlarmTransformerBase +from vitrage.datasources.aodh.properties import AodhProperties as AodhProps +from vitrage.datasources import transformer_base as tbase +from vitrage.datasources.transformer_base import Neighbor import vitrage.graph.utils as graph_utils -from vitrage.synchronizer.plugins.aodh.properties import AodhProperties \ - as AodhProps -from vitrage.synchronizer.plugins.base.alarm.properties \ - import AlarmProperties as AlarmProps -from vitrage.synchronizer.plugins.base.alarm.transformer \ - import BaseAlarmTransformer -from vitrage.synchronizer.plugins import transformer_base as tbase -from vitrage.synchronizer.plugins.transformer_base import Neighbor LOG = logging.getLogger(__name__) -class AodhTransformer(BaseAlarmTransformer): +class AodhTransformer(AlarmTransformerBase): STATUS_OK = 'ok' diff --git a/vitrage/synchronizer/plugins/cinder/__init__.py b/vitrage/datasources/cinder/__init__.py similarity index 100% rename from vitrage/synchronizer/plugins/cinder/__init__.py rename to vitrage/datasources/cinder/__init__.py diff --git a/vitrage/synchronizer/plugins/cinder/volume/__init__.py b/vitrage/datasources/cinder/volume/__init__.py similarity index 70% rename from vitrage/synchronizer/plugins/cinder/volume/__init__.py rename to vitrage/datasources/cinder/volume/__init__.py index e3ab2f8af..c0a14fde7 100644 --- a/vitrage/synchronizer/plugins/cinder/volume/__init__.py +++ b/vitrage/datasources/cinder/volume/__init__.py @@ -14,18 +14,18 @@ from oslo_config import cfg -CINDER_VOLUME_PLUGIN = 'cinder.volume' +CINDER_VOLUME_DATASOURCE = 'cinder.volume' OPTS = [ cfg.StrOpt('transformer', - default='vitrage.synchronizer.plugins.cinder.volume.' - 'transformer.CinderVolumeTransformer', + default='vitrage.datasources.cinder.volume.transformer.' + 'CinderVolumeTransformer', help='Nova host transformer class path', required=True), - cfg.StrOpt('synchronizer', - default='vitrage.synchronizer.plugins.cinder.volume.' - 'synchronizer.CinderVolumeSynchronizer', - help='Nova host synchronizer class path', + cfg.StrOpt('driver', + default='vitrage.datasources.cinder.volume.driver.' + 'CinderVolumeDriver', + help='Nova host driver class path', required=True), cfg.StrOpt('notification_topic', default='vitrage_notifications', diff --git a/vitrage/synchronizer/plugins/cinder/volume/synchronizer.py b/vitrage/datasources/cinder/volume/driver.py similarity index 71% rename from vitrage/synchronizer/plugins/cinder/volume/synchronizer.py rename to vitrage/datasources/cinder/volume/driver.py index dafd13887..3ca2f7c81 100644 --- a/vitrage/synchronizer/plugins/cinder/volume/synchronizer.py +++ b/vitrage/datasources/cinder/volume/driver.py @@ -17,16 +17,16 @@ from oslo_log import log as logging from vitrage import clients from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import SyncMode -from vitrage.synchronizer.plugins.cinder.volume import CINDER_VOLUME_PLUGIN -from vitrage.synchronizer.plugins.synchronizer_base import SynchronizerBase +from vitrage.datasources.cinder.volume import CINDER_VOLUME_DATASOURCE +from vitrage.datasources.driver_base import DriverBase LOG = logging.getLogger(__name__) -class CinderVolumeSynchronizer(SynchronizerBase): +class CinderVolumeDriver(DriverBase): def __init__(self, conf): - super(CinderVolumeSynchronizer, self).__init__() + super(CinderVolumeDriver, self).__init__() self.client = clients.cinder_client(conf) self.conf = conf @@ -37,16 +37,16 @@ class CinderVolumeSynchronizer(SynchronizerBase): def get_all(self, sync_mode): return self.make_pickleable( self.extract_events(self.client.volumes.list()), - CINDER_VOLUME_PLUGIN, + CINDER_VOLUME_DATASOURCE, sync_mode) @staticmethod def enrich_event(event, event_type): event[SyncProps.EVENT_TYPE] = event_type - return CinderVolumeSynchronizer.make_pickleable([event], - CINDER_VOLUME_PLUGIN, - SyncMode.UPDATE)[0] + return CinderVolumeDriver.make_pickleable([event], + CINDER_VOLUME_DATASOURCE, + SyncMode.UPDATE)[0] @staticmethod def get_event_types(conf): @@ -54,4 +54,4 @@ class CinderVolumeSynchronizer(SynchronizerBase): @staticmethod def get_topic(conf): - return conf[CINDER_VOLUME_PLUGIN].notification_topic + return conf[CINDER_VOLUME_DATASOURCE].notification_topic diff --git a/vitrage/synchronizer/plugins/cinder/volume/transformer.py b/vitrage/datasources/cinder/volume/transformer.py similarity index 87% rename from vitrage/synchronizer/plugins/cinder/volume/transformer.py rename to vitrage/datasources/cinder/volume/transformer.py index bece1df73..106f6ad6b 100644 --- a/vitrage/synchronizer/plugins/cinder/volume/transformer.py +++ b/vitrage/datasources/cinder/volume/transformer.py @@ -19,21 +19,21 @@ from vitrage.common.constants import EntityCategory from vitrage.common.constants import EventAction from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import VertexProperties as VProps +from vitrage.datasources.cinder.volume import CINDER_VOLUME_DATASOURCE +from vitrage.datasources.nova.instance import NOVA_INSTANCE_DATASOURCE +from vitrage.datasources.resource_transformer_base import \ + ResourceTransformerBase +from vitrage.datasources import transformer_base as tbase +from vitrage.datasources.transformer_base import build_key +from vitrage.datasources.transformer_base import extract_field_value +from vitrage.datasources.transformer_base import Neighbor import vitrage.graph.utils as graph_utils -from vitrage.synchronizer.plugins.base.resource.transformer import \ - BaseResourceTransformer -from vitrage.synchronizer.plugins.cinder.volume import CINDER_VOLUME_PLUGIN -from vitrage.synchronizer.plugins.nova.instance import NOVA_INSTANCE_PLUGIN -from vitrage.synchronizer.plugins import transformer_base as tbase -from vitrage.synchronizer.plugins.transformer_base import build_key -from vitrage.synchronizer.plugins.transformer_base import extract_field_value -from vitrage.synchronizer.plugins.transformer_base import Neighbor LOG = logging.getLogger(__name__) -class CinderVolumeTransformer(BaseResourceTransformer): +class CinderVolumeTransformer(ResourceTransformerBase): # Event types which need to refer them differently UPDATE_EVENT_TYPES = { @@ -85,7 +85,7 @@ class CinderVolumeTransformer(BaseResourceTransformer): entity_key, entity_id=volume_id, entity_category=EntityCategory.RESOURCE, - entity_type=CINDER_VOLUME_PLUGIN, + entity_type=CINDER_VOLUME_DATASOURCE, entity_state=volume_state, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, @@ -109,14 +109,14 @@ class CinderVolumeTransformer(BaseResourceTransformer): id_field_path = 'volume_id' if is_update_event else 'id' volume_id = extract_field_value(entity_event, id_field_path) - key_fields = self._key_values(CINDER_VOLUME_PLUGIN, volume_id) + key_fields = self._key_values(CINDER_VOLUME_DATASOURCE, volume_id) return build_key(key_fields) def _create_instance_neighbors(self, entity_event, attachments_property, instance_id_property): - transformer = self.transformers[NOVA_INSTANCE_PLUGIN] + transformer = self.transformers[NOVA_INSTANCE_DATASOURCE] if transformer: return [self._create_instance_neighbor(entity_event, @@ -140,7 +140,7 @@ class CinderVolumeTransformer(BaseResourceTransformer): properties = { VProps.ID: instance_id, - VProps.TYPE: NOVA_INSTANCE_PLUGIN, + VProps.TYPE: NOVA_INSTANCE_DATASOURCE, VProps.SAMPLE_TIMESTAMP: sample_timestamp } instance_vertex = \ diff --git a/vitrage/synchronizer/plugins/synchronizer_base.py b/vitrage/datasources/driver_base.py similarity index 99% rename from vitrage/synchronizer/plugins/synchronizer_base.py rename to vitrage/datasources/driver_base.py index 3b25fe192..aa3995e1c 100644 --- a/vitrage/synchronizer/plugins/synchronizer_base.py +++ b/vitrage/datasources/driver_base.py @@ -26,7 +26,7 @@ LOG = log.getLogger(__name__) @six.add_metaclass(abc.ABCMeta) -class SynchronizerBase(object): +class DriverBase(object): def __init__(self): pass diff --git a/vitrage/synchronizer/launcher.py b/vitrage/datasources/launcher.py similarity index 77% rename from vitrage/synchronizer/launcher.py rename to vitrage/datasources/launcher.py index e210b06fe..d10ed1003 100644 --- a/vitrage/synchronizer/launcher.py +++ b/vitrage/datasources/launcher.py @@ -18,7 +18,7 @@ import itertools from oslo_log import log from oslo_service import service as os_service from oslo_utils import importutils as utils -from vitrage.synchronizer.plugins.listener_service import ListenerService +from vitrage.datasources.listener_service import ListenerService from services import ChangesService from services import SnapshotsService @@ -39,7 +39,7 @@ class Launcher(object): def __init__(self, conf, callback): self.conf = conf self.callback = callback - self.snapshot_plugins = self._register_snapshot_plugins() + self.snapshot_datasources = self._register_snapshot_datasources() self.services = self._register_services() def launch(self): @@ -47,25 +47,25 @@ class Launcher(object): for service in self.services: launcher.launch_service(service, 1) - def _register_snapshot_plugins(self): - return {plugin: utils.import_object(self.conf[plugin].synchronizer, + def _register_snapshot_datasources(self): + return {plugin: utils.import_object(self.conf[plugin].driver, self.conf) - for plugin in self.conf.plugins.plugin_type} + for plugin in self.conf.datasources.types} def _register_services(self): return itertools.chain( (ChangesService(self.conf, - [self.snapshot_plugins[plugin]], + [self.snapshot_datasources[plugin]], self.conf[plugin].changes_interval, self.callback) - for plugin in self.conf.plugins.plugin_type + for plugin in self.conf.datasources.types if opt_exists(self.conf[plugin], CHANGES_INTERVAL)), (SnapshotsService(self.conf, - self.snapshot_plugins, + self.snapshot_datasources, self.callback),), (ListenerService(self.conf, - self.snapshot_plugins, + self.snapshot_datasources, self.callback),),) diff --git a/vitrage/synchronizer/plugins/listener_service.py b/vitrage/datasources/listener_service.py similarity index 73% rename from vitrage/synchronizer/plugins/listener_service.py rename to vitrage/datasources/listener_service.py index 46b36736d..a1c2a5997 100644 --- a/vitrage/synchronizer/plugins/listener_service.py +++ b/vitrage/datasources/listener_service.py @@ -26,34 +26,34 @@ LOG = log.getLogger(__name__) class ListenerService(os_service.Service): - def __init__(self, conf, synchronizers, callback): + def __init__(self, conf, drivers, callback): super(ListenerService, self).__init__() - # Get the topics of the synchronizers and callbacks - topics = self._get_topics_set(synchronizers, conf) + # Get the topics of the drivers and callbacks + topics = self._get_topics_set(drivers, conf) self.enrich_callbacks_by_events = \ - self._create_callbacks_by_events_dict(synchronizers, conf) - self.skipped_event_types = self._get_skipped_event_types(synchronizers) + self._create_callbacks_by_events_dict(drivers, conf) + self.skipped_event_types = self._get_skipped_event_types(drivers) self.listener = self._get_topics_listener(conf, topics, callback) def start(self): - LOG.info("Vitrage Synchronizer Listener Service - Starting...") + LOG.info("Vitrage data source Listener Service - Starting...") super(ListenerService, self).start() self.listener.start() - LOG.info("Vitrage Synchronizer Listener Service - Started!") + LOG.info("Vitrage data source Listener Service - Started!") def stop(self, graceful=False): - LOG.info("Vitrage Synchronizer Listener Service - Stopping...") + LOG.info("Vitrage data source Listener Service - Stopping...") super(ListenerService, self).stop(graceful) - LOG.info("Vitrage Synchronizer Listener Service - Stopped!") + LOG.info("Vitrage data source Listener Service - Stopped!") @staticmethod - def _get_topics_set(synchronizers, conf): - topics = {sync.get_topic(conf) for sync in synchronizers.values()} + def _get_topics_set(drivers, conf): + topics = {driver.get_topic(conf) for driver in drivers.values()} if None in topics: topics.remove(None) @@ -61,12 +61,12 @@ class ListenerService(os_service.Service): return topics @staticmethod - def _create_callbacks_by_events_dict(synchronizers, conf): + def _create_callbacks_by_events_dict(drivers, conf): ret = defaultdict(list) - for sync in synchronizers.values(): - for event in sync.get_event_types(conf): - ret[event].append(sync.enrich_event) + for driver in drivers.values(): + for event in driver.get_event_types(conf): + ret[event].append(driver.enrich_event) return ret @@ -84,10 +84,11 @@ class ListenerService(os_service.Service): self.skipped_event_types)]) @staticmethod - def _get_skipped_event_types(synchronizers): + def _get_skipped_event_types(drivers): + skipped_events = [] - for synchronizer in synchronizers.values(): - skipped_events += synchronizer.get_skipped_event_types() + for driver in drivers.values(): + skipped_events += driver.get_skipped_event_types() return set(skipped_events) @@ -104,8 +105,7 @@ class NotificationsEndpoint(object): def info(self, ctxt, publisher_id, event_type, payload, metadata): # TODO(Alexey): improve skipped implementation because we need to skip - # event depending on the synchronizer and not for all - # synchronizers + # event depending on the drivers and not for all drivers if event_type in self.skipped_event_types: LOG.info('EVENT SKIPPED: ' + str(event_type)) return diff --git a/vitrage/synchronizer/plugins/nagios/__init__.py b/vitrage/datasources/nagios/__init__.py similarity index 74% rename from vitrage/synchronizer/plugins/nagios/__init__.py rename to vitrage/datasources/nagios/__init__.py index 01dda52e9..064fb6a16 100644 --- a/vitrage/synchronizer/plugins/nagios/__init__.py +++ b/vitrage/datasources/nagios/__init__.py @@ -14,23 +14,22 @@ from oslo_config import cfg -NAGIOS_PLUGIN = 'nagios' +NAGIOS_DATASOURCE = 'nagios' OPTS = [ cfg.StrOpt('transformer', - default='vitrage.synchronizer.plugins.nagios.' - 'transformer.NagiosTransformer', - help='Nagios plugin transformer class path', + default='vitrage.datasources.nagios.transformer.' + 'NagiosTransformer', + help='Nagios transformer class path', required=True), - cfg.StrOpt('synchronizer', - default='vitrage.synchronizer.plugins.nagios.synchronizer' - '.NagiosSynchronizer', - help='Nagios plugin synchronizer class path', + cfg.StrOpt('driver', + default='vitrage.datasources.nagios.driver.NagiosDriver', + help='Nagios driver class path', required=True), cfg.IntOpt('changes_interval', default=30, min=30, - help='interval between checking changes in nagios plugin', + help='interval between checking changes in nagios data source', required=True), cfg.StrOpt('user', default='nagiosadmin', help='Nagios user name'), diff --git a/vitrage/synchronizer/plugins/nagios/config.py b/vitrage/datasources/nagios/config.py similarity index 100% rename from vitrage/synchronizer/plugins/nagios/config.py rename to vitrage/datasources/nagios/config.py diff --git a/vitrage/synchronizer/plugins/nagios/synchronizer.py b/vitrage/datasources/nagios/driver.py similarity index 85% rename from vitrage/synchronizer/plugins/nagios/synchronizer.py rename to vitrage/datasources/nagios/driver.py index 8513ad706..af7088e8f 100644 --- a/vitrage/synchronizer/plugins/nagios/synchronizer.py +++ b/vitrage/datasources/nagios/driver.py @@ -18,32 +18,31 @@ from oslo_log import log import requests from vitrage.common.constants import SynchronizerProperties as SyncProps +from vitrage.datasources.alarm_driver_base import AlarmDriverBase +from vitrage.datasources.nagios.config import NagiosConfig +from vitrage.datasources.nagios import NAGIOS_DATASOURCE +from vitrage.datasources.nagios.parser import NagiosParser +from vitrage.datasources.nagios.properties import NagiosProperties\ + as NagiosProps +from vitrage.datasources.nagios.properties import NagiosStatus # noinspection PyProtectedMember from vitrage.i18n import _LE # noinspection PyProtectedMember from vitrage.i18n import _LW -from vitrage.synchronizer.plugins.base.alarm.synchronizer \ - import BaseAlarmSynchronizer -from vitrage.synchronizer.plugins.nagios.config import NagiosConfig -from vitrage.synchronizer.plugins.nagios import NAGIOS_PLUGIN -from vitrage.synchronizer.plugins.nagios.parser import NagiosParser -from vitrage.synchronizer.plugins.nagios.properties import NagiosProperties \ - as NagiosProps -from vitrage.synchronizer.plugins.nagios.properties import NagiosStatus LOG = log.getLogger(__name__) -class NagiosSynchronizer(BaseAlarmSynchronizer): +class NagiosDriver(AlarmDriverBase): ServiceKey = namedtuple('ServiceKey', ['host_name', 'service']) def __init__(self, conf): - super(NagiosSynchronizer, self).__init__() + super(NagiosDriver, self).__init__() self.conf = conf self.config = NagiosConfig(conf) def _sync_type(self): - return NAGIOS_PLUGIN + return NAGIOS_DATASOURCE def _alarm_key(self, alarm): return self.ServiceKey(host_name=alarm[NagiosProps.RESOURCE_NAME], diff --git a/vitrage/synchronizer/plugins/nagios/parser.py b/vitrage/datasources/nagios/parser.py similarity index 98% rename from vitrage/synchronizer/plugins/nagios/parser.py rename to vitrage/datasources/nagios/parser.py index e616739bd..d666b9dd1 100644 --- a/vitrage/synchronizer/plugins/nagios/parser.py +++ b/vitrage/datasources/nagios/parser.py @@ -14,8 +14,9 @@ from lxml import etree from oslo_log import log + from six.moves import StringIO -from vitrage.synchronizer.plugins.nagios.properties import NagiosProperties +from vitrage.datasources.nagios.properties import NagiosProperties LOG = log.getLogger(__name__) diff --git a/vitrage/synchronizer/plugins/nagios/properties.py b/vitrage/datasources/nagios/properties.py similarity index 100% rename from vitrage/synchronizer/plugins/nagios/properties.py rename to vitrage/datasources/nagios/properties.py diff --git a/vitrage/synchronizer/plugins/nagios/transformer.py b/vitrage/datasources/nagios/transformer.py similarity index 86% rename from vitrage/synchronizer/plugins/nagios/transformer.py rename to vitrage/datasources/nagios/transformer.py index 4a6da6196..8c7cf6e78 100644 --- a/vitrage/synchronizer/plugins/nagios/transformer.py +++ b/vitrage/datasources/nagios/transformer.py @@ -19,22 +19,20 @@ from vitrage.common.constants import EntityCategory from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import VertexProperties as VProps from vitrage.common import datetime_utils +from vitrage.datasources.alarm_properties import AlarmProperties as AlarmProps +from vitrage.datasources.alarm_transformer_base import AlarmTransformerBase +from vitrage.datasources.nagios.properties import NagiosProperties +from vitrage.datasources.nagios.properties import NagiosStatus +from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE +from vitrage.datasources.static_physical import SWITCH +from vitrage.datasources import transformer_base as tbase +from vitrage.datasources.transformer_base import Neighbor import vitrage.graph.utils as graph_utils -from vitrage.synchronizer.plugins.base.alarm.properties \ - import AlarmProperties as AlarmProps -from vitrage.synchronizer.plugins.base.alarm.transformer \ - import BaseAlarmTransformer -from vitrage.synchronizer.plugins.nagios.properties import NagiosProperties -from vitrage.synchronizer.plugins.nagios.properties import NagiosStatus -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.static_physical import SWITCH -from vitrage.synchronizer.plugins import transformer_base as tbase -from vitrage.synchronizer.plugins.transformer_base import Neighbor LOG = logging.getLogger(__name__) -class NagiosTransformer(BaseAlarmTransformer): +class NagiosTransformer(AlarmTransformerBase): STATUS_OK = 'OK' @@ -87,7 +85,7 @@ class NagiosTransformer(BaseAlarmTransformer): tbase.TIMESTAMP_FORMAT) resource_type = entity_event[NagiosProperties.RESOURCE_TYPE] - if resource_type == NOVA_HOST_PLUGIN or resource_type == SWITCH: + if resource_type == NOVA_HOST_DATASOURCE or resource_type == SWITCH: return [self._create_neighbor( vitrage_id, timestamp, diff --git a/vitrage/synchronizer/plugins/neutron/__init__.py b/vitrage/datasources/neutron/__init__.py similarity index 100% rename from vitrage/synchronizer/plugins/neutron/__init__.py rename to vitrage/datasources/neutron/__init__.py diff --git a/vitrage/synchronizer/plugins/neutron/base.py b/vitrage/datasources/neutron/base.py similarity index 87% rename from vitrage/synchronizer/plugins/neutron/base.py rename to vitrage/datasources/neutron/base.py index a2ccf0cb2..248e4f92e 100644 --- a/vitrage/synchronizer/plugins/neutron/base.py +++ b/vitrage/datasources/neutron/base.py @@ -14,10 +14,10 @@ from vitrage import clients -from vitrage.synchronizer.plugins.synchronizer_base import SynchronizerBase +from vitrage.datasources.driver_base import DriverBase -class NeutronBase(SynchronizerBase): +class NeutronBase(DriverBase): def __init__(self, conf): super(NeutronBase, self).__init__() self.client = clients.neutron_client(conf) diff --git a/vitrage/synchronizer/plugins/neutron/network/__init__.py b/vitrage/datasources/neutron/network/__init__.py similarity index 66% rename from vitrage/synchronizer/plugins/neutron/network/__init__.py rename to vitrage/datasources/neutron/network/__init__.py index 0982d8cc5..b7f86ce07 100644 --- a/vitrage/synchronizer/plugins/neutron/network/__init__.py +++ b/vitrage/datasources/neutron/network/__init__.py @@ -14,17 +14,17 @@ from oslo_config import cfg -NEUTRON_NETWORK_PLUGIN = 'neutron.network' +NEUTRON_NETWORK_DATASOURCE = 'neutron.network' OPTS = [ cfg.StrOpt('transformer', - default='vitrage.synchronizer.plugins.neutron.network.' - 'transformer.NetworkTransformer', + default='vitrage.datasources.neutron.network.transformer.' + 'NetworkTransformer', help='Neutron network transformer class path', required=True), - cfg.StrOpt('synchronizer', - default='vitrage.synchronizer.plugins.neutron.network.' - 'synchronizer.NetworkSynchronizer', - help='Neutron network synchronizer class path', + cfg.StrOpt('driver', + default='vitrage.datasources.neutron.network.driver.' + 'NetworkDriver', + help='Neutron network driver class path', required=True), ] diff --git a/vitrage/synchronizer/plugins/neutron/network/synchronizer.py b/vitrage/datasources/neutron/network/driver.py similarity index 81% rename from vitrage/synchronizer/plugins/neutron/network/synchronizer.py rename to vitrage/datasources/neutron/network/driver.py index c7d39792e..0f20035b3 100644 --- a/vitrage/synchronizer/plugins/neutron/network/synchronizer.py +++ b/vitrage/datasources/neutron/network/driver.py @@ -12,11 +12,11 @@ # License for the specific language governing permissions and limitations # under the License. -from vitrage.synchronizer.plugins.neutron.base import NeutronBase -from vitrage.synchronizer.plugins.neutron.network import NEUTRON_NETWORK_PLUGIN +from vitrage.datasources.neutron.base import NeutronBase +from vitrage.datasources.neutron.network import NEUTRON_NETWORK_DATASOURCE -class NetworkSynchronizer(NeutronBase): +class NetworkDriver(NeutronBase): @staticmethod def get_skipped_event_types(): @@ -37,5 +37,5 @@ class NetworkSynchronizer(NeutronBase): def get_all(self, sync_mode): return self.make_pickleable( self.client.list_networks()['networks'], - NEUTRON_NETWORK_PLUGIN, + NEUTRON_NETWORK_DATASOURCE, sync_mode) diff --git a/vitrage/synchronizer/plugins/neutron/network/transformer.py b/vitrage/datasources/neutron/network/transformer.py similarity index 84% rename from vitrage/synchronizer/plugins/neutron/network/transformer.py rename to vitrage/datasources/neutron/network/transformer.py index ed2b9e803..857641857 100644 --- a/vitrage/synchronizer/plugins/neutron/network/transformer.py +++ b/vitrage/datasources/neutron/network/transformer.py @@ -15,16 +15,15 @@ from vitrage.common.constants import EntityCategory from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import VertexProperties as VProps -from vitrage.synchronizer.plugins.base.resource.transformer import \ - BaseResourceTransformer -from vitrage.synchronizer.plugins.neutron.network import NEUTRON_NETWORK_PLUGIN -from vitrage.synchronizer.plugins import transformer_base as tbase -from vitrage.synchronizer.plugins.transformer_base import extract_field_value - +from vitrage.datasources.neutron.network import NEUTRON_NETWORK_DATASOURCE +from vitrage.datasources.resource_transformer_base import \ + ResourceTransformerBase +from vitrage.datasources import transformer_base as tbase +from vitrage.datasources.transformer_base import extract_field_value import vitrage.graph.utils as graph_utils -class NetworkTransformer(BaseResourceTransformer): +class NetworkTransformer(ResourceTransformerBase): UPDATE_EVENT_TYPES = {} @@ -34,7 +33,7 @@ class NetworkTransformer(BaseResourceTransformer): def _create_entity_key(self, entity_event): network_id = 'network_id' if tbase.is_update_event(entity_event) \ else 'id' - key_fields = self._key_values(NEUTRON_NETWORK_PLUGIN, + key_fields = self._key_values(NEUTRON_NETWORK_DATASOURCE, extract_field_value(entity_event, network_id)) return tbase.build_key(key_fields) @@ -64,7 +63,7 @@ class NetworkTransformer(BaseResourceTransformer): self._create_entity_key(entity_event), entity_id=entity_id, entity_category=EntityCategory.RESOURCE, - entity_type=NEUTRON_NETWORK_PLUGIN, + entity_type=NEUTRON_NETWORK_DATASOURCE, entity_state=state, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, diff --git a/vitrage/synchronizer/plugins/neutron/port/__init__.py b/vitrage/datasources/neutron/port/__init__.py similarity index 71% rename from vitrage/synchronizer/plugins/neutron/port/__init__.py rename to vitrage/datasources/neutron/port/__init__.py index 0d67681c4..d18158c8c 100644 --- a/vitrage/synchronizer/plugins/neutron/port/__init__.py +++ b/vitrage/datasources/neutron/port/__init__.py @@ -14,17 +14,16 @@ from oslo_config import cfg -NEUTRON_PORT_PLUGIN = 'neutron.port' +NEUTRON_PORT_DATASOURCE = 'neutron.port' OPTS = [ cfg.StrOpt('transformer', - default='vitrage.synchronizer.plugins.neutron.port.' + default='vitrage.datasources.neutron.port.' 'transformer.PortTransformer', help='Neutron port transformer class path', required=True), - cfg.StrOpt('synchronizer', - default='vitrage.synchronizer.plugins.neutron.port.' - 'synchronizer.PortSynchronizer', - help='Neutron port synchronizer class path', + cfg.StrOpt('driver', + default='vitrage.datasources.neutron.port.driver.PortDriver', + help='Neutron port driver class path', required=True), ] diff --git a/vitrage/synchronizer/plugins/neutron/port/synchronizer.py b/vitrage/datasources/neutron/port/driver.py similarity index 82% rename from vitrage/synchronizer/plugins/neutron/port/synchronizer.py rename to vitrage/datasources/neutron/port/driver.py index 76483683e..3208000b4 100644 --- a/vitrage/synchronizer/plugins/neutron/port/synchronizer.py +++ b/vitrage/datasources/neutron/port/driver.py @@ -12,11 +12,11 @@ # License for the specific language governing permissions and limitations # under the License. -from vitrage.synchronizer.plugins.neutron.base import NeutronBase -from vitrage.synchronizer.plugins.neutron.port import NEUTRON_PORT_PLUGIN +from vitrage.datasources.neutron.base import NeutronBase +from vitrage.datasources.neutron.port import NEUTRON_PORT_DATASOURCE -class PortSynchronizer(NeutronBase): +class PortDriver(NeutronBase): @staticmethod def get_skipped_event_types(): @@ -37,5 +37,5 @@ class PortSynchronizer(NeutronBase): def get_all(self, sync_mode): return self.make_pickleable( self.client.list_ports()['ports'], - NEUTRON_PORT_PLUGIN, + NEUTRON_PORT_DATASOURCE, sync_mode) diff --git a/vitrage/synchronizer/plugins/neutron/port/transformer.py b/vitrage/datasources/neutron/port/transformer.py similarity index 87% rename from vitrage/synchronizer/plugins/neutron/port/transformer.py rename to vitrage/datasources/neutron/port/transformer.py index 9bc891f8d..e3c83bf97 100644 --- a/vitrage/synchronizer/plugins/neutron/port/transformer.py +++ b/vitrage/datasources/neutron/port/transformer.py @@ -11,6 +11,8 @@ # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. +from vitrage.datasources.resource_transformer_base import \ + ResourceTransformerBase from oslo_log import log as logging @@ -18,28 +20,26 @@ from vitrage.common.constants import EdgeLabels from vitrage.common.constants import EntityCategory from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import VertexProperties as VProps -from vitrage.synchronizer.plugins.base.resource.transformer import \ - BaseResourceTransformer -from vitrage.synchronizer.plugins.neutron.network import NEUTRON_NETWORK_PLUGIN -from vitrage.synchronizer.plugins.neutron.port import NEUTRON_PORT_PLUGIN -from vitrage.synchronizer.plugins.nova.instance import NOVA_INSTANCE_PLUGIN -from vitrage.synchronizer.plugins import transformer_base as tbase -from vitrage.synchronizer.plugins.transformer_base import extract_field_value -from vitrage.synchronizer.plugins.transformer_base import Neighbor +from vitrage.datasources.neutron.network import NEUTRON_NETWORK_DATASOURCE +from vitrage.datasources.neutron.port import NEUTRON_PORT_DATASOURCE +from vitrage.datasources.nova.instance import NOVA_INSTANCE_DATASOURCE +from vitrage.datasources import transformer_base as tbase +from vitrage.datasources.transformer_base import extract_field_value +from vitrage.datasources.transformer_base import Neighbor import vitrage.graph.utils as graph_utils LOG = logging.getLogger(__name__) -class PortTransformer(BaseResourceTransformer): +class PortTransformer(ResourceTransformerBase): def __init__(self, transformers): super(PortTransformer, self).__init__(transformers) def _create_entity_key(self, entity_event): port_id = 'port_id' if tbase.is_update_event(entity_event) \ else 'id' - key_fields = self._key_values(NEUTRON_PORT_PLUGIN, + key_fields = self._key_values(NEUTRON_PORT_DATASOURCE, extract_field_value(entity_event, port_id)) return tbase.build_key(key_fields) @@ -70,7 +70,7 @@ class PortTransformer(BaseResourceTransformer): self._create_entity_key(entity_event), entity_id=entity_id, entity_category=EntityCategory.RESOURCE, - entity_type=NEUTRON_PORT_PLUGIN, + entity_type=NEUTRON_PORT_DATASOURCE, entity_state=state, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, @@ -122,7 +122,7 @@ class PortTransformer(BaseResourceTransformer): properties = { VProps.ID: instance_id, - VProps.TYPE: NOVA_INSTANCE_PLUGIN, + VProps.TYPE: NOVA_INSTANCE_DATASOURCE, VProps.SAMPLE_TIMESTAMP: sample_timestamp } instance_vertex = self.create_placeholder_vertex(**properties) @@ -143,7 +143,7 @@ class PortTransformer(BaseResourceTransformer): properties = { VProps.ID: net_id, - VProps.TYPE: NEUTRON_NETWORK_PLUGIN, + VProps.TYPE: NEUTRON_NETWORK_DATASOURCE, VProps.SAMPLE_TIMESTAMP: sample_timestamp } diff --git a/vitrage/datasources/nova/__init__.py b/vitrage/datasources/nova/__init__.py new file mode 100644 index 000000000..6a20380a1 --- /dev/null +++ b/vitrage/datasources/nova/__init__.py @@ -0,0 +1 @@ +__author__ = 'stack' diff --git a/vitrage/synchronizer/plugins/nova/host/__init__.py b/vitrage/datasources/nova/host/__init__.py similarity index 72% rename from vitrage/synchronizer/plugins/nova/host/__init__.py rename to vitrage/datasources/nova/host/__init__.py index fae366de5..fb498ab00 100644 --- a/vitrage/synchronizer/plugins/nova/host/__init__.py +++ b/vitrage/datasources/nova/host/__init__.py @@ -14,17 +14,16 @@ from oslo_config import cfg -NOVA_HOST_PLUGIN = 'nova.host' +NOVA_HOST_DATASOURCE = 'nova.host' OPTS = [ cfg.StrOpt('transformer', - default='vitrage.synchronizer.plugins.nova.host.' + default='vitrage.datasources.nova.host.' 'transformer.HostTransformer', help='Nova host transformer class path', required=True), - cfg.StrOpt('synchronizer', - default='vitrage.synchronizer.plugins.nova.host.synchronizer' - '.HostSynchronizer', - help='Nova host synchronizer class path', + cfg.StrOpt('driver', + default='vitrage.datasources.nova.host.driver.HostDriver', + help='Nova host driver class path', required=True), ] diff --git a/vitrage/synchronizer/plugins/nova/host/synchronizer.py b/vitrage/datasources/nova/host/driver.py similarity index 84% rename from vitrage/synchronizer/plugins/nova/host/synchronizer.py rename to vitrage/datasources/nova/host/driver.py index 96142a857..b74f92dfe 100644 --- a/vitrage/synchronizer/plugins/nova/host/synchronizer.py +++ b/vitrage/datasources/nova/host/driver.py @@ -12,11 +12,11 @@ # License for the specific language governing permissions and limitations # under the License. -from vitrage.synchronizer.plugins.nova.base import NovaBase -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN +from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE +from vitrage.datasources.nova.nova_driver_base import NovaDriverBase -class HostSynchronizer(NovaBase): +class HostDriver(NovaDriverBase): @staticmethod def filter_none_compute_hosts(entities): @@ -30,6 +30,6 @@ class HostSynchronizer(NovaBase): def get_all(self, sync_mode): return self.make_pickleable( self.filter_none_compute_hosts(self.client.hosts.list()), - NOVA_HOST_PLUGIN, + NOVA_HOST_DATASOURCE, sync_mode, 'manager') diff --git a/vitrage/synchronizer/plugins/nova/host/transformer.py b/vitrage/datasources/nova/host/transformer.py similarity index 83% rename from vitrage/synchronizer/plugins/nova/host/transformer.py rename to vitrage/datasources/nova/host/transformer.py index 741aca012..6c30e0ecc 100644 --- a/vitrage/synchronizer/plugins/nova/host/transformer.py +++ b/vitrage/datasources/nova/host/transformer.py @@ -18,20 +18,20 @@ from vitrage.common.constants import EdgeLabels from vitrage.common.constants import EntityCategory from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import VertexProperties as VProps +from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE +from vitrage.datasources.nova.zone import NOVA_ZONE_DATASOURCE +from vitrage.datasources.resource_transformer_base import \ + ResourceTransformerBase +from vitrage.datasources import transformer_base +from vitrage.datasources.transformer_base import extract_field_value +from vitrage.datasources.transformer_base import Neighbor import vitrage.graph.utils as graph_utils -from vitrage.synchronizer.plugins.base.resource.transformer import \ - BaseResourceTransformer -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.nova.zone import NOVA_ZONE_PLUGIN -from vitrage.synchronizer.plugins import transformer_base -from vitrage.synchronizer.plugins.transformer_base import extract_field_value -from vitrage.synchronizer.plugins.transformer_base import Neighbor LOG = logging.getLogger(__name__) -class HostTransformer(BaseResourceTransformer): +class HostTransformer(ResourceTransformerBase): def __init__(self, transformers): super(HostTransformer, self).__init__(transformers) @@ -57,7 +57,7 @@ class HostTransformer(BaseResourceTransformer): entity_key, entity_id=host_name, entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_HOST_PLUGIN, + entity_type=NOVA_HOST_DATASOURCE, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata) @@ -84,7 +84,7 @@ class HostTransformer(BaseResourceTransformer): host_vertex_id, zone_name_path): - zone_transformer = self.transformers[NOVA_ZONE_PLUGIN] + zone_transformer = self.transformers[NOVA_ZONE_DATASOURCE] if zone_transformer: @@ -92,7 +92,7 @@ class HostTransformer(BaseResourceTransformer): properties = { VProps.ID: zone_name, - VProps.TYPE: NOVA_ZONE_PLUGIN, + VProps.TYPE: NOVA_ZONE_DATASOURCE, VProps.SAMPLE_TIMESTAMP: sample_timestamp } zone_neighbor = zone_transformer.create_placeholder_vertex( @@ -112,5 +112,5 @@ class HostTransformer(BaseResourceTransformer): host_name = extract_field_value(entity_event, '_info', 'host_name') - key_fields = self._key_values(NOVA_HOST_PLUGIN, host_name) + key_fields = self._key_values(NOVA_HOST_DATASOURCE, host_name) return transformer_base.build_key(key_fields) diff --git a/vitrage/synchronizer/plugins/nova/instance/__init__.py b/vitrage/datasources/nova/instance/__init__.py similarity index 70% rename from vitrage/synchronizer/plugins/nova/instance/__init__.py rename to vitrage/datasources/nova/instance/__init__.py index ce200d02c..dfaa517c5 100644 --- a/vitrage/synchronizer/plugins/nova/instance/__init__.py +++ b/vitrage/datasources/nova/instance/__init__.py @@ -14,18 +14,18 @@ from oslo_config import cfg -NOVA_INSTANCE_PLUGIN = 'nova.instance' +NOVA_INSTANCE_DATASOURCE = 'nova.instance' OPTS = [ cfg.StrOpt('transformer', - default='vitrage.synchronizer.plugins.nova.instance.' - 'transformer.InstanceTransformer', + default='vitrage.datasources.nova.instance.transformer.' + 'InstanceTransformer', help='Nova instance transformer class path', required=True), - cfg.StrOpt('synchronizer', - default='vitrage.synchronizer.plugins.nova.instance.' - 'synchronizer.InstanceSynchronizer', - help='Nova instance synchronizer class path', + cfg.StrOpt('driver', + default='vitrage.datasources.nova.instance.driver.' + 'InstanceDriver', + help='Nova instance driver class path', required=True), cfg.StrOpt('notification_topic', default='vitrage_notifications', diff --git a/vitrage/synchronizer/plugins/nova/instance/synchronizer.py b/vitrage/datasources/nova/instance/driver.py similarity index 75% rename from vitrage/synchronizer/plugins/nova/instance/synchronizer.py rename to vitrage/datasources/nova/instance/driver.py index 4b686b182..b18f41fca 100644 --- a/vitrage/synchronizer/plugins/nova/instance/synchronizer.py +++ b/vitrage/datasources/nova/instance/driver.py @@ -16,13 +16,13 @@ from oslo_log import log as logging from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import SyncMode -from vitrage.synchronizer.plugins.nova.base import NovaBase -from vitrage.synchronizer.plugins.nova.instance import NOVA_INSTANCE_PLUGIN +from vitrage.datasources.nova.instance import NOVA_INSTANCE_DATASOURCE +from vitrage.datasources.nova.nova_driver_base import NovaDriverBase LOG = logging.getLogger(__name__) -class InstanceSynchronizer(NovaBase): +class InstanceDriver(NovaDriverBase): @staticmethod def extract_events(instances): @@ -31,7 +31,7 @@ class InstanceSynchronizer(NovaBase): def get_all(self, sync_mode): return self.make_pickleable( self.extract_events(self.client.servers.list()), - NOVA_INSTANCE_PLUGIN, + NOVA_INSTANCE_DATASOURCE, sync_mode, 'manager') @@ -39,9 +39,9 @@ class InstanceSynchronizer(NovaBase): def enrich_event(event, event_type): event[SyncProps.EVENT_TYPE] = event_type - return InstanceSynchronizer.make_pickleable([event], - NOVA_INSTANCE_PLUGIN, - SyncMode.UPDATE)[0] + return InstanceDriver.make_pickleable([event], + NOVA_INSTANCE_DATASOURCE, + SyncMode.UPDATE)[0] @staticmethod def get_event_types(conf): @@ -53,4 +53,4 @@ class InstanceSynchronizer(NovaBase): @staticmethod def get_topic(conf): - return conf[NOVA_INSTANCE_PLUGIN].notification_topic + return conf[NOVA_INSTANCE_DATASOURCE].notification_topic diff --git a/vitrage/synchronizer/plugins/nova/instance/transformer.py b/vitrage/datasources/nova/instance/transformer.py similarity index 85% rename from vitrage/synchronizer/plugins/nova/instance/transformer.py rename to vitrage/datasources/nova/instance/transformer.py index 5ae17cce4..e030c3e49 100644 --- a/vitrage/synchronizer/plugins/nova/instance/transformer.py +++ b/vitrage/datasources/nova/instance/transformer.py @@ -19,19 +19,20 @@ from vitrage.common.constants import EntityCategory from vitrage.common.constants import EventAction from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import VertexProperties as VProps +from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE +from vitrage.datasources.nova.instance import NOVA_INSTANCE_DATASOURCE +from vitrage.datasources.resource_transformer_base import \ + ResourceTransformerBase +from vitrage.datasources import transformer_base as tbase +from vitrage.datasources.transformer_base import extract_field_value +from vitrage.datasources.transformer_base import Neighbor import vitrage.graph.utils as graph_utils -from vitrage.synchronizer.plugins.base.resource.transformer import \ - BaseResourceTransformer -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.nova.instance import NOVA_INSTANCE_PLUGIN -from vitrage.synchronizer.plugins import transformer_base as tbase -from vitrage.synchronizer.plugins.transformer_base import extract_field_value -from vitrage.synchronizer.plugins.transformer_base import Neighbor + LOG = logging.getLogger(__name__) -class InstanceTransformer(BaseResourceTransformer): +class InstanceTransformer(ResourceTransformerBase): # Event types which need to refer them differently UPDATE_EVENT_TYPES = { @@ -78,7 +79,7 @@ class InstanceTransformer(BaseResourceTransformer): self._create_entity_key(entity_event), entity_id=entity_id, entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_INSTANCE_PLUGIN, + entity_type=NOVA_INSTANCE_DATASOURCE, entity_state=state, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, @@ -87,7 +88,7 @@ class InstanceTransformer(BaseResourceTransformer): def _create_neighbors(self, entity_event): neighbors = [] - host_transformer = self.transformers[NOVA_HOST_PLUGIN] + host_transformer = self.transformers[NOVA_HOST_DATASOURCE] host_name = 'host' if tbase.is_update_event(entity_event) \ else 'OS-EXT-SRV-ATTR:host' @@ -107,7 +108,7 @@ class InstanceTransformer(BaseResourceTransformer): def _create_entity_key(self, event): instance_id = 'instance_id' if tbase.is_update_event(event) else 'id' - key_fields = self._key_values(NOVA_INSTANCE_PLUGIN, + key_fields = self._key_values(NOVA_INSTANCE_DATASOURCE, extract_field_value(event, instance_id)) return tbase.build_key(key_fields) @@ -119,7 +120,7 @@ class InstanceTransformer(BaseResourceTransformer): host_transformer): properties = { VProps.ID: host_name, - VProps.TYPE: NOVA_HOST_PLUGIN, + VProps.TYPE: NOVA_HOST_DATASOURCE, VProps.SAMPLE_TIMESTAMP: sample_timestamp } host_vertex = host_transformer.create_placeholder_vertex(**properties) diff --git a/vitrage/synchronizer/plugins/nova/base.py b/vitrage/datasources/nova/nova_driver_base.py similarity index 83% rename from vitrage/synchronizer/plugins/nova/base.py rename to vitrage/datasources/nova/nova_driver_base.py index 789a75978..e1f80ff0a 100644 --- a/vitrage/synchronizer/plugins/nova/base.py +++ b/vitrage/datasources/nova/nova_driver_base.py @@ -14,12 +14,12 @@ from vitrage import clients -from vitrage.synchronizer.plugins.synchronizer_base import SynchronizerBase +from vitrage.datasources.driver_base import DriverBase -class NovaBase(SynchronizerBase): +class NovaDriverBase(DriverBase): def __init__(self, conf): - super(NovaBase, self).__init__() + super(NovaDriverBase, self).__init__() self.client = clients.nova_client(conf) self.conf = conf diff --git a/vitrage/synchronizer/plugins/nova/zone/__init__.py b/vitrage/datasources/nova/zone/__init__.py similarity index 73% rename from vitrage/synchronizer/plugins/nova/zone/__init__.py rename to vitrage/datasources/nova/zone/__init__.py index 1c1532156..7fa01b05c 100644 --- a/vitrage/synchronizer/plugins/nova/zone/__init__.py +++ b/vitrage/datasources/nova/zone/__init__.py @@ -14,17 +14,17 @@ from oslo_config import cfg -NOVA_ZONE_PLUGIN = 'nova.zone' +NOVA_ZONE_DATASOURCE = 'nova.zone' OPTS = [ cfg.StrOpt('transformer', - default='vitrage.synchronizer.plugins.nova.zone.' - 'transformer.ZoneTransformer', + default='vitrage.datasources.nova.zone.transformer.' + 'ZoneTransformer', help='Nova zone transformer class path', required=True), - cfg.StrOpt('synchronizer', - default='vitrage.synchronizer.plugins.nova.zone.synchronizer' - '.ZoneSynchronizer', + cfg.StrOpt('driver', + default='vitrage.datasources.nova.zone.driver' + '.ZoneDriver', help='Nova zone synchronizer class path', required=True), ] diff --git a/vitrage/synchronizer/plugins/nova/zone/synchronizer.py b/vitrage/datasources/nova/zone/driver.py similarity index 84% rename from vitrage/synchronizer/plugins/nova/zone/synchronizer.py rename to vitrage/datasources/nova/zone/driver.py index 2e553abed..30eea9475 100644 --- a/vitrage/synchronizer/plugins/nova/zone/synchronizer.py +++ b/vitrage/datasources/nova/zone/driver.py @@ -10,13 +10,13 @@ # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations + # under the License. - -from vitrage.synchronizer.plugins.nova.base import NovaBase -from vitrage.synchronizer.plugins.nova.zone import NOVA_ZONE_PLUGIN +from vitrage.datasources.nova.nova_driver_base import NovaDriverBase +from vitrage.datasources.nova.zone import NOVA_ZONE_DATASOURCE -class ZoneSynchronizer(NovaBase): +class ZoneDriver(NovaDriverBase): @staticmethod def filter_internal_zone(zones): @@ -30,6 +30,6 @@ class ZoneSynchronizer(NovaBase): def get_all(self, sync_mode): return self.make_pickleable(self.filter_internal_zone( self.client.availability_zones.list()), - NOVA_ZONE_PLUGIN, + NOVA_ZONE_DATASOURCE, sync_mode, 'manager') diff --git a/vitrage/synchronizer/plugins/nova/zone/transformer.py b/vitrage/datasources/nova/zone/transformer.py similarity index 87% rename from vitrage/synchronizer/plugins/nova/zone/transformer.py rename to vitrage/datasources/nova/zone/transformer.py index bb222f02c..00bf9806d 100644 --- a/vitrage/synchronizer/plugins/nova/zone/transformer.py +++ b/vitrage/datasources/nova/zone/transformer.py @@ -18,19 +18,19 @@ from vitrage.common.constants import EdgeLabels from vitrage.common.constants import EntityCategory from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import VertexProperties as VProps +from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE +from vitrage.datasources.nova.zone import NOVA_ZONE_DATASOURCE +from vitrage.datasources.resource_transformer_base import \ + ResourceTransformerBase +from vitrage.datasources import transformer_base as tbase +from vitrage.datasources.transformer_base import extract_field_value import vitrage.graph.utils as graph_utils -from vitrage.synchronizer.plugins.base.resource.transformer import \ - BaseResourceTransformer -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.nova.zone import NOVA_ZONE_PLUGIN -from vitrage.synchronizer.plugins import transformer_base as tbase -from vitrage.synchronizer.plugins.transformer_base import extract_field_value LOG = logging.getLogger(__name__) -class ZoneTransformer(BaseResourceTransformer): +class ZoneTransformer(ResourceTransformerBase): STATE_AVAILABLE = 'available' STATE_UNAVAILABLE = 'unavailable' @@ -67,7 +67,7 @@ class ZoneTransformer(BaseResourceTransformer): entity_key, entity_id=zone_name, entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_ZONE_PLUGIN, + entity_type=NOVA_ZONE_DATASOURCE, entity_state=state, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, @@ -78,7 +78,7 @@ class ZoneTransformer(BaseResourceTransformer): zone_vertex_id = self._create_entity_key(entity_event) neighbors = [self._create_node_neighbor(zone_vertex_id)] hosts = extract_field_value(entity_event, 'hosts') - host_transformer = self.transformers[NOVA_HOST_PLUGIN] + host_transformer = self.transformers[NOVA_HOST_DATASOURCE] if host_transformer: for hostname, host_data in hosts.items(): @@ -120,12 +120,12 @@ class ZoneTransformer(BaseResourceTransformer): def _create_host_neighbor(self, zone_id, host_name, host_state, sample_timestamp): - host_transformer = self.transformers[NOVA_HOST_PLUGIN] + host_transformer = self.transformers[NOVA_HOST_DATASOURCE] properties = { VProps.ID: host_name, VProps.SAMPLE_TIMESTAMP: sample_timestamp, - VProps.TYPE: NOVA_HOST_PLUGIN + VProps.TYPE: NOVA_HOST_DATASOURCE } host_neighbor = \ host_transformer.create_placeholder_vertex(**properties) @@ -143,5 +143,5 @@ class ZoneTransformer(BaseResourceTransformer): zone_name = extract_field_value(entity_event, 'zoneName') - key_fields = self._key_values(NOVA_ZONE_PLUGIN, zone_name) + key_fields = self._key_values(NOVA_ZONE_DATASOURCE, zone_name) return tbase.build_key(key_fields) diff --git a/vitrage/synchronizer/plugins/base/resource/transformer.py b/vitrage/datasources/resource_transformer_base.py similarity index 88% rename from vitrage/synchronizer/plugins/base/resource/transformer.py rename to vitrage/datasources/resource_transformer_base.py index 5075e2c50..a99b4f82d 100644 --- a/vitrage/synchronizer/plugins/base/resource/transformer.py +++ b/vitrage/datasources/resource_transformer_base.py @@ -16,15 +16,14 @@ from oslo_log import log as logging from vitrage.common.constants import EntityCategory from vitrage.common.constants import VertexProperties as VProps +from vitrage.datasources import transformer_base as tbase import vitrage.graph.utils as graph_utils -from vitrage.synchronizer.plugins import transformer_base as tbase -from vitrage.synchronizer.plugins import transformer_base LOG = logging.getLogger(__name__) -class BaseResourceTransformer(tbase.TransformerBase): +class ResourceTransformerBase(tbase.TransformerBase): def __init__(self, transformers): self.transformers = transformers @@ -44,7 +43,7 @@ class BaseResourceTransformer(tbase.TransformerBase): key_fields = self._key_values(kwargs[VProps.TYPE], kwargs[VProps.ID]) return graph_utils.create_vertex( - transformer_base.build_key(key_fields), + tbase.build_key(key_fields), entity_id=kwargs[VProps.ID], entity_category=EntityCategory.RESOURCE, entity_type=kwargs[VProps.TYPE], diff --git a/vitrage/synchronizer/services.py b/vitrage/datasources/services.py similarity index 70% rename from vitrage/synchronizer/services.py rename to vitrage/datasources/services.py index 1004eefda..917083c7e 100644 --- a/vitrage/synchronizer/services.py +++ b/vitrage/datasources/services.py @@ -22,42 +22,42 @@ LOG = log.getLogger(__name__) class SynchronizerService(os_service.Service): - def __init__(self, conf, registered_plugins, callback_function): + def __init__(self, conf, registered_datasources, callback_function): super(SynchronizerService, self).__init__() self.conf = conf - self.registered_plugins = registered_plugins + self.registered_datasources = registered_datasources self.callback_function = callback_function class SnapshotsService(SynchronizerService): - def __init__(self, conf, registered_plugins, callback_function): + def __init__(self, conf, registered_datasources, callback_function): super(SnapshotsService, self).__init__(conf, - registered_plugins, + registered_datasources, callback_function) self.first_time = True def start(self): - LOG.info("Vitrage Synchronizer Snapshot Service - Starting...") + LOG.info("Vitrage datasources Snapshot Service - Starting...") super(SnapshotsService, self).start() - interval = self.conf.synchronizer.snapshots_interval + interval = self.conf.datasources.snapshots_interval self.tg.add_timer(interval, self._get_all) - LOG.info("Vitrage Synchronizer Snapshot Service - Started!") + LOG.info("Vitrage datasources Snapshot Service - Started!") def stop(self, graceful=False): - LOG.info("Vitrage Synchronizer Snapshot Service - Stopping...") + LOG.info("Vitrage datasources Snapshot Service - Stopping...") super(SnapshotsService, self).stop() - LOG.info("Vitrage Synchronizer Snapshot Service - Stopped!") + LOG.info("Vitrage datasources Snapshot Service - Stopped!") def _get_all(self): sync_mode = SyncMode.INIT_SNAPSHOT \ if self.first_time else SyncMode.SNAPSHOT LOG.debug("start get all with sync mode %s" % sync_mode) - for plugin in self.registered_plugins.values(): + for plugin in self.registered_datasources.values(): entities_dictionaries = plugin.get_all(sync_mode) for entity in entities_dictionaries: self.callback_function(entity) @@ -68,17 +68,17 @@ class SnapshotsService(SynchronizerService): class ChangesService(SynchronizerService): def __init__(self, conf, - registered_plugins, + registered_datasources, changes_interval, callback_function): super(ChangesService, self).__init__(conf, - registered_plugins, + registered_datasources, callback_function) self.changes_interval = changes_interval def start(self): LOG.info("Vitrage Synchronizer Changes Service For: %s - Starting...", - self.registered_plugins[0].__class__.__name__) + self.registered_datasources[0].__class__.__name__) super(ChangesService, self).start() self.tg.add_timer(interval=self.changes_interval, @@ -86,22 +86,22 @@ class ChangesService(SynchronizerService): initial_delay=self.changes_interval) LOG.info("Vitrage Synchronizer Changes Service For: %s - Started!", - self.registered_plugins[0].__class__.__name__) + self.registered_datasources[0].__class__.__name__) def stop(self, graceful=False): LOG.info("Vitrage Synchronizer Changes Service For: %s - Stopping...", - self.registered_plugins[0].__class__.__name__) + self.registered_datasources[0].__class__.__name__) super(ChangesService, self).stop() LOG.info("Vitrage Synchronizer Changes Service For: %s - Stopped!", - self.registered_plugins[0].__class__.__name__) + self.registered_datasources[0].__class__.__name__) def _get_changes(self): LOG.debug("start get changes") - for plugin in self.registered_plugins: - for entity in plugin.get_changes(SyncMode.UPDATE): + for datasource in self.registered_datasources: + for entity in datasource.get_changes(SyncMode.UPDATE): self.callback_function(entity) LOG.debug("end get changes") diff --git a/vitrage/synchronizer/plugins/static_physical/__init__.py b/vitrage/datasources/static_physical/__init__.py similarity index 65% rename from vitrage/synchronizer/plugins/static_physical/__init__.py rename to vitrage/datasources/static_physical/__init__.py index f9848a6b6..05afb1567 100644 --- a/vitrage/synchronizer/plugins/static_physical/__init__.py +++ b/vitrage/datasources/static_physical/__init__.py @@ -14,28 +14,28 @@ from oslo_config import cfg -STATIC_PHYSICAL_PLUGIN = 'static_physical' +STATIC_PHYSICAL_DATASOURCE = 'static_physical' SWITCH = 'switch' OPTS = [ cfg.StrOpt('transformer', - default='vitrage.synchronizer.plugins.static_physical.' - 'transformer.StaticPhysicalTransformer', + default='vitrage.datasources.static_physical.transformer.' + 'StaticPhysicalTransformer', help='Static physical transformer class path', required=True), - cfg.StrOpt('synchronizer', - default='vitrage.synchronizer.plugins.static_physical' - '.synchronizer.StaticPhysicalSynchronizer', - help='Static physical synchronizer class path', + cfg.StrOpt('driver', + default='vitrage.datasources.static_physical.driver.' + 'StaticPhysicalDriver', + help='Static physical driver class path', required=True), cfg.IntOpt('changes_interval', default=30, min=30, help='interval between checking changes in the configuration ' - 'files of the physical topology plugin', + 'files of the physical topology data sources', required=True), - cfg.StrOpt('directory', default='/etc/vitrage/static_plugins', - help='Static physical plugins directory'), + cfg.StrOpt('directory', default='/etc/vitrage/static_datasources', + help='Static physical data sources directory'), cfg.ListOpt('entities', default=[SWITCH], help='Static physical entity types list') diff --git a/vitrage/synchronizer/plugins/static_physical/synchronizer.py b/vitrage/datasources/static_physical/driver.py similarity index 92% rename from vitrage/synchronizer/plugins/static_physical/synchronizer.py rename to vitrage/datasources/static_physical/driver.py index 4f5906130..99ea47d2b 100644 --- a/vitrage/synchronizer/plugins/static_physical/synchronizer.py +++ b/vitrage/datasources/static_physical/driver.py @@ -19,26 +19,26 @@ from vitrage.common.constants import EventAction from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import VertexProperties as VProps from vitrage.common import file_utils -from vitrage.synchronizer.plugins.static_physical import STATIC_PHYSICAL_PLUGIN -from vitrage.synchronizer.plugins.synchronizer_base import SynchronizerBase +from vitrage.datasources.driver_base import DriverBase +from vitrage.datasources.static_physical import STATIC_PHYSICAL_DATASOURCE -class StaticPhysicalSynchronizer(SynchronizerBase): +class StaticPhysicalDriver(DriverBase): ENTITIES_SECTION = 'entities' def __init__(self, conf): - super(StaticPhysicalSynchronizer, self).__init__() + super(StaticPhysicalDriver, self).__init__() self.cfg = conf self.cache = {} def get_all(self, sync_mode): return self.make_pickleable(self._get_all_entities(), - STATIC_PHYSICAL_PLUGIN, + STATIC_PHYSICAL_DATASOURCE, sync_mode) def get_changes(self, sync_mode): return self.make_pickleable(self._get_changes_entities(), - STATIC_PHYSICAL_PLUGIN, + STATIC_PHYSICAL_DATASOURCE, sync_mode) def _get_all_entities(self): diff --git a/vitrage/synchronizer/plugins/static_physical/transformer.py b/vitrage/datasources/static_physical/transformer.py similarity index 91% rename from vitrage/synchronizer/plugins/static_physical/transformer.py rename to vitrage/datasources/static_physical/transformer.py index 9f64ae18d..bc42ca801 100644 --- a/vitrage/synchronizer/plugins/static_physical/transformer.py +++ b/vitrage/datasources/static_physical/transformer.py @@ -17,18 +17,18 @@ from oslo_log import log as logging from vitrage.common.constants import EntityCategory from vitrage.common.constants import SynchronizerProperties as SyncProps 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_physical import SWITCH +from vitrage.datasources import transformer_base +from vitrage.datasources.transformer_base import Neighbor import vitrage.graph.utils as graph_utils -from vitrage.synchronizer.plugins.base.resource.transformer import \ - BaseResourceTransformer -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.static_physical import SWITCH -from vitrage.synchronizer.plugins import transformer_base -from vitrage.synchronizer.plugins.transformer_base import Neighbor LOG = logging.getLogger(__name__) -class StaticPhysicalTransformer(BaseResourceTransformer): +class StaticPhysicalTransformer(ResourceTransformerBase): RELATION_TYPE = 'relation_type' RELATIONSHIPS_SECTION = 'relationships' @@ -129,7 +129,7 @@ class StaticPhysicalTransformer(BaseResourceTransformer): def _register_relations_direction(self): self.relation_direction = {} - relationship = (SWITCH, NOVA_HOST_PLUGIN) + relationship = (SWITCH, NOVA_HOST_DATASOURCE) self.relation_direction[relationship] = True relationship = (SWITCH, SWITCH) diff --git a/vitrage/synchronizer/plugins/transformer_base.py b/vitrage/datasources/transformer_base.py similarity index 93% rename from vitrage/synchronizer/plugins/transformer_base.py rename to vitrage/datasources/transformer_base.py index e5e10b98f..081710bf1 100644 --- a/vitrage/synchronizer/plugins/transformer_base.py +++ b/vitrage/datasources/transformer_base.py @@ -25,8 +25,8 @@ from vitrage.common.constants import EventAction from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import SyncMode from vitrage.common.exception import VitrageTransformerError +from vitrage.datasources import OPENSTACK_NODE import vitrage.graph.utils as graph_utils -from vitrage.synchronizer.plugins import OPENSTACK_NODE LOG = logging.getLogger(__name__) @@ -97,13 +97,13 @@ class TransformerBase(object): def transform(self, entity_event): """Transform an entity event into entity wrapper. - Entity event is received from synchronizer it need to be + Entity event is received from driver and it need to be transformed into entity wrapper. The wrapper contains: 1. Entity Vertex - The vertex itself with all fields 2. Neighbor list - neighbor placeholder vertex and an edge 3. Action type - CREATE/UPDATE/DELETE - :param entity_event: a general event from the synchronizer + :param entity_event: a general event from the driver :return: entity wrapper :rtype:EntityWrapper """ @@ -139,9 +139,9 @@ class TransformerBase(object): """Extracts entity neighbors received from a given entity event. Extracting entity neighbors from a given event provided - by synchronizer + by driver - :param entity_event: an event provided by synchronizer + :param entity_event: an event provided by driver :return: neighbors - a list of neighbors where each item in the list is a tuple of (vertex, edge) :rtype: list @@ -154,7 +154,7 @@ class TransformerBase(object): By given an entity event, return a entity key which consisting key fields - :param entity_event: event that returns from the synchronizer + :param entity_event: event that returns from the driver :return: key """ pass @@ -164,7 +164,7 @@ class TransformerBase(object): """Creates placeholder vertex. Placeholder vertex contains only mandatory fields of this entity. - This way other plugins can create placeholder vertices of those + This way other datasources can create placeholder vertices of those entities :param kwargs: the properties for the placeholder vertex @@ -179,7 +179,7 @@ class TransformerBase(object): Decides what action (from constants.EventAction) the processor need to perform according to the data received from the event. - :param entity_event: event that returns from the synchronizer + :param entity_event: event that returns from the driver :return: the action that the processor needs to perform :rtype: str """ diff --git a/vitrage/entity_graph/__init__.py b/vitrage/entity_graph/__init__.py index 2b8bc78de..6ea689c47 100644 --- a/vitrage/entity_graph/__init__.py +++ b/vitrage/entity_graph/__init__.py @@ -17,8 +17,9 @@ from oslo_config import cfg OPTS = [ - cfg.StrOpt('states_plugins_dir', - default='/etc/vitrage/states_plugins', - help='A path for the configuration files of the plugins states' + cfg.StrOpt('datasources_states_dir', + default='/etc/vitrage/datasources_states', + help='A path for the configuration files of the data sources' + ' states' ), ] diff --git a/vitrage/entity_graph/api_handler/entity_graph_api.py b/vitrage/entity_graph/api_handler/entity_graph_api.py index 11522d213..8408a9647 100644 --- a/vitrage/entity_graph/api_handler/entity_graph_api.py +++ b/vitrage/entity_graph/api_handler/entity_graph_api.py @@ -19,12 +19,12 @@ from vitrage.common.constants import EdgeLabels 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.nova.host import NOVA_HOST_DATASOURCE +from vitrage.datasources.nova.instance import NOVA_INSTANCE_DATASOURCE +from vitrage.datasources.nova.zone import NOVA_ZONE_DATASOURCE +from vitrage.datasources import OPENSTACK_NODE from vitrage.graph import create_algorithm from vitrage.graph import Direction -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.nova.instance import NOVA_INSTANCE_PLUGIN -from vitrage.synchronizer.plugins.nova.zone import NOVA_ZONE_PLUGIN -from vitrage.synchronizer.plugins import OPENSTACK_NODE LOG = log.getLogger(__name__) @@ -37,9 +37,9 @@ TREE_TOPOLOGY_QUERY = { { 'or': [ {'==': {VProps.TYPE: OPENSTACK_NODE}}, - {'==': {VProps.TYPE: NOVA_INSTANCE_PLUGIN}}, - {'==': {VProps.TYPE: NOVA_HOST_PLUGIN}}, - {'==': {VProps.TYPE: NOVA_ZONE_PLUGIN}} + {'==': {VProps.TYPE: NOVA_INSTANCE_DATASOURCE}}, + {'==': {VProps.TYPE: NOVA_HOST_DATASOURCE}}, + {'==': {VProps.TYPE: NOVA_ZONE_DATASOURCE}} ] } ] diff --git a/vitrage/entity_graph/consistency/__init__.py b/vitrage/entity_graph/consistency/__init__.py index 06d1d6ce4..d278d48f3 100644 --- a/vitrage/entity_graph/consistency/__init__.py +++ b/vitrage/entity_graph/consistency/__init__.py @@ -24,12 +24,12 @@ OPTS = [ default=3, min=1, help='interval between consistency initialization checks for ' - 'finding if all end messages from plugins were ' + 'finding if all end messages from datasources were ' 'received (in seconds)'), cfg.IntOpt('initialization_max_retries', default=30, min=1, help='maximum retries for consistency initialization ' - 'for finding if all end messages from plugins were ' + 'for finding if all end messages from datasources were ' 'received (in seconds)'), ] diff --git a/vitrage/entity_graph/consistency/consistency_enforcer.py b/vitrage/entity_graph/consistency/consistency_enforcer.py index c4b53be46..9ef5328d1 100644 --- a/vitrage/entity_graph/consistency/consistency_enforcer.py +++ b/vitrage/entity_graph/consistency/consistency_enforcer.py @@ -20,8 +20,8 @@ from oslo_log import log from vitrage.common.constants import EntityCategory from vitrage.common.constants import VertexProperties as VProps from vitrage.common.datetime_utils import utcnow +from vitrage.datasources import OPENSTACK_NODE from vitrage.evaluator.actions.evaluator_event_transformer import VITRAGE_TYPE -from vitrage.synchronizer.plugins import OPENSTACK_NODE LOG = log.getLogger(__name__) @@ -94,7 +94,7 @@ class ConsistencyEnforcer(object): 'and': [ {'!=': {VProps.TYPE: VITRAGE_TYPE}}, {'<': {VProps.SAMPLE_TIMESTAMP: str(utcnow() - timedelta( - seconds=2 * self.conf.synchronizer.snapshots_interval))}} + seconds=2 * self.conf.datasources.snapshots_interval))}} ] } diff --git a/vitrage/entity_graph/consistency/service.py b/vitrage/entity_graph/consistency/service.py index 6372daea8..a306f897b 100644 --- a/vitrage/entity_graph/consistency/service.py +++ b/vitrage/entity_graph/consistency/service.py @@ -47,10 +47,10 @@ class VitrageGraphConsistencyService(os_service.Service): self.evaluator, self.entity_graph, self.initialization_status) - self.tg.add_timer(self.conf.synchronizer.snapshots_interval, + self.tg.add_timer(self.conf.datasources.snapshots_interval, consistency_enf.periodic_process, initial_delay=60 + - self.conf.synchronizer.snapshots_interval) + self.conf.datasources.snapshots_interval) initializing_process_thread = \ threading.Thread(target=consistency_enf.initializing_process) diff --git a/vitrage/entity_graph/processor/processor.py b/vitrage/entity_graph/processor/processor.py index 8d759715a..83e354aa8 100644 --- a/vitrage/entity_graph/processor/processor.py +++ b/vitrage/entity_graph/processor/processor.py @@ -17,12 +17,12 @@ from oslo_log import log from vitrage.common.constants import EventAction from vitrage.common.constants import VertexProperties as VProps +from vitrage.datasources.transformer_base import TransformerBase from vitrage.entity_graph.processor import base as processor from vitrage.entity_graph.processor import entity_graph from vitrage.entity_graph.states.state_manager import StateManager from vitrage.entity_graph.transformer_manager import TransformerManager from vitrage.graph import Direction -from vitrage.synchronizer.plugins.transformer_base import TransformerBase LOG = log.getLogger(__name__) @@ -156,7 +156,7 @@ class Processor(processor.ProcessorBase): self.initialization_status.end_messages[vertex[VProps.TYPE]] = True if len(self.initialization_status.end_messages) == \ - len(self.conf.plugins.plugin_type): + len(self.conf.datasources.types): self.initialization_status.status = \ self.initialization_status.RECEIVED_ALL_END_MESSAGES diff --git a/vitrage/entity_graph/states/state_manager.py b/vitrage/entity_graph/states/state_manager.py index 4e8f7601e..4516740ee 100644 --- a/vitrage/entity_graph/states/state_manager.py +++ b/vitrage/entity_graph/states/state_manager.py @@ -35,40 +35,45 @@ class StateManager(object): def __init__(self, conf): self.conf = conf self.category_normalizator = self._init_category_normalizator() - self.states_plugins = self._load_state_configurations() + self.datasources_state_confs = self._load_state_configurations() - def normalize_state(self, category, plugin_name, state): + def normalize_state(self, category, datasource_name, state): upper_state = state if not state else state.upper() important_states = \ self.category_normalizator[category].important_states() - if plugin_name in self.states_plugins: - return self.states_plugins[plugin_name][self.STATES][upper_state] \ - if upper_state in \ - self.states_plugins[plugin_name][self.STATES] else \ - self.states_plugins[plugin_name][important_states.unknown] + if datasource_name in self.datasources_state_confs: + + states_conf = self.datasources_state_confs[datasource_name] + + return states_conf[self.STATES][upper_state] \ + if upper_state in states_conf[self.STATES] \ + else states_conf[important_states.unknown] else: return important_states.undefined - def state_priority(self, plugin_name, normalized_state): + def state_priority(self, datasource_name, normalized_state): # no need to check if normalized_state exists, cause it exists for sure upper_state = normalized_state if not normalized_state else \ normalized_state.upper() - if plugin_name in self.states_plugins: - return \ - self.states_plugins[plugin_name][self.PRIORITIES][upper_state] + if datasource_name in self.datasources_state_confs: + states_conf = self.datasources_state_confs[datasource_name] + return states_conf[self.PRIORITIES][upper_state] else: # default UNDEFINED priority return 0 def aggregated_state(self, new_vertex, graph_vertex, is_normalized=False): - plugin_name = new_vertex[VProps.TYPE] if VProps.TYPE in \ - new_vertex.properties else graph_vertex[VProps.TYPE] - category = new_vertex[VProps.CATEGORY] if VProps.CATEGORY in \ - new_vertex.properties else graph_vertex[VProps.CATEGORY] + datasource_name = new_vertex[VProps.TYPE] if \ + VProps.TYPE in new_vertex.properties else \ + graph_vertex[VProps.TYPE] - if plugin_name in self.states_plugins: + category = new_vertex[VProps.CATEGORY] if \ + VProps.CATEGORY in new_vertex.properties else \ + graph_vertex[VProps.CATEGORY] + + if datasource_name in self.datasources_state_confs: state_properties = \ self.category_normalizator[category].state_properties() normalized_state, state_priority = \ @@ -76,7 +81,7 @@ class StateManager(object): graph_vertex, state_properties[0], category, - plugin_name, + datasource_name, is_normalized) state_properties.pop(0) @@ -86,7 +91,7 @@ class StateManager(object): graph_vertex, property_, category, - plugin_name, + datasource_name, is_normalized) if tmp_state_priority > state_priority: normalized_state = tmp_normalized_state @@ -106,33 +111,33 @@ class StateManager(object): } def _load_state_configurations(self): - states_plugins = {} - erroneous_plugins = [] + ok_datasources = {} + erroneous_datasources = [] files = file_utils.load_files( - self.conf.entity_graph.states_plugins_dir, '.yaml') + self.conf.entity_graph.datasources_states_dir, '.yaml') for file_name in files: try: - full_path = self.conf.entity_graph.states_plugins_dir + '/' \ - + file_name + full_path = self.conf.entity_graph.datasources_states_dir \ + + '/' + file_name states, priorities = \ self._retrieve_states_and_priorities_from_file(full_path) - states_plugins[os.path.splitext(file_name)[0]] = { + ok_datasources[os.path.splitext(file_name)[0]] = { self.STATES: states, self.PRIORITIES: priorities } except Exception as e: LOG.exception("Exception: %s", e) - plugin = os.path.splitext(file_name)[0] - LOG.error('erroneous plugins is %s', - erroneous_plugins.append(plugin)) + datasource = os.path.splitext(file_name)[0] + LOG.error('erroneous data sources is %s', + erroneous_datasources.append(datasource)) - self._is_all_plugins_states_exists( - [key for key in states_plugins.keys()], - erroneous_plugins) + self._check_state_confs_exists( + [key for key in ok_datasources.keys()], + erroneous_datasources) - return states_plugins + return ok_datasources def _retrieve_states_and_priorities_from_file(self, full_path): states = {} @@ -154,7 +159,7 @@ class StateManager(object): priorities[normalized_state_name] = \ int(normalized_state['priority']) - self.check_validity(category, states, priorities, full_path) + self.check_validity(category, priorities, full_path) return states, priorities @@ -164,7 +169,7 @@ class StateManager(object): states[None] = state priorities[NormalizedResourceState.UNDEFINED] = priority - def check_validity(self, category, states, priorities, full_path): + def check_validity(self, category, priorities, full_path): important_states = \ self.category_normalizator[category].important_states() if important_states.unknown not in priorities: @@ -187,7 +192,7 @@ class StateManager(object): graph_vertex, property_, category, - plugin_name, + datasource_name, is_normalized=False): state = self._get_updated_property(new_vertex, graph_vertex, @@ -196,9 +201,10 @@ class StateManager(object): upper_state1 = state if not state else state.upper() normalized_state = upper_state1 if is_normalized else \ - self.normalize_state(category, plugin_name, upper_state1) + self.normalize_state(category, datasource_name, upper_state1) - state_priority = self.state_priority(plugin_name, normalized_state) + state_priority = self.state_priority(datasource_name, + normalized_state) return normalized_state, state_priority @@ -207,13 +213,17 @@ class StateManager(object): return [attr for attr in dir(class_instance) if not callable(attr) and not attr.startswith("__")] - def _is_all_plugins_states_exists(self, states_plugins, error_plugins): - plugin_types = self.conf.plugins.plugin_type - all_state_loaded_plugins = states_plugins + error_plugins + def _check_state_confs_exists(self, + ok_datasources, + error_datasources): - for plugin_type in plugin_types: - if plugin_type not in all_state_loaded_plugins: - LOG.error("No state configuration file for: %s", plugin_type) + datasource_types = self.conf.datasources.types + datasources_with_state_conf = ok_datasources + error_datasources + + for datasource_type in datasource_types: + if datasource_type not in datasources_with_state_conf: + LOG.error("No state configuration file for: %s", + datasource_type) @staticmethod def _get_updated_property(new_vertex, graph_vertex, prop): diff --git a/vitrage/entity_graph/transformer_manager.py b/vitrage/entity_graph/transformer_manager.py index 2997a7467..fd48956a9 100644 --- a/vitrage/entity_graph/transformer_manager.py +++ b/vitrage/entity_graph/transformer_manager.py @@ -36,14 +36,14 @@ class TransformerManager(object): def register_transformer_classes(conf): transformers = {} - for plugin in conf.plugins.plugin_type: - transformers[plugin] = importutils.import_object( - conf[plugin].transformer, + for datasource_type in conf.datasources.types: + transformers[datasource_type] = importutils.import_object( + conf[datasource_type].transformer, transformers) - if opt_exists(conf[plugin], ENTITIES): - for entity in conf[plugin].entities: + if opt_exists(conf[datasource_type], ENTITIES): + for entity in conf[datasource_type].entities: transformers[entity] = importutils.import_object( - conf[plugin].transformer, transformers) + conf[datasource_type].transformer, transformers) transformers[VITRAGE_TYPE] = importutils.import_object( "%s.%s" % (EvaluatorEventTransformer.__module__, diff --git a/vitrage/evaluator/actions/evaluator_event_transformer.py b/vitrage/evaluator/actions/evaluator_event_transformer.py index 7e6561f5e..9df9467fe 100644 --- a/vitrage/evaluator/actions/evaluator_event_transformer.py +++ b/vitrage/evaluator/actions/evaluator_event_transformer.py @@ -20,6 +20,8 @@ from vitrage.common.constants import EntityCategory from vitrage.common.constants import EventAction from vitrage.common.constants import VertexProperties as VProps from vitrage.common.exception import VitrageTransformerError +from vitrage.datasources import transformer_base +from vitrage.datasources.transformer_base import Neighbor 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 @@ -29,8 +31,6 @@ from vitrage.evaluator.actions.recipes.base import EVALUATOR_EVENT_TYPE from vitrage.evaluator.template_fields import TemplateFields as TFields import vitrage.graph.utils as graph_utils from vitrage.graph import Vertex -from vitrage.synchronizer.plugins import transformer_base -from vitrage.synchronizer.plugins.transformer_base import Neighbor LOG = logging.getLogger(__name__) diff --git a/vitrage/evaluator/actions/recipes/raise_alarm.py b/vitrage/evaluator/actions/recipes/raise_alarm.py index e89a97972..5f771dc93 100644 --- a/vitrage/evaluator/actions/recipes/raise_alarm.py +++ b/vitrage/evaluator/actions/recipes/raise_alarm.py @@ -14,14 +14,13 @@ from vitrage.common.constants import NotifierEventTypes from vitrage.common.constants import VertexProperties as VProps +from vitrage.datasources.alarm_properties import AlarmProperties as AlarmProps from vitrage.evaluator.actions.recipes.action_steps import ADD_VERTEX from vitrage.evaluator.actions.recipes.action_steps import NOTIFY from vitrage.evaluator.actions.recipes.action_steps import REMOVE_VERTEX from vitrage.evaluator.actions.recipes import base from vitrage.evaluator.actions.recipes.base import ActionStepWrapper from vitrage.evaluator.template_fields import TemplateFields as TFields -from vitrage.synchronizer.plugins.base.alarm.properties \ - import AlarmProperties as AlarmProps class RaiseAlarm(base.Recipe): diff --git a/vitrage/opts.py b/vitrage/opts.py index 2cbc58b86..c2c2849fb 100644 --- a/vitrage/opts.py +++ b/vitrage/opts.py @@ -19,36 +19,31 @@ from oslo_utils import importutils import vitrage.api import vitrage.clients +import vitrage.datasources import vitrage.entity_graph.consistency import vitrage.evaluator import vitrage.keystone_client import vitrage.rpc -import vitrage.synchronizer -import vitrage.synchronizer.plugins -PLUGINS_MODULE_PATH = 'vitrage.synchronizer.plugins.' -PLUGINS_FS_PATH = os.path.join('vitrage', 'synchronizer', 'plugins') -SYNCHRONIZER_FILE = 'synchronizer.py' -TRANSFORMER_FILE = 'transformer.py' +DATASOURCES_MODULE_PATH = 'vitrage.datasources.' +DATASOURCE_FS_PATH = os.path.join('vitrage', 'datasources') +DRIVER_FILE = 'driver.py' +TRANSFORMER_FILE = 'alarm_transformer_base.py' def list_opts(): return [ ('api', vitrage.api.OPTS), - ('synchronizer', vitrage.synchronizer.OPTS), + ('datasources', vitrage.datasources.OPTS), ('evaluator', vitrage.evaluator.OPTS), - ('plugins', vitrage.synchronizer.plugins.OPTS), ('consistency', vitrage.entity_graph.consistency.OPTS), ('entity_graph', vitrage.entity_graph.OPTS), ('service_credentials', vitrage.keystone_client.OPTS), - ('DEFAULT', - itertools.chain( - vitrage.clients.OPTS, - vitrage.rpc.OPTS)) + ('DEFAULT', itertools.chain(vitrage.clients.OPTS, vitrage.rpc.OPTS)) ] -def plugins_opts(): +def datasources_opts(): top = os.getcwd() plugin_names = _normalize_path_to_plugin_name( _filter_folders_containing_transformer( @@ -56,14 +51,14 @@ def plugins_opts(): return [(plugin_name, plugin_module.OPTS) for plugin_name in plugin_names for plugin_module in - [importutils.import_module(PLUGINS_MODULE_PATH + plugin_name)] + [importutils.import_module(DATASOURCES_MODULE_PATH + plugin_name)] if 'OPTS' in plugin_module.__dict__] def _get_folders_containing_synchronizer(top=os.getcwd()): return [os.path.dirname(os.path.join(root, name)) for root, dirs, files in os.walk(top, topdown=False) - for name in files if name == SYNCHRONIZER_FILE] + for name in files if name == DRIVER_FILE] def _filter_folders_containing_transformer(folders): @@ -73,5 +68,5 @@ def _filter_folders_containing_transformer(folders): def _normalize_path_to_plugin_name(path_list, top=os.getcwd()): - return [os.path.relpath(path, os.path.join(top, PLUGINS_FS_PATH)) + return [os.path.relpath(path, os.path.join(top, DATASOURCE_FS_PATH)) .replace(os.sep, '.') for path in path_list] diff --git a/vitrage/service.py b/vitrage/service.py index 95ae21035..2d62fc61f 100644 --- a/vitrage/service.py +++ b/vitrage/service.py @@ -38,8 +38,8 @@ def prepare_service(args=None, conf=None, config_files=None): conf(args, project='vitrage', validate_default_values=True, default_config_files=config_files) - for plugin_name in conf.plugins.plugin_type: - load_plugin(conf, plugin_name, conf.plugins.plugin_path) + for datasource in conf.datasources.types: + load_datasource(conf, datasource, conf.datasources.path) keystone_client.register_keystoneauth_opts(conf) @@ -51,7 +51,7 @@ def prepare_service(args=None, conf=None, config_files=None): return conf -def load_plugin(conf, name, paths): +def load_datasource(conf, name, paths): for path in paths: try: opt = importutils.import_module("%s.%s" % (path, name)).OPTS diff --git a/vitrage/synchronizer/__init__.py b/vitrage/synchronizer/__init__.py deleted file mode 100644 index 31fbea826..000000000 --- a/vitrage/synchronizer/__init__.py +++ /dev/null @@ -1,22 +0,0 @@ -# Copyright 2016 - Alcatel-Lucent -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -from oslo_config import cfg - -OPTS = [ - cfg.IntOpt('snapshots_interval', - default=600, - min=10, - help='interval between full snapshots'), -] diff --git a/vitrage/synchronizer/plugins/__init__.py b/vitrage/synchronizer/plugins/__init__.py deleted file mode 100644 index 376b71229..000000000 --- a/vitrage/synchronizer/plugins/__init__.py +++ /dev/null @@ -1,46 +0,0 @@ -# Copyright 2016 - Nokia -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -from oslo_config import cfg - -from vitrage.synchronizer.plugins.aodh import AODH_PLUGIN -from vitrage.synchronizer.plugins.cinder.volume import CINDER_VOLUME_PLUGIN -from vitrage.synchronizer.plugins.nagios import NAGIOS_PLUGIN -from vitrage.synchronizer.plugins.neutron.network import NEUTRON_NETWORK_PLUGIN -from vitrage.synchronizer.plugins.neutron.port import NEUTRON_PORT_PLUGIN -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.nova.instance import NOVA_INSTANCE_PLUGIN -from vitrage.synchronizer.plugins.nova.zone import NOVA_ZONE_PLUGIN -from vitrage.synchronizer.plugins.static_physical import STATIC_PHYSICAL_PLUGIN - -OPENSTACK_NODE = 'openstack.node' - -# Register options for the service -OPTS = [ - - cfg.ListOpt('plugin_type', - default=[NOVA_HOST_PLUGIN, - NOVA_INSTANCE_PLUGIN, - NOVA_ZONE_PLUGIN, - NAGIOS_PLUGIN, - STATIC_PHYSICAL_PLUGIN, - AODH_PLUGIN, - CINDER_VOLUME_PLUGIN, - NEUTRON_NETWORK_PLUGIN, - NEUTRON_PORT_PLUGIN], - help='Names of supported plugins'), - cfg.ListOpt('plugin_path', - default=['vitrage.synchronizer.plugins'], - help='base path for plugins') -] diff --git a/vitrage/synchronizer/test_client.py.template b/vitrage/synchronizer/test_client.py.template deleted file mode 100644 index aa55a65d9..000000000 --- a/vitrage/synchronizer/test_client.py.template +++ /dev/null @@ -1,43 +0,0 @@ -# Copyright 2015 - Alcatel-Lucent -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -import multiprocessing - -from vitrage.synchronizer.synchronizer import Synchronizer - - -class TestClient(object): - def queue_callback_function(self, output): - for entity in output: - self.queue.put(entity) - - def print_queue(self): - while True: - entity = self.queue.get() - print(entity) - - def __init__(self): - self.queue = multiprocessing.Queue() - self.synchronizer = Synchronizer(self.queue) - self.worker = multiprocessing.Process(target=self.print_queue) - - def get_all(self): - self.synchronizer.get_all() - - -if __name__ == '__main__': - client = TestClient() - client.get_all() - client.worker.start() - client.worker.join() diff --git a/vitrage/tests/functional/base.py b/vitrage/tests/functional/base.py index 354f8aab3..c99705ce7 100644 --- a/vitrage/tests/functional/base.py +++ b/vitrage/tests/functional/base.py @@ -16,7 +16,7 @@ from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import SyncMode from vitrage.entity_graph.initialization_status import InitializationStatus from vitrage.entity_graph.processor import processor as proc -from vitrage.tests.mocks import mock_syncronizer as mock_sync +from vitrage.tests.mocks import mock_driver from vitrage.tests.unit.entity_graph.base import TestEntityGraphUnitBase @@ -34,19 +34,19 @@ class TestFunctionalBase(TestEntityGraphUnitBase): return processor def _create_mock_events(self): - gen_list = mock_sync.simple_zone_generators( + gen_list = mock_driver.simple_zone_generators( self.NUM_ZONES, self.NUM_HOSTS, snapshot_events=self.NUM_ZONES, snap_vals={SyncProps.SYNC_MODE: SyncMode.INIT_SNAPSHOT}) - gen_list += mock_sync.simple_host_generators( + gen_list += mock_driver.simple_host_generators( self.NUM_ZONES, self.NUM_HOSTS, self.NUM_HOSTS, snap_vals={SyncProps.SYNC_MODE: SyncMode.INIT_SNAPSHOT}) - gen_list += mock_sync.simple_instance_generators( + gen_list += mock_driver.simple_instance_generators( self.NUM_HOSTS, self.NUM_INSTANCES, self.NUM_INSTANCES, snap_vals={SyncProps.SYNC_MODE: SyncMode.INIT_SNAPSHOT}) - return mock_sync.generate_sequential_events_list(gen_list) + return mock_driver.generate_sequential_events_list(gen_list) diff --git a/vitrage/synchronizer/plugins/base/__init__.py b/vitrage/tests/functional/datasources/__init__.py similarity index 100% rename from vitrage/synchronizer/plugins/base/__init__.py rename to vitrage/tests/functional/datasources/__init__.py diff --git a/vitrage/synchronizer/plugins/base/alarm/__init__.py b/vitrage/tests/functional/datasources/aodh/__init__.py similarity index 100% rename from vitrage/synchronizer/plugins/base/alarm/__init__.py rename to vitrage/tests/functional/datasources/aodh/__init__.py diff --git a/vitrage/tests/functional/data_sources/aodh/test_aodh.py b/vitrage/tests/functional/datasources/aodh/test_aodh.py similarity index 100% rename from vitrage/tests/functional/data_sources/aodh/test_aodh.py rename to vitrage/tests/functional/datasources/aodh/test_aodh.py diff --git a/vitrage/tests/functional/data_sources/base.py b/vitrage/tests/functional/datasources/base.py similarity index 100% rename from vitrage/tests/functional/data_sources/base.py rename to vitrage/tests/functional/datasources/base.py diff --git a/vitrage/synchronizer/plugins/base/resource/__init__.py b/vitrage/tests/functional/datasources/cinder/__init__.py similarity index 100% rename from vitrage/synchronizer/plugins/base/resource/__init__.py rename to vitrage/tests/functional/datasources/cinder/__init__.py diff --git a/vitrage/tests/functional/data_sources/cinder/test_cinder_volume.py b/vitrage/tests/functional/datasources/cinder/test_cinder_volume.py similarity index 64% rename from vitrage/tests/functional/data_sources/cinder/test_cinder_volume.py rename to vitrage/tests/functional/datasources/cinder/test_cinder_volume.py index 2e17ba8f0..faa692c97 100644 --- a/vitrage/tests/functional/data_sources/cinder/test_cinder_volume.py +++ b/vitrage/tests/functional/datasources/cinder/test_cinder_volume.py @@ -16,29 +16,28 @@ from oslo_config import cfg from vitrage.common.constants import EntityCategory from vitrage.common.constants import VertexProperties as VProps -from vitrage.synchronizer.plugins import CINDER_VOLUME_PLUGIN -from vitrage.synchronizer.plugins import NAGIOS_PLUGIN -from vitrage.synchronizer.plugins import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins import NOVA_INSTANCE_PLUGIN -from vitrage.synchronizer.plugins import NOVA_ZONE_PLUGIN -from vitrage.tests.functional.data_sources.base import \ - TestDataSourcesBase -from vitrage.tests.mocks import mock_syncronizer as mock_sync +from vitrage.datasources import CINDER_VOLUME_DATASOURCE +from vitrage.datasources import NAGIOS_DATASOURCE +from vitrage.datasources import NOVA_HOST_DATASOURCE +from vitrage.datasources import NOVA_INSTANCE_DATASOURCE +from vitrage.datasources import NOVA_ZONE_DATASOURCE +from vitrage.tests.functional.datasources.base import TestDataSourcesBase +from vitrage.tests.mocks import mock_driver class TestCinderVolume(TestDataSourcesBase): - PLUGINS_OPTS = [ - cfg.ListOpt('plugin_type', - default=[NAGIOS_PLUGIN, - NOVA_HOST_PLUGIN, - NOVA_INSTANCE_PLUGIN, - NOVA_ZONE_PLUGIN, - CINDER_VOLUME_PLUGIN], + DATASOURCES_OPTS = [ + cfg.ListOpt('types', + default=[NAGIOS_DATASOURCE, + NOVA_HOST_DATASOURCE, + NOVA_INSTANCE_DATASOURCE, + NOVA_ZONE_DATASOURCE, + CINDER_VOLUME_DATASOURCE], help='Names of supported driver data sources'), - cfg.ListOpt('plugin_path', - default=['vitrage.synchronizer.plugins'], + cfg.ListOpt('path', + default=['vitrage.datasources'], help='base path for data sources') ] @@ -47,8 +46,8 @@ class TestCinderVolume(TestDataSourcesBase): super(TestCinderVolume, cls).setUpClass() cls.conf = cfg.ConfigOpts() cls.conf.register_opts(cls.PROCESSOR_OPTS, group='entity_graph') - cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins') - cls.load_plugins(cls.conf) + cls.conf.register_opts(cls.DATASOURCES_OPTS, group='datasources') + cls.load_datasources(cls.conf) def test_cinder_volume_validity(self): # Setup @@ -56,15 +55,15 @@ class TestCinderVolume(TestDataSourcesBase): self.assertEqual(self._num_total_expected_vertices(), len(processor.entity_graph)) - spec_list = mock_sync.simple_volume_generators( + spec_list = mock_driver.simple_volume_generators( volume_num=1, instance_num=1, snapshot_events=1) - static_events = mock_sync.generate_random_events_list(spec_list) + static_events = mock_driver.generate_random_events_list(spec_list) cinder_volume_event = static_events[0] cinder_volume_event['attachments'][0]['server_id'] = \ self._find_entity_id_by_type(processor.entity_graph, - NOVA_INSTANCE_PLUGIN) + NOVA_INSTANCE_DATASOURCE) # Action processor.process_event(cinder_volume_event) @@ -76,7 +75,7 @@ class TestCinderVolume(TestDataSourcesBase): cinder_vertices = processor.entity_graph.get_vertices( vertex_attr_filter={ VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: CINDER_VOLUME_PLUGIN + VProps.TYPE: CINDER_VOLUME_DATASOURCE }) self.assertEqual(1, len(cinder_vertices)) @@ -84,5 +83,5 @@ class TestCinderVolume(TestDataSourcesBase): cinder_vertices[0].vertex_id) self.assertEqual(1, len(cinder_neighbors)) - self.assertEqual(NOVA_INSTANCE_PLUGIN, + self.assertEqual(NOVA_INSTANCE_DATASOURCE, cinder_neighbors[0][VProps.TYPE]) diff --git a/vitrage/synchronizer/plugins/nova/__init__.py b/vitrage/tests/functional/datasources/nagios/__init__.py similarity index 100% rename from vitrage/synchronizer/plugins/nova/__init__.py rename to vitrage/tests/functional/datasources/nagios/__init__.py diff --git a/vitrage/tests/functional/data_sources/nagios/test_nagios.py b/vitrage/tests/functional/datasources/nagios/test_nagios.py similarity index 66% rename from vitrage/tests/functional/data_sources/nagios/test_nagios.py rename to vitrage/tests/functional/datasources/nagios/test_nagios.py index c71af3d51..b517b82e0 100644 --- a/vitrage/tests/functional/data_sources/nagios/test_nagios.py +++ b/vitrage/tests/functional/datasources/nagios/test_nagios.py @@ -16,28 +16,28 @@ from oslo_config import cfg from vitrage.common.constants import EntityCategory from vitrage.common.constants import VertexProperties as VProps -from vitrage.synchronizer.plugins import NAGIOS_PLUGIN -from vitrage.synchronizer.plugins import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins import NOVA_INSTANCE_PLUGIN -from vitrage.synchronizer.plugins import NOVA_ZONE_PLUGIN -from vitrage.tests.functional.data_sources.base import \ +from vitrage.datasources import NAGIOS_DATASOURCE +from vitrage.datasources import NOVA_HOST_DATASOURCE +from vitrage.datasources import NOVA_INSTANCE_DATASOURCE +from vitrage.datasources import NOVA_ZONE_DATASOURCE +from vitrage.tests.functional.datasources.base import \ TestDataSourcesBase -from vitrage.tests.mocks import mock_syncronizer as mock_sync +from vitrage.tests.mocks import mock_driver class TestNagios(TestDataSourcesBase): - PLUGINS_OPTS = [ - cfg.ListOpt('plugin_type', - default=[NAGIOS_PLUGIN, - NOVA_HOST_PLUGIN, - NOVA_INSTANCE_PLUGIN, - NOVA_ZONE_PLUGIN, - NAGIOS_PLUGIN], + DATASOURCES_OPTS = [ + cfg.ListOpt('types', + default=[NAGIOS_DATASOURCE, + NOVA_HOST_DATASOURCE, + NOVA_INSTANCE_DATASOURCE, + NOVA_ZONE_DATASOURCE, + NAGIOS_DATASOURCE], help='Names of supported driver data sources'), - cfg.ListOpt('plugin_path', - default=['vitrage.synchronizer.plugins'], + cfg.ListOpt('path', + default=['vitrage.datasources'], help='base path for data sources') ] @@ -46,8 +46,8 @@ class TestNagios(TestDataSourcesBase): super(TestNagios, cls).setUpClass() cls.conf = cfg.ConfigOpts() cls.conf.register_opts(cls.PROCESSOR_OPTS, group='entity_graph') - cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins') - cls.load_plugins(cls.conf) + cls.conf.register_opts(cls.DATASOURCES_OPTS, group='datasources') + cls.load_datasources(cls.conf) def test_nagios_validity(self): # Setup @@ -55,14 +55,14 @@ class TestNagios(TestDataSourcesBase): self.assertEqual(self._num_total_expected_vertices(), len(processor.entity_graph)) - spec_list = mock_sync.simple_nagios_alarm_generators( + spec_list = mock_driver.simple_nagios_alarm_generators( host_num=1, events_num=1) - static_events = mock_sync.generate_random_events_list(spec_list) + static_events = mock_driver.generate_random_events_list(spec_list) nagios_event = static_events[0] nagios_event['resource_name'] = \ self._find_entity_id_by_type(processor.entity_graph, - NOVA_HOST_PLUGIN) + NOVA_HOST_DATASOURCE) nagios_event['status'] = 'critical' # Action @@ -75,7 +75,7 @@ class TestNagios(TestDataSourcesBase): nagios_vertices = processor.entity_graph.get_vertices( vertex_attr_filter={ VProps.CATEGORY: EntityCategory.ALARM, - VProps.TYPE: NAGIOS_PLUGIN + VProps.TYPE: NAGIOS_DATASOURCE }) self.assertEqual(1, len(nagios_vertices)) @@ -83,5 +83,5 @@ class TestNagios(TestDataSourcesBase): nagios_vertices[0].vertex_id) self.assertEqual(1, len(nagios_neighbors)) - self.assertEqual(NOVA_HOST_PLUGIN, + self.assertEqual(NOVA_HOST_DATASOURCE, nagios_neighbors[0][VProps.TYPE]) diff --git a/vitrage/tests/functional/data_sources/__init__.py b/vitrage/tests/functional/datasources/neutron/__init__.py similarity index 100% rename from vitrage/tests/functional/data_sources/__init__.py rename to vitrage/tests/functional/datasources/neutron/__init__.py diff --git a/vitrage/tests/functional/data_sources/neutron/test_neutron_network.py b/vitrage/tests/functional/datasources/neutron/test_neutron_network.py similarity index 100% rename from vitrage/tests/functional/data_sources/neutron/test_neutron_network.py rename to vitrage/tests/functional/datasources/neutron/test_neutron_network.py diff --git a/vitrage/tests/functional/data_sources/neutron/test_neutron_port.py b/vitrage/tests/functional/datasources/neutron/test_neutron_port.py similarity index 100% rename from vitrage/tests/functional/data_sources/neutron/test_neutron_port.py rename to vitrage/tests/functional/datasources/neutron/test_neutron_port.py diff --git a/vitrage/tests/functional/data_sources/aodh/__init__.py b/vitrage/tests/functional/datasources/nova/__init__.py similarity index 100% rename from vitrage/tests/functional/data_sources/aodh/__init__.py rename to vitrage/tests/functional/datasources/nova/__init__.py diff --git a/vitrage/tests/functional/data_sources/nova/test_nova_plugins.py b/vitrage/tests/functional/datasources/nova/test_nova_datasources.py similarity index 82% rename from vitrage/tests/functional/data_sources/nova/test_nova_plugins.py rename to vitrage/tests/functional/datasources/nova/test_nova_datasources.py index 2d5d88da7..a916652e4 100644 --- a/vitrage/tests/functional/data_sources/nova/test_nova_plugins.py +++ b/vitrage/tests/functional/datasources/nova/test_nova_datasources.py @@ -14,21 +14,21 @@ from oslo_config import cfg -from vitrage.tests.functional.data_sources.base import \ +from vitrage.tests.functional.datasources.base import \ TestDataSourcesBase -class TestNovaPlugins(TestDataSourcesBase): +class TestNovaDatasources(TestDataSourcesBase): @classmethod def setUpClass(cls): - super(TestNovaPlugins, cls).setUpClass() + super(TestNovaDatasources, cls).setUpClass() cls.conf = cfg.ConfigOpts() cls.conf.register_opts(cls.PROCESSOR_OPTS, group='entity_graph') - cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins') - cls.load_plugins(cls.conf) + cls.conf.register_opts(cls.DATASOURCES_OPTS, group='datasources') + cls.load_datasources(cls.conf) - def test_nova_plugins(self): + def test_nova_datasources(self): processor = self._create_processor_with_graph(self.conf) self.assertEqual(self._num_total_expected_vertices(), diff --git a/vitrage/tests/functional/data_sources/cinder/__init__.py b/vitrage/tests/functional/datasources/static_physical/__init__.py similarity index 100% rename from vitrage/tests/functional/data_sources/cinder/__init__.py rename to vitrage/tests/functional/datasources/static_physical/__init__.py diff --git a/vitrage/tests/functional/data_sources/static_physical/test_static_physical.py b/vitrage/tests/functional/datasources/static_physical/test_static_physical.py similarity index 64% rename from vitrage/tests/functional/data_sources/static_physical/test_static_physical.py rename to vitrage/tests/functional/datasources/static_physical/test_static_physical.py index e70b4f018..f351877d1 100644 --- a/vitrage/tests/functional/data_sources/static_physical/test_static_physical.py +++ b/vitrage/tests/functional/datasources/static_physical/test_static_physical.py @@ -17,30 +17,30 @@ from oslo_config import cfg from vitrage.common.constants import EntityCategory from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import VertexProperties as VProps -from vitrage.synchronizer.plugins import NAGIOS_PLUGIN -from vitrage.synchronizer.plugins import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins import NOVA_INSTANCE_PLUGIN -from vitrage.synchronizer.plugins import NOVA_ZONE_PLUGIN -from vitrage.synchronizer.plugins.static_physical import STATIC_PHYSICAL_PLUGIN -from vitrage.synchronizer.plugins.static_physical import SWITCH -from vitrage.tests.functional.data_sources.base import \ +from vitrage.datasources import NAGIOS_DATASOURCE +from vitrage.datasources import NOVA_HOST_DATASOURCE +from vitrage.datasources import NOVA_INSTANCE_DATASOURCE +from vitrage.datasources import NOVA_ZONE_DATASOURCE +from vitrage.datasources.static_physical import STATIC_PHYSICAL_DATASOURCE +from vitrage.datasources.static_physical import SWITCH +from vitrage.tests.functional.datasources.base import \ TestDataSourcesBase -from vitrage.tests.mocks import mock_syncronizer as mock_sync +from vitrage.tests.mocks import mock_driver class TestStaticPhysical(TestDataSourcesBase): - PLUGINS_OPTS = [ - cfg.ListOpt('plugin_type', - default=[NAGIOS_PLUGIN, - NOVA_HOST_PLUGIN, - NOVA_INSTANCE_PLUGIN, - NOVA_ZONE_PLUGIN, - STATIC_PHYSICAL_PLUGIN], + DATASOURCES_OPTS = [ + cfg.ListOpt('types', + default=[NAGIOS_DATASOURCE, + NOVA_HOST_DATASOURCE, + NOVA_INSTANCE_DATASOURCE, + NOVA_ZONE_DATASOURCE, + STATIC_PHYSICAL_DATASOURCE], help='Names of supported driver data sources'), - cfg.ListOpt('plugin_path', - default=['vitrage.synchronizer.plugins'], + cfg.ListOpt('path', + default=['vitrage.datasources'], help='base path for data sources') ] @@ -49,27 +49,27 @@ class TestStaticPhysical(TestDataSourcesBase): super(TestStaticPhysical, cls).setUpClass() cls.conf = cfg.ConfigOpts() cls.conf.register_opts(cls.PROCESSOR_OPTS, group='entity_graph') - cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins') - cls.load_plugins(cls.conf) + cls.conf.register_opts(cls.DATASOURCES_OPTS, group='datasources') + cls.load_datasources(cls.conf) def test_static_physical_validity(self): # Setup processor = self._create_processor_with_graph(self.conf) - processor.transformer_manager.transformers[SWITCH] = \ - processor.transformer_manager.transformers[STATIC_PHYSICAL_PLUGIN] + transformers = processor.transformer_manager.transformers + transformers[SWITCH] = transformers[STATIC_PHYSICAL_DATASOURCE] self.assertEqual(self._num_total_expected_vertices(), len(processor.entity_graph)) - spec_list = mock_sync.simple_switch_generators( + spec_list = mock_driver.simple_switch_generators( switch_num=1, host_num=1, snapshot_events=1) - static_events = mock_sync.generate_random_events_list(spec_list) + static_events = mock_driver.generate_random_events_list(spec_list) static_physical_event = static_events[0] static_physical_event[SyncProps.SYNC_TYPE] = SWITCH static_physical_event['relationships'][0]['name'] = \ self._find_entity_id_by_type(processor.entity_graph, - NOVA_HOST_PLUGIN) + NOVA_HOST_DATASOURCE) # Action processor.process_event(static_physical_event) @@ -89,5 +89,5 @@ class TestStaticPhysical(TestDataSourcesBase): static_physical_vertices[0].vertex_id) self.assertEqual(1, len(static_physical_neighbors)) - self.assertEqual(NOVA_HOST_PLUGIN, + self.assertEqual(NOVA_HOST_DATASOURCE, static_physical_neighbors[0][VProps.TYPE]) diff --git a/vitrage/tests/functional/entity_graph/consistency/test_consistency.py b/vitrage/tests/functional/entity_graph/consistency/test_consistency.py index d2e572a21..8ae610c8c 100644 --- a/vitrage/tests/functional/entity_graph/consistency/test_consistency.py +++ b/vitrage/tests/functional/entity_graph/consistency/test_consistency.py @@ -24,6 +24,10 @@ from vitrage.common.constants import EdgeLabels from vitrage.common.constants import EntityCategory from vitrage.common.constants import VertexProperties as VProps from vitrage.common.datetime_utils import utcnow +from vitrage.datasources.nagios import NAGIOS_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.entity_graph.consistency.consistency_enforcer \ import ConsistencyEnforcer from vitrage.entity_graph.initialization_status import InitializationStatus @@ -32,12 +36,7 @@ from vitrage.evaluator.actions.evaluator_event_transformer import VITRAGE_TYPE from vitrage.evaluator.scenario_evaluator import ScenarioEvaluator from vitrage.evaluator.scenario_repository import ScenarioRepository import vitrage.graph.utils as graph_utils -from vitrage.synchronizer.plugins.nagios import NAGIOS_PLUGIN -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.nova.instance import NOVA_INSTANCE_PLUGIN -from vitrage.synchronizer.plugins.nova.zone import NOVA_ZONE_PLUGIN -from vitrage.tests.functional.base import \ - TestFunctionalBase +from vitrage.tests.functional.base import TestFunctionalBase from vitrage.tests.mocks import utils @@ -54,12 +53,6 @@ class TestConsistencyFunctional(TestFunctionalBase): default=10), ] - SYNCHRONIZER_OPTS = [ - cfg.IntOpt('snapshots_interval', - default=1, - min=1), - ] - EVALUATOR_OPTS = [ cfg.StrOpt('templates_dir', default=utils.get_resources_dir() + @@ -79,9 +72,8 @@ class TestConsistencyFunctional(TestFunctionalBase): cls.conf.register_opts(cls.CONSISTENCY_OPTS, group='consistency') cls.conf.register_opts(cls.PROCESSOR_OPTS, group='entity_graph') cls.conf.register_opts(cls.EVALUATOR_OPTS, group='evaluator') - cls.conf.register_opts(cls.SYNCHRONIZER_OPTS, group='synchronizer') - cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins') - cls.load_plugins(cls.conf) + cls.conf.register_opts(cls.DATASOURCES_OPTS, group='datasources') + cls.load_datasources(cls.conf) cls.processor = Processor(cls.conf, cls.initialization_status) cls.event_queue = queue.Queue() @@ -150,7 +142,7 @@ class TestConsistencyFunctional(TestFunctionalBase): def test_periodic_process(self): # Setup - consistency_interval = self.conf.synchronizer.snapshots_interval + consistency_interval = self.conf.datasources.snapshots_interval self._periodic_process_setup_stage(consistency_interval) # Action @@ -160,18 +152,18 @@ class TestConsistencyFunctional(TestFunctionalBase): # Test Assertions instance_vertices = self.processor.entity_graph.get_vertices({ VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: NOVA_INSTANCE_PLUGIN + VProps.TYPE: NOVA_INSTANCE_DATASOURCE }) - is_deleted_instance_vertices = \ + deleted_instance_vertices = \ self.processor.entity_graph.get_vertices({ VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: NOVA_INSTANCE_PLUGIN, + VProps.TYPE: NOVA_INSTANCE_DATASOURCE, VProps.IS_DELETED: True }) self.assertEqual(self.NUM_INSTANCES - 3, len(instance_vertices)) self.assertEqual(self._num_total_expected_vertices() - 3, len(self.processor.entity_graph.get_vertices())) - self.assertEqual(6, len(is_deleted_instance_vertices)) + self.assertEqual(6, len(deleted_instance_vertices)) def _periodic_process_setup_stage(self, consistency_interval): self._create_processor_with_graph(self.conf, processor=self.processor) @@ -185,7 +177,7 @@ 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_PLUGIN + VProps.TYPE: NOVA_INSTANCE_DATASOURCE }) self.assertEqual(self.NUM_INSTANCES, len(instance_vertices)) @@ -205,11 +197,11 @@ class TestConsistencyFunctional(TestFunctionalBase): self.processor.entity_graph.update_vertex(instance_vertices[i]) def _set_end_messages(self): - self.initialization_status.end_messages[NOVA_ZONE_PLUGIN] = True - self.initialization_status.end_messages[NOVA_HOST_PLUGIN] = True - self.initialization_status.end_messages[NOVA_INSTANCE_PLUGIN] = \ + self.initialization_status.end_messages[NOVA_ZONE_DATASOURCE] = True + self.initialization_status.end_messages[NOVA_HOST_DATASOURCE] = True + self.initialization_status.end_messages[NOVA_INSTANCE_DATASOURCE] = \ True - self.initialization_status.end_messages[NAGIOS_PLUGIN] = True + self.initialization_status.end_messages[NAGIOS_DATASOURCE] = True self.initialization_status.status = \ self.initialization_status.RECEIVED_ALL_END_MESSAGES @@ -217,7 +209,7 @@ class TestConsistencyFunctional(TestFunctionalBase): # find hosts and instances host_vertices = self.processor.entity_graph.get_vertices({ VProps.CATEGORY: EntityCategory.RESOURCE, - VProps.TYPE: NOVA_HOST_PLUGIN + VProps.TYPE: NOVA_HOST_DATASOURCE }) # add host alarms + deduced alarms @@ -227,7 +219,7 @@ class TestConsistencyFunctional(TestFunctionalBase): alarm_name = '%s:%s' % ('nagios_alarm_on_host_', host_vertex[VProps.NAME]) alarms_on_hosts_list.append( - self._create_alarm(alarm_name, NAGIOS_PLUGIN)) + self._create_alarm(alarm_name, NAGIOS_DATASOURCE)) self.processor.entity_graph.add_vertex(alarms_on_hosts_list[index]) edge = graph_utils.create_edge( alarms_on_hosts_list[index].vertex_id, diff --git a/vitrage/tests/functional/entity_graph/processor/test_processor.py b/vitrage/tests/functional/entity_graph/processor/test_processor.py index 6ea638853..37aafff19 100644 --- a/vitrage/tests/functional/entity_graph/processor/test_processor.py +++ b/vitrage/tests/functional/entity_graph/processor/test_processor.py @@ -30,8 +30,8 @@ class TestProcessorFunctional(TestFunctionalBase): super(TestProcessorFunctional, cls).setUpClass() cls.conf = cfg.ConfigOpts() cls.conf.register_opts(cls.PROCESSOR_OPTS, group='entity_graph') - cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins') - cls.load_plugins(cls.conf) + cls.conf.register_opts(cls.DATASOURCES_OPTS, group='datasources') + cls.load_datasources(cls.conf) def test_create_entity_graph(self): processor = self._create_processor_with_graph(self.conf) diff --git a/vitrage/tests/functional/entity_graph/states/test_state_manager.py b/vitrage/tests/functional/entity_graph/states/test_state_manager.py index 293846445..b383f8788 100644 --- a/vitrage/tests/functional/entity_graph/states/test_state_manager.py +++ b/vitrage/tests/functional/entity_graph/states/test_state_manager.py @@ -17,14 +17,12 @@ from oslo_config import cfg from vitrage.common.constants import EventAction from vitrage.common.constants import SyncMode from vitrage.common.constants import VertexProperties as VProps +from vitrage.datasources.nova.instance.transformer import InstanceTransformer from vitrage.entity_graph.initialization_status import InitializationStatus from vitrage.entity_graph.processor import processor as proc from vitrage.entity_graph.states.normalized_resource_state import \ NormalizedResourceState -from vitrage.synchronizer.plugins.nova.instance.transformer import \ - InstanceTransformer -from vitrage.tests.functional.base import \ - TestFunctionalBase +from vitrage.tests.functional.base import TestFunctionalBase class TestStateManagerFunctional(TestFunctionalBase): @@ -35,8 +33,8 @@ class TestStateManagerFunctional(TestFunctionalBase): super(TestStateManagerFunctional, cls).setUpClass() cls.conf = cfg.ConfigOpts() cls.conf.register_opts(cls.PROCESSOR_OPTS, group='entity_graph') - cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins') - cls.load_plugins(cls.conf) + cls.conf.register_opts(cls.DATASOURCES_OPTS, group='datasources') + cls.load_datasources(cls.conf) def test_state_on_update(self): # setup diff --git a/vitrage/tests/functional/evaluator/test_action_executor.py b/vitrage/tests/functional/evaluator/test_action_executor.py index dcabc9e6b..13aa70ad1 100644 --- a/vitrage/tests/functional/evaluator/test_action_executor.py +++ b/vitrage/tests/functional/evaluator/test_action_executor.py @@ -20,6 +20,9 @@ from six.moves import queue from vitrage.common.constants import EdgeLabels from vitrage.common.constants import EntityCategory 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.nova.host import NOVA_HOST_DATASOURCE from vitrage.entity_graph.states.normalized_resource_state import \ NormalizedResourceState from vitrage.evaluator.actions.action_executor import ActionExecutor @@ -28,13 +31,8 @@ from vitrage.evaluator.actions.base import ActionType from vitrage.evaluator.actions.evaluator_event_transformer import VITRAGE_TYPE from vitrage.evaluator.template import ActionSpecs from vitrage.evaluator.template_fields import TemplateFields as TFields -from vitrage.service import load_plugin -from vitrage.synchronizer.plugins.base.alarm.properties \ - import AlarmProperties as AlarmProps -from vitrage.synchronizer.plugins.nagios import NAGIOS_PLUGIN -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.tests.functional.base import \ - TestFunctionalBase +from vitrage.service import load_datasource +from vitrage.tests.functional.base import TestFunctionalBase LOG = logging.getLogger(__name__) @@ -46,16 +44,19 @@ class TestActionExecutor(TestFunctionalBase): def setUpClass(cls): cls.conf = cfg.ConfigOpts() cls.conf.register_opts(cls.PROCESSOR_OPTS, group='entity_graph') - cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins') - for plugin_name in cls.conf.plugins.plugin_type: - load_plugin(cls.conf, plugin_name, cls.conf.plugins.plugin_path) + cls.conf.register_opts(cls.DATASOURCES_OPTS, group='datasources') + + for datasource_name in cls.conf.datasources.types: + load_datasource(cls.conf, + datasource_name, + cls.conf.datasources.path) def test_execute_update_vertex(self): # Test Setup processor = self._create_processor_with_graph(self.conf) - vertex_attrs = {VProps.TYPE: NOVA_HOST_PLUGIN} + vertex_attrs = {VProps.TYPE: NOVA_HOST_DATASOURCE} host_vertices = processor.entity_graph.get_vertices( vertex_attr_filter=vertex_attrs) host_vertex_before = host_vertices[0] @@ -102,21 +103,21 @@ class TestActionExecutor(TestFunctionalBase): # Test Setup processor = self._create_processor_with_graph(self.conf) - vertex_attrs = {VProps.TYPE: NOVA_HOST_PLUGIN} + vertex_attrs = {VProps.TYPE: NOVA_HOST_DATASOURCE} host_vertices = processor.entity_graph.get_vertices( vertex_attr_filter=vertex_attrs) host_1 = host_vertices[0] nagios_event1 = TestActionExecutor._get_nagios_event( - host_1.get(VProps.ID), NOVA_HOST_PLUGIN) + host_1.get(VProps.ID), NOVA_HOST_DATASOURCE) processor.process_event(nagios_event1) host_2 = host_vertices[1] nagios_event2 = TestActionExecutor._get_nagios_event( - host_2.get(VProps.ID), NOVA_HOST_PLUGIN) + host_2.get(VProps.ID), NOVA_HOST_DATASOURCE) processor.process_event(nagios_event2) - alarms_attrs = {VProps.TYPE: NAGIOS_PLUGIN} + alarms_attrs = {VProps.TYPE: NAGIOS_DATASOURCE} alarms_vertices = processor.entity_graph.get_vertices( vertex_attr_filter=alarms_attrs) @@ -152,7 +153,7 @@ class TestActionExecutor(TestFunctionalBase): # Test Setup processor = self._create_processor_with_graph(self.conf) - vertex_attrs = {VProps.TYPE: NOVA_HOST_PLUGIN} + vertex_attrs = {VProps.TYPE: NOVA_HOST_DATASOURCE} host_vertices = processor.entity_graph.get_vertices( vertex_attr_filter=vertex_attrs) @@ -209,7 +210,7 @@ class TestActionExecutor(TestFunctionalBase): # Test Setup processor = self._create_processor_with_graph(self.conf) - vertex_attrs = {VProps.TYPE: NOVA_HOST_PLUGIN} + vertex_attrs = {VProps.TYPE: NOVA_HOST_DATASOURCE} host_vertices = processor.entity_graph.get_vertices( vertex_attr_filter=vertex_attrs) diff --git a/vitrage/tests/functional/evaluator/test_scenario_evaluator.py b/vitrage/tests/functional/evaluator/test_scenario_evaluator.py index 748565625..dfc0bfa75 100644 --- a/vitrage/tests/functional/evaluator/test_scenario_evaluator.py +++ b/vitrage/tests/functional/evaluator/test_scenario_evaluator.py @@ -17,9 +17,9 @@ from oslo_log import log as logging from six.moves import queue from vitrage.common.constants import VertexProperties as VProps +from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE from vitrage.evaluator.scenario_evaluator import ScenarioEvaluator from vitrage.evaluator.scenario_repository import ScenarioRepository -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN from vitrage.tests.functional.base import \ TestFunctionalBase from vitrage.tests.mocks import utils @@ -45,8 +45,8 @@ class TestScenarioEvaluator(TestFunctionalBase): cls.conf = cfg.ConfigOpts() cls.conf.register_opts(cls.PROCESSOR_OPTS, group='entity_graph') cls.conf.register_opts(cls.EVALUATOR_OPTS, group='evaluator') - cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins') - TestScenarioEvaluator.load_plugins(cls.conf) + cls.conf.register_opts(cls.DATASOURCES_OPTS, group='datasources') + TestScenarioEvaluator.load_datasources(cls.conf) cls.scenario_repository = ScenarioRepository(cls.conf) def test_deduced_state(self): @@ -67,7 +67,7 @@ class TestScenarioEvaluator(TestFunctionalBase): nagios_event = {'last_check': '2016-02-07 15:26:04', 'resource_name': target_host, - 'resource_type': NOVA_HOST_PLUGIN, + 'resource_type': NOVA_HOST_DATASOURCE, 'service': 'Check_MK', 'status': 'CRITICAL', 'status_info': 'ok', @@ -94,7 +94,7 @@ class TestScenarioEvaluator(TestFunctionalBase): @staticmethod def _get_host_from_graph(host_name, entity_graph): - vertex_attrs = {VProps.TYPE: NOVA_HOST_PLUGIN, + vertex_attrs = {VProps.TYPE: NOVA_HOST_DATASOURCE, VProps.NAME: host_name} host_vertices = entity_graph.get_vertices( vertex_attr_filter=vertex_attrs) diff --git a/vitrage/tests/mocks/mock_syncronizer.py b/vitrage/tests/mocks/mock_driver.py similarity index 90% rename from vitrage/tests/mocks/mock_syncronizer.py rename to vitrage/tests/mocks/mock_driver.py index 7afce7b20..c2bd32b1b 100644 --- a/vitrage/tests/mocks/mock_syncronizer.py +++ b/vitrage/tests/mocks/mock_driver.py @@ -13,15 +13,15 @@ # under the License. -"""Methods for generating synchronizer events +"""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 sync events +regex of) what can be returned, which will be used to generate driver events usage example: test_entity_spec_list = [ - {mg.DYNAMIC_INFO_FKEY: 'sync_inst_snapshot_dynamic.json', - mg.STATIC_INFO_FKEY: 'sync_inst_snapshot_static.json', + {mg.DYNAMIC_INFO_FKEY: 'driver_inst_snapshot_dynamic.json', + mg.STATIC_INFO_FKEY: 'driver_inst_snapshot_static.json', mg.MAPPING_KEY: [('vm1', 'host1'), ('vm2', 'host1'), ('vm3','host2')], mg.NAME_KEY: 'Instance (vm) generator', NUM_EVENTS_KEY: 10 @@ -47,7 +47,7 @@ def generate_random_events_list(generator_spec_list): :param generator_spec_list: list of generators :type generator_spec_list: list - :return list of synchronizer events + :return list of driver events :rtype list """ @@ -69,7 +69,7 @@ def generate_sequential_events_list(generator_spec_list): :param generator_spec_list: list of generators :type generator_spec_list: list - :return list of synchronizer events + :return list of driver events :rtype list """ @@ -106,8 +106,8 @@ def simple_instance_generators(host_num, vm_num, test_entity_spec_list = [] if snapshot_events: test_entity_spec_list.append( - {tg.DYNAMIC_INFO_FKEY: tg.SYNC_INST_SNAPSHOT_D, - tg.STATIC_INFO_FKEY: tg.SYNC_INST_SNAPSHOT_S, + {tg.DYNAMIC_INFO_FKEY: tg.DRIVER_INST_SNAPSHOT_D, + tg.STATIC_INFO_FKEY: tg.DRIVER_INST_SNAPSHOT_S, tg.EXTERNAL_INFO_KEY: snap_vals, tg.MAPPING_KEY: mapping, tg.NAME_KEY: 'Instance (vm) snapshot generator', @@ -116,7 +116,7 @@ def simple_instance_generators(host_num, vm_num, ) if update_events: test_entity_spec_list.append( - {tg.DYNAMIC_INFO_FKEY: tg.SYNC_INST_UPDATE_D, + {tg.DYNAMIC_INFO_FKEY: tg.DRIVER_INST_UPDATE_D, tg.STATIC_INFO_FKEY: None, tg.EXTERNAL_INFO_KEY: update_vals, tg.MAPPING_KEY: mapping, @@ -148,7 +148,7 @@ def simple_host_generators(zone_num, host_num, snapshot_events=0, test_entity_spec_list = [] if snapshot_events: test_entity_spec_list.append( - {tg.DYNAMIC_INFO_FKEY: tg.SYNC_HOST_SNAPSHOT_D, + {tg.DYNAMIC_INFO_FKEY: tg.DRIVER_HOST_SNAPSHOT_D, tg.STATIC_INFO_FKEY: None, tg.EXTERNAL_INFO_KEY: snap_vals, tg.MAPPING_KEY: mapping, @@ -180,7 +180,7 @@ def simple_zone_generators(zone_num, host_num, snapshot_events=0, test_entity_spec_list = [] if snapshot_events: test_entity_spec_list.append( - {tg.DYNAMIC_INFO_FKEY: tg.SYNC_ZONE_SNAPSHOT_D, + {tg.DYNAMIC_INFO_FKEY: tg.DRIVER_ZONE_SNAPSHOT_D, tg.STATIC_INFO_FKEY: None, tg.EXTERNAL_INFO_KEY: snap_vals, tg.MAPPING_KEY: mapping, @@ -214,7 +214,7 @@ def simple_volume_generators(volume_num, instance_num, test_entity_spec_list = [] if snapshot_events: test_entity_spec_list.append( - {tg.DYNAMIC_INFO_FKEY: tg.SYNC_VOLUME_SNAPSHOT_D, + {tg.DYNAMIC_INFO_FKEY: tg.DRIVER_VOLUME_SNAPSHOT_D, tg.STATIC_INFO_FKEY: None, tg.EXTERNAL_INFO_KEY: snap_vals, tg.MAPPING_KEY: mapping, @@ -224,7 +224,7 @@ def simple_volume_generators(volume_num, instance_num, ) if update_events: test_entity_spec_list.append( - {tg.DYNAMIC_INFO_FKEY: tg.SYNC_VOLUME_UPDATE_D, + {tg.DYNAMIC_INFO_FKEY: tg.DRIVER_VOLUME_UPDATE_D, tg.STATIC_INFO_FKEY: None, tg.EXTERNAL_INFO_KEY: update_vals, tg.MAPPING_KEY: mapping, @@ -259,7 +259,7 @@ def simple_switch_generators(switch_num, host_num, test_entity_spec_list = [] if snapshot_events: test_entity_spec_list.append( - {tg.DYNAMIC_INFO_FKEY: tg.SYNC_SWITCH_SNAPSHOT_D, + {tg.DYNAMIC_INFO_FKEY: tg.DRIVER_SWITCH_SNAPSHOT_D, tg.STATIC_INFO_FKEY: None, tg.EXTERNAL_INFO_KEY: snap_vals, tg.MAPPING_KEY: mapping, @@ -271,7 +271,7 @@ def simple_switch_generators(switch_num, host_num, update_vals = {} if not update_vals else update_vals update_vals['sync_mode'] = 'update' test_entity_spec_list.append( - {tg.DYNAMIC_INFO_FKEY: tg.SYNC_SWITCH_SNAPSHOT_D, + {tg.DYNAMIC_INFO_FKEY: tg.DRIVER_SWITCH_SNAPSHOT_D, tg.STATIC_INFO_FKEY: None, tg.EXTERNAL_INFO_KEY: update_vals, tg.MAPPING_KEY: mapping, @@ -300,7 +300,7 @@ def simple_nagios_alarm_generators(host_num, test_entity_spec_list = [] if events_num: test_entity_spec_list.append({ - tg.DYNAMIC_INFO_FKEY: tg.SYNC_NAGIOS_SNAPSHOT_D, + tg.DYNAMIC_INFO_FKEY: tg.DRIVER_NAGIOS_SNAPSHOT_D, tg.STATIC_INFO_FKEY: None, tg.EXTERNAL_INFO_KEY: snap_vals, tg.MAPPING_KEY: hosts, @@ -308,8 +308,8 @@ def simple_nagios_alarm_generators(host_num, tg.NUM_EVENTS: max(events_num - len(hosts), 0) }) test_entity_spec_list.append({ - tg.DYNAMIC_INFO_FKEY: tg.SYNC_NAGIOS_SNAPSHOT_D, - tg.STATIC_INFO_FKEY: tg.SYNC_NAGIOS_SNAPSHOT_S, + tg.DYNAMIC_INFO_FKEY: tg.DRIVER_NAGIOS_SNAPSHOT_D, + tg.STATIC_INFO_FKEY: tg.DRIVER_NAGIOS_SNAPSHOT_S, tg.EXTERNAL_INFO_KEY: snap_vals, tg.MAPPING_KEY: hosts, tg.NAME_KEY: 'Nagios alarm generator (alarm off)', diff --git a/vitrage/tests/mocks/trace_generator.py b/vitrage/tests/mocks/trace_generator.py index 608667b23..15b6c3dee 100644 --- a/vitrage/tests/mocks/trace_generator.py +++ b/vitrage/tests/mocks/trace_generator.py @@ -27,7 +27,7 @@ from random import randint import exrex # noinspection PyPep8Naming -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN +from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE from vitrage.tests.mocks.entity_model import BasicEntityModel as Bem import vitrage.tests.mocks.utils as utils @@ -42,17 +42,18 @@ GENERATOR = 'generator' # specification files for input types -# Mock synchronizer specs -SYNC_INST_SNAPSHOT_D = 'sync_inst_snapshot_dynamic.json' -SYNC_INST_SNAPSHOT_S = 'sync_inst_snapshot_static.json' -SYNC_INST_UPDATE_D = 'sync_inst_update_dynamic.json' -SYNC_HOST_SNAPSHOT_D = 'sync_host_snapshot_dynamic.json' -SYNC_ZONE_SNAPSHOT_D = 'sync_zone_snapshot_dynamic.json' -SYNC_VOLUME_SNAPSHOT_D = 'sync_volume_snapshot_dynamic.json' -SYNC_VOLUME_UPDATE_D = 'sync_volume_update_dynamic.json' -SYNC_SWITCH_SNAPSHOT_D = 'sync_switch_snapshot_dynamic.json' -SYNC_NAGIOS_SNAPSHOT_D = 'sync_nagios_snapshot_dynamic.json' -SYNC_NAGIOS_SNAPSHOT_S = 'sync_nagios_snapshot_static.json' +# Mock driver specs +DRIVER_HOST_SNAPSHOT_D = 'driver_host_snapshot_dynamic.json' +DRIVER_INST_SNAPSHOT_D = 'driver_inst_snapshot_dynamic.json' +DRIVER_INST_SNAPSHOT_S = 'driver_inst_snapshot_static.json' +DRIVER_INST_UPDATE_D = 'driver_inst_update_dynamic.json' +DRIVER_NAGIOS_SNAPSHOT_D = 'driver_nagios_snapshot_dynamic.json' +DRIVER_NAGIOS_SNAPSHOT_S = 'driver_nagios_snapshot_static.json' +DRIVER_SWITCH_SNAPSHOT_D = 'driver_switch_snapshot_dynamic.json' +DRIVER_VOLUME_UPDATE_D = 'driver_volume_update_dynamic.json' +DRIVER_VOLUME_SNAPSHOT_D = 'driver_volume_snapshot_dynamic.json' +DRIVER_ZONE_SNAPSHOT_D = 'driver_zone_snapshot_dynamic.json' + # Mock transformer Specs (i.e., what the transformer outputs) TRANS_INST_SNAPSHOT_D = 'transformer_inst_snapshot_dynamic.json' @@ -96,14 +97,14 @@ class EventTraceGenerator(object): """ static_info_parsers = \ - {SYNC_INST_SNAPSHOT_D: _get_sync_vm_snapshot_values, - SYNC_INST_UPDATE_D: _get_sync_vm_update_values, - SYNC_HOST_SNAPSHOT_D: _get_sync_host_snapshot_values, - SYNC_ZONE_SNAPSHOT_D: _get_sync_zone_snapshot_values, - SYNC_VOLUME_SNAPSHOT_D: _get_sync_volume_snapshot_values, - SYNC_VOLUME_UPDATE_D: _get_sync_volume_update_values, - SYNC_SWITCH_SNAPSHOT_D: _get_sync_switch_snapshot_values, - SYNC_NAGIOS_SNAPSHOT_D: _get_sync_nagios_alarm_values, + {DRIVER_INST_SNAPSHOT_D: _get_vm_snapshot_driver_values, + DRIVER_INST_UPDATE_D: _get_vm_update_driver_values, + DRIVER_HOST_SNAPSHOT_D: _get_host_snapshot_driver_values, + DRIVER_ZONE_SNAPSHOT_D: _get_zone_snapshot_driver_values, + DRIVER_VOLUME_SNAPSHOT_D: _get_volume_snapshot_driver_values, + DRIVER_VOLUME_UPDATE_D: _get_volume_update_driver_values, + DRIVER_SWITCH_SNAPSHOT_D: _get_switch_snapshot_driver_values, + DRIVER_NAGIOS_SNAPSHOT_D: _get_nagios_alarm_driver_values, TRANS_INST_SNAPSHOT_D: _get_trans_vm_snapshot_values, TRANS_HOST_SNAPSHOT_D: _get_trans_host_snapshot_values, @@ -163,12 +164,12 @@ def generate_round_robin_data_stream(models, event_num=100): return data_stream -def _get_sync_vm_snapshot_values(spec): - """Generates the static synchronizer values for each vm. +def _get_vm_snapshot_driver_values(spec): + """Generates the static driver values for each vm. :param spec: specification of event generation. :type spec: dict - :return: list of static synchronizer values for each vm. + :return: list of static driver values for each vm. :rtype: list """ @@ -193,12 +194,12 @@ def _get_sync_vm_snapshot_values(spec): return static_values -def _get_sync_host_snapshot_values(spec): - """Generates the static synchronizer values for each host. +def _get_host_snapshot_driver_values(spec): + """Generates the static driver values for each host. :param spec: specification of event generation. :type spec: dict - :return: list of static synchronizer values for each host. + :return: list of static driver values for each host. :rtype: list """ @@ -219,12 +220,12 @@ def _get_sync_host_snapshot_values(spec): return static_values -def _get_sync_zone_snapshot_values(spec): - """Generates the static synchronizer values for each zone. +def _get_zone_snapshot_driver_values(spec): + """Generates the static driver values for each zone. :param spec: specification of event generation. :type spec: dict - :return: list of static synchronizer values for each host. + :return: list of static driver values for each host. :rtype: list """ @@ -261,12 +262,12 @@ def _get_sync_zone_snapshot_values(spec): return static_values -def _get_sync_volume_snapshot_values(spec): - """Generates the static synchronizer values for each volume. +def _get_volume_snapshot_driver_values(spec): + """Generates the static driver values for each volume. :param spec: specification of event generation. :type spec: dict - :return: list of static synchronizer values for each volume. + :return: list of static driver values for each volume. :rtype: list """ @@ -286,12 +287,12 @@ def _get_sync_volume_snapshot_values(spec): return static_values -def _get_sync_volume_update_values(spec): - """Generates the static synchronizer values for each volume. +def _get_volume_update_driver_values(spec): + """Generates the static driver values for each volume. :param spec: specification of event generation. :type spec: dict - :return: list of static synchronizer values for each volume. + :return: list of static driver values for each volume. :rtype: list """ @@ -336,12 +337,12 @@ def _get_trans_vm_snapshot_values(spec): return static_values -def _get_sync_vm_update_values(spec): - """Generates the static synchronizer values for each vm, for updates. +def _get_vm_update_driver_values(spec): + """Generates the static driver values for each vm, for updates. :param spec: specification of event generation. :type spec: dict - :return: list of static synchronizer values for each vm updates. + :return: list of static driver values for each vm updates. :rtype: list """ @@ -360,12 +361,12 @@ def _get_sync_vm_update_values(spec): return static_values -def _get_sync_switch_snapshot_values(spec): - """Generates the static synchronizer values for each zone. +def _get_switch_snapshot_driver_values(spec): + """Generates the static driver values for each zone. :param spec: specification of event generation. :type spec: dict - :return: list of static synchronizer values for each zone. + :return: list of static driver values for each zone. :rtype: list """ @@ -380,7 +381,7 @@ def _get_sync_switch_snapshot_values(spec): for host_name, switch_name in host_switch_mapping: switch_info = switches_info.get(switch_name, []) - relationship_info = {"type": NOVA_HOST_PLUGIN, + relationship_info = {"type": NOVA_HOST_DATASOURCE, "name": host_name, "id": host_name, "relation_type": "contains" @@ -400,7 +401,7 @@ def _get_sync_switch_snapshot_values(spec): return static_values -def _get_sync_nagios_alarm_values(spec): +def _get_nagios_alarm_driver_values(spec): hosts = spec[MAPPING_KEY] static_info_re = None if spec[STATIC_INFO_FKEY] is not None: @@ -416,11 +417,11 @@ def _get_sync_nagios_alarm_values(spec): def _get_trans_host_snapshot_values(spec): - """Generates the static synchronizer values for each host. + """Generates the static driver values for each host. :param spec: specification of event generation. :type spec: dict - :return: list of static synchronizer values for each host. + :return: list of static driver values for each host. :rtype: list """ @@ -441,11 +442,11 @@ def _get_trans_host_snapshot_values(spec): def _get_trans_zone_snapshot_values(spec): - """Generates the static synchronizer values for each zone. + """Generates the static driver values for each zone. :param spec: specification of event generation. :type spec: dict - :return: list of static synchronizer values for each zone. + :return: list of static driver values for each zone. :rtype: list """ diff --git a/vitrage/tests/resources/states_plugins/erroneous_states_plugins/nagios.yaml b/vitrage/tests/resources/datasources_states/erroneous_states/nagios.yaml similarity index 100% rename from vitrage/tests/resources/states_plugins/erroneous_states_plugins/nagios.yaml rename to vitrage/tests/resources/datasources_states/erroneous_states/nagios.yaml diff --git a/vitrage/tests/resources/states_plugins/erroneous_states_plugins/nova.host.yaml b/vitrage/tests/resources/datasources_states/erroneous_states/nova.host.yaml similarity index 100% rename from vitrage/tests/resources/states_plugins/erroneous_states_plugins/nova.host.yaml rename to vitrage/tests/resources/datasources_states/erroneous_states/nova.host.yaml diff --git a/vitrage/tests/resources/states_plugins/erroneous_states_plugins/nova.instance.yaml b/vitrage/tests/resources/datasources_states/erroneous_states/nova.instance.yaml similarity index 100% rename from vitrage/tests/resources/states_plugins/erroneous_states_plugins/nova.instance.yaml rename to vitrage/tests/resources/datasources_states/erroneous_states/nova.instance.yaml diff --git a/vitrage/tests/resources/states_plugins/nagios.yaml b/vitrage/tests/resources/datasources_states/nagios.yaml similarity index 100% rename from vitrage/tests/resources/states_plugins/nagios.yaml rename to vitrage/tests/resources/datasources_states/nagios.yaml diff --git a/vitrage/tests/resources/states_plugins/nova.host.yaml b/vitrage/tests/resources/datasources_states/nova.host.yaml similarity index 100% rename from vitrage/tests/resources/states_plugins/nova.host.yaml rename to vitrage/tests/resources/datasources_states/nova.host.yaml diff --git a/vitrage/tests/resources/states_plugins/nova.instance.yaml b/vitrage/tests/resources/datasources_states/nova.instance.yaml similarity index 100% rename from vitrage/tests/resources/states_plugins/nova.instance.yaml rename to vitrage/tests/resources/datasources_states/nova.instance.yaml diff --git a/vitrage/tests/resources/states_plugins/nova.zone.yaml b/vitrage/tests/resources/datasources_states/nova.zone.yaml similarity index 100% rename from vitrage/tests/resources/states_plugins/nova.zone.yaml rename to vitrage/tests/resources/datasources_states/nova.zone.yaml diff --git a/vitrage/tests/resources/states_plugins/vitrage.yaml b/vitrage/tests/resources/datasources_states/vitrage.yaml similarity index 100% rename from vitrage/tests/resources/states_plugins/vitrage.yaml rename to vitrage/tests/resources/datasources_states/vitrage.yaml diff --git a/vitrage/tests/resources/mock_configurations/synchronizer/sync_host_snapshot_dynamic.json b/vitrage/tests/resources/mock_configurations/synchronizer/driver_host_snapshot_dynamic.json similarity index 100% rename from vitrage/tests/resources/mock_configurations/synchronizer/sync_host_snapshot_dynamic.json rename to vitrage/tests/resources/mock_configurations/synchronizer/driver_host_snapshot_dynamic.json diff --git a/vitrage/tests/resources/mock_configurations/synchronizer/sync_inst_snapshot_dynamic.json b/vitrage/tests/resources/mock_configurations/synchronizer/driver_inst_snapshot_dynamic.json similarity index 100% rename from vitrage/tests/resources/mock_configurations/synchronizer/sync_inst_snapshot_dynamic.json rename to vitrage/tests/resources/mock_configurations/synchronizer/driver_inst_snapshot_dynamic.json diff --git a/vitrage/tests/resources/mock_configurations/synchronizer/sync_inst_snapshot_static.json b/vitrage/tests/resources/mock_configurations/synchronizer/driver_inst_snapshot_static.json similarity index 100% rename from vitrage/tests/resources/mock_configurations/synchronizer/sync_inst_snapshot_static.json rename to vitrage/tests/resources/mock_configurations/synchronizer/driver_inst_snapshot_static.json diff --git a/vitrage/tests/resources/mock_configurations/synchronizer/sync_inst_update_dynamic.json b/vitrage/tests/resources/mock_configurations/synchronizer/driver_inst_update_dynamic.json similarity index 100% rename from vitrage/tests/resources/mock_configurations/synchronizer/sync_inst_update_dynamic.json rename to vitrage/tests/resources/mock_configurations/synchronizer/driver_inst_update_dynamic.json diff --git a/vitrage/tests/resources/mock_configurations/synchronizer/sync_nagios_snapshot_dynamic.json b/vitrage/tests/resources/mock_configurations/synchronizer/driver_nagios_snapshot_dynamic.json similarity index 100% rename from vitrage/tests/resources/mock_configurations/synchronizer/sync_nagios_snapshot_dynamic.json rename to vitrage/tests/resources/mock_configurations/synchronizer/driver_nagios_snapshot_dynamic.json diff --git a/vitrage/tests/resources/mock_configurations/synchronizer/sync_nagios_snapshot_static.json b/vitrage/tests/resources/mock_configurations/synchronizer/driver_nagios_snapshot_static.json similarity index 100% rename from vitrage/tests/resources/mock_configurations/synchronizer/sync_nagios_snapshot_static.json rename to vitrage/tests/resources/mock_configurations/synchronizer/driver_nagios_snapshot_static.json diff --git a/vitrage/tests/resources/mock_configurations/synchronizer/sync_switch_snapshot_dynamic.json b/vitrage/tests/resources/mock_configurations/synchronizer/driver_switch_snapshot_dynamic.json similarity index 100% rename from vitrage/tests/resources/mock_configurations/synchronizer/sync_switch_snapshot_dynamic.json rename to vitrage/tests/resources/mock_configurations/synchronizer/driver_switch_snapshot_dynamic.json diff --git a/vitrage/tests/resources/mock_configurations/synchronizer/sync_volume_snapshot_dynamic.json b/vitrage/tests/resources/mock_configurations/synchronizer/driver_volume_snapshot_dynamic.json similarity index 100% rename from vitrage/tests/resources/mock_configurations/synchronizer/sync_volume_snapshot_dynamic.json rename to vitrage/tests/resources/mock_configurations/synchronizer/driver_volume_snapshot_dynamic.json diff --git a/vitrage/tests/resources/mock_configurations/synchronizer/sync_volume_update_dynamic.json b/vitrage/tests/resources/mock_configurations/synchronizer/driver_volume_update_dynamic.json similarity index 100% rename from vitrage/tests/resources/mock_configurations/synchronizer/sync_volume_update_dynamic.json rename to vitrage/tests/resources/mock_configurations/synchronizer/driver_volume_update_dynamic.json diff --git a/vitrage/tests/resources/mock_configurations/synchronizer/sync_zone_snapshot_dynamic.json b/vitrage/tests/resources/mock_configurations/synchronizer/driver_zone_snapshot_dynamic.json similarity index 100% rename from vitrage/tests/resources/mock_configurations/synchronizer/sync_zone_snapshot_dynamic.json rename to vitrage/tests/resources/mock_configurations/synchronizer/driver_zone_snapshot_dynamic.json diff --git a/vitrage/tests/resources/static_plugins/changes_plugins/switch_to_host_plugin.yaml b/vitrage/tests/resources/static_datasources/changes_datasources/switch_to_host_plugin.yaml similarity index 96% rename from vitrage/tests/resources/static_plugins/changes_plugins/switch_to_host_plugin.yaml rename to vitrage/tests/resources/static_datasources/changes_datasources/switch_to_host_plugin.yaml index 603c6f316..0ad50e908 100644 --- a/vitrage/tests/resources/static_plugins/changes_plugins/switch_to_host_plugin.yaml +++ b/vitrage/tests/resources/static_datasources/changes_datasources/switch_to_host_plugin.yaml @@ -38,4 +38,4 @@ entities: - type: nova.host name: host-3 id: 3 - relation_type: attached \ No newline at end of file + relation_type: attached diff --git a/vitrage/tests/resources/static_plugins/changes_plugins/switch_to_switch_plugin.yaml b/vitrage/tests/resources/static_datasources/changes_datasources/switch_to_switch_plugin.yaml similarity index 91% rename from vitrage/tests/resources/static_plugins/changes_plugins/switch_to_switch_plugin.yaml rename to vitrage/tests/resources/static_datasources/changes_datasources/switch_to_switch_plugin.yaml index d484b29b7..d53a7ec46 100644 --- a/vitrage/tests/resources/static_plugins/changes_plugins/switch_to_switch_plugin.yaml +++ b/vitrage/tests/resources/static_datasources/changes_datasources/switch_to_switch_plugin.yaml @@ -16,4 +16,4 @@ entities: - type: switch name: switch-3 id: 34567 - relation_type: backup \ No newline at end of file + relation_type: backup diff --git a/vitrage/tests/resources/static_plugins/switch_to_host_plugin.yaml b/vitrage/tests/resources/static_datasources/switch_to_host_plugin.yaml similarity index 96% rename from vitrage/tests/resources/static_plugins/switch_to_host_plugin.yaml rename to vitrage/tests/resources/static_datasources/switch_to_host_plugin.yaml index 716629868..b8295bc07 100644 --- a/vitrage/tests/resources/static_plugins/switch_to_host_plugin.yaml +++ b/vitrage/tests/resources/static_datasources/switch_to_host_plugin.yaml @@ -37,4 +37,4 @@ entities: - type: nova.host name: host-4 id: 4 - relation_type: attached \ No newline at end of file + relation_type: attached diff --git a/vitrage/tests/resources/static_plugins/switch_to_switch_plugin.yaml b/vitrage/tests/resources/static_datasources/switch_to_switch_plugin.yaml similarity index 91% rename from vitrage/tests/resources/static_plugins/switch_to_switch_plugin.yaml rename to vitrage/tests/resources/static_datasources/switch_to_switch_plugin.yaml index d484b29b7..d53a7ec46 100644 --- a/vitrage/tests/resources/static_plugins/switch_to_switch_plugin.yaml +++ b/vitrage/tests/resources/static_datasources/switch_to_switch_plugin.yaml @@ -16,4 +16,4 @@ entities: - type: switch name: switch-3 id: 34567 - relation_type: backup \ No newline at end of file + relation_type: backup diff --git a/vitrage/tests/functional/data_sources/nagios/__init__.py b/vitrage/tests/unit/datasources/__init__.py similarity index 100% rename from vitrage/tests/functional/data_sources/nagios/__init__.py rename to vitrage/tests/unit/datasources/__init__.py diff --git a/vitrage/tests/functional/data_sources/neutron/__init__.py b/vitrage/tests/unit/datasources/cinder/__init__.py similarity index 100% rename from vitrage/tests/functional/data_sources/neutron/__init__.py rename to vitrage/tests/unit/datasources/cinder/__init__.py diff --git a/vitrage/tests/unit/synchronizer/plugins/cinder/test_cinder_volume_transformer.py b/vitrage/tests/unit/datasources/cinder/test_cinder_volume_transformer.py similarity index 87% rename from vitrage/tests/unit/synchronizer/plugins/cinder/test_cinder_volume_transformer.py rename to vitrage/tests/unit/datasources/cinder/test_cinder_volume_transformer.py index b1f22a91a..9b4b749b4 100644 --- a/vitrage/tests/unit/synchronizer/plugins/cinder/test_cinder_volume_transformer.py +++ b/vitrage/tests/unit/datasources/cinder/test_cinder_volume_transformer.py @@ -20,16 +20,15 @@ from vitrage.common.constants import EdgeLabels from vitrage.common.constants import EntityCategory from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import VertexProperties as VProps -from vitrage.synchronizer.plugins.cinder.volume import CINDER_VOLUME_PLUGIN -from vitrage.synchronizer.plugins.cinder.volume.transformer \ +from vitrage.datasources.cinder.volume import CINDER_VOLUME_DATASOURCE +from vitrage.datasources.cinder.volume.transformer \ import CinderVolumeTransformer -from vitrage.synchronizer.plugins.nova.instance import NOVA_INSTANCE_PLUGIN -from vitrage.synchronizer.plugins.nova.instance.transformer \ - import InstanceTransformer -from vitrage.synchronizer.plugins import transformer_base as tbase -from vitrage.synchronizer.plugins.transformer_base import TransformerBase +from vitrage.datasources.nova.instance import NOVA_INSTANCE_DATASOURCE +from vitrage.datasources.nova.instance.transformer import InstanceTransformer +from vitrage.datasources import transformer_base as tbase +from vitrage.datasources.transformer_base import TransformerBase from vitrage.tests import base -from vitrage.tests.mocks import mock_syncronizer as mock_sync +from vitrage.tests.mocks import mock_driver as mock_sync LOG = logging.getLogger(__name__) @@ -40,9 +39,9 @@ class TestCinderVolumeTransformer(base.BaseTest): @classmethod def setUpClass(cls): cls.transformers = {} - cls.transformers[CINDER_VOLUME_PLUGIN] = \ + cls.transformers[CINDER_VOLUME_DATASOURCE] = \ CinderVolumeTransformer(cls.transformers) - cls.transformers[NOVA_INSTANCE_PLUGIN] = \ + cls.transformers[NOVA_INSTANCE_DATASOURCE] = \ InstanceTransformer(cls.transformers) def test_create_placeholder_vertex(self): @@ -54,7 +53,7 @@ class TestCinderVolumeTransformer(base.BaseTest): timestamp = datetime.datetime.utcnow() properties = { VProps.ID: volume_id, - VProps.TYPE: CINDER_VOLUME_PLUGIN, + VProps.TYPE: CINDER_VOLUME_DATASOURCE, VProps.SAMPLE_TIMESTAMP: timestamp } transformer = CinderVolumeTransformer(self.transformers) @@ -65,7 +64,7 @@ class TestCinderVolumeTransformer(base.BaseTest): # Test assertions observed_id_values = placeholder.vertex_id.split( TransformerBase.KEY_SEPARATOR) - expected_id_values = transformer._key_values(CINDER_VOLUME_PLUGIN, + expected_id_values = transformer._key_values(CINDER_VOLUME_DATASOURCE, volume_id) self.assertEqual(tuple(observed_id_values), expected_id_values) @@ -73,7 +72,7 @@ class TestCinderVolumeTransformer(base.BaseTest): self.assertEqual(observed_time, timestamp) observed_type = placeholder.get(VProps.TYPE) - self.assertEqual(observed_type, CINDER_VOLUME_PLUGIN) + self.assertEqual(observed_type, CINDER_VOLUME_DATASOURCE) observed_entity_id = placeholder.get(VProps.ID) self.assertEqual(observed_entity_id, volume_id) @@ -88,7 +87,7 @@ class TestCinderVolumeTransformer(base.BaseTest): LOG.debug('Cinder Volume transformer test: get key values') # Test setup - volume_type = CINDER_VOLUME_PLUGIN + volume_type = CINDER_VOLUME_DATASOURCE volume_id = '12345' transformer = CinderVolumeTransformer(self.transformers) @@ -98,7 +97,7 @@ class TestCinderVolumeTransformer(base.BaseTest): # Test assertions self.assertEqual(EntityCategory.RESOURCE, observed_key_fields[0]) - self.assertEqual(CINDER_VOLUME_PLUGIN, observed_key_fields[1]) + self.assertEqual(CINDER_VOLUME_DATASOURCE, observed_key_fields[1]) self.assertEqual(volume_id, observed_key_fields[2]) def test_snapshot_transform(self): @@ -113,7 +112,8 @@ class TestCinderVolumeTransformer(base.BaseTest): for event in static_events: # Test action - wrapper = self.transformers[CINDER_VOLUME_PLUGIN].transform(event) + wrapper = self.transformers[CINDER_VOLUME_DATASOURCE].transform( + event) # Test assertions vertex = wrapper.vertex @@ -135,7 +135,8 @@ class TestCinderVolumeTransformer(base.BaseTest): for event in static_events: # Test action - wrapper = self.transformers[CINDER_VOLUME_PLUGIN].transform(event) + wrapper = self.transformers[CINDER_VOLUME_DATASOURCE].transform( + event) # Test assertions vertex = wrapper.vertex @@ -196,7 +197,7 @@ class TestCinderVolumeTransformer(base.BaseTest): # validate neighbor vertex self.assertEqual(EntityCategory.RESOURCE, instance_neighbor.vertex[VProps.CATEGORY]) - self.assertEqual(NOVA_INSTANCE_PLUGIN, + self.assertEqual(NOVA_INSTANCE_DATASOURCE, instance_neighbor.vertex[VProps.TYPE]) self.assertEqual(instance_id, instance_neighbor.vertex[VProps.ID]) self.assertTrue(instance_neighbor.vertex[VProps.IS_PLACEHOLDER]) diff --git a/vitrage/tests/functional/data_sources/nova/__init__.py b/vitrage/tests/unit/datasources/nagios/__init__.py similarity index 100% rename from vitrage/tests/functional/data_sources/nova/__init__.py rename to vitrage/tests/unit/datasources/nagios/__init__.py diff --git a/vitrage/tests/unit/synchronizer/plugins/nagios/mock_synchronizer.py b/vitrage/tests/unit/datasources/nagios/mock_driver.py similarity index 71% rename from vitrage/tests/unit/synchronizer/plugins/nagios/mock_synchronizer.py rename to vitrage/tests/unit/datasources/nagios/mock_driver.py index f75121690..a62d976d5 100644 --- a/vitrage/tests/unit/synchronizer/plugins/nagios/mock_synchronizer.py +++ b/vitrage/tests/unit/datasources/nagios/mock_driver.py @@ -12,19 +12,19 @@ # License for the specific language governing permissions and limitations # under the License. -from vitrage.synchronizer.plugins.nagios.synchronizer import NagiosSynchronizer -from vitrage.tests.mocks import mock_syncronizer as mock_sync +from vitrage.datasources.nagios.driver import NagiosDriver +from vitrage.tests.mocks import mock_driver -class MockNagiosSynchronizer(NagiosSynchronizer): - """A nagios synchronizer for tests. +class MockNagiosDriver(NagiosDriver): + """A nagios driver for tests. Instead of calling Nagios URL to get the data, it returns the data it is asked to """ def __init__(self, conf): - super(MockNagiosSynchronizer, self).__init__(conf) + super(MockNagiosDriver, self).__init__(conf) self.service_datas = None def set_service_datas(self, service_datas): @@ -33,11 +33,11 @@ class MockNagiosSynchronizer(NagiosSynchronizer): def _get_alarms(self): alarms = [] for service_data in self.service_datas: - generators = mock_sync.simple_nagios_alarm_generators( + generators = mock_driver.simple_nagios_alarm_generators( host_num=1, events_num=1, snap_vals=service_data) alarms.append( - mock_sync.generate_sequential_events_list(generators)[0]) + mock_driver.generate_sequential_events_list(generators)[0]) return alarms diff --git a/vitrage/tests/unit/synchronizer/plugins/nagios/nagios_base_test.py b/vitrage/tests/unit/datasources/nagios/nagios_base_test.py similarity index 95% rename from vitrage/tests/unit/synchronizer/plugins/nagios/nagios_base_test.py rename to vitrage/tests/unit/datasources/nagios/nagios_base_test.py index cdbe1f404..e20dd3763 100644 --- a/vitrage/tests/unit/synchronizer/plugins/nagios/nagios_base_test.py +++ b/vitrage/tests/unit/datasources/nagios/nagios_base_test.py @@ -11,7 +11,7 @@ # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. -from vitrage.synchronizer.plugins.nagios.properties import NagiosProperties \ +from vitrage.datasources.nagios.properties import NagiosProperties \ as NagiosProps from vitrage.tests import base diff --git a/vitrage/tests/unit/synchronizer/plugins/nagios/test_nagios_config.py b/vitrage/tests/unit/datasources/nagios/test_nagios_config.py similarity index 84% rename from vitrage/tests/unit/synchronizer/plugins/nagios/test_nagios_config.py rename to vitrage/tests/unit/datasources/nagios/test_nagios_config.py index 19741624f..1f6802991 100644 --- a/vitrage/tests/unit/synchronizer/plugins/nagios/test_nagios_config.py +++ b/vitrage/tests/unit/datasources/nagios/test_nagios_config.py @@ -15,10 +15,10 @@ from oslo_config import cfg from oslo_log import log as logging -from vitrage.synchronizer.plugins.nagios.config import NagiosConfig -from vitrage.synchronizer.plugins.nagios.config import NagiosHostMapping -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.nova.instance import NOVA_INSTANCE_PLUGIN +from vitrage.datasources.nagios.config import NagiosConfig +from vitrage.datasources.nagios.config import NagiosHostMapping +from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE +from vitrage.datasources.nova.instance import NOVA_INSTANCE_DATASOURCE from vitrage.tests import base from vitrage.tests.mocks import utils @@ -29,13 +29,12 @@ class TestNagiosConfig(base.BaseTest): OPTS = [ cfg.StrOpt('transformer', - default='vitrage.synchronizer.plugins.nagios.' - 'transformer.NagiosTransformer', - help='Nagios plugin transformer class path', + default='vitrage.datasources.nagios.transformer.' + 'NagiosTransformer', + help='Nagios data source transformer class path', required=True), - cfg.StrOpt('synchronizer', - default='vitrage.synchronizer.plugins.nagios.synchronizer' - '.NagiosSynchronizer', + cfg.StrOpt('driver', + default='vitrage.datasources.nagios.driver.NagiosDriver', help='Nagios plugin synchronizer class path', required=True), cfg.IntOpt('changes_interval', @@ -55,24 +54,26 @@ class TestNagiosConfig(base.BaseTest): ] # the mappings match the ones in nagios_conf.yaml - MAPPING_1 = NagiosHostMapping('compute-1', NOVA_HOST_PLUGIN, 'compute-1') - MAPPING_2 = NagiosHostMapping('compute-2', NOVA_HOST_PLUGIN, 'host2') + MAPPING_1 = NagiosHostMapping('compute-1', + NOVA_HOST_DATASOURCE, + 'compute-1') + MAPPING_2 = NagiosHostMapping('compute-2', NOVA_HOST_DATASOURCE, 'host2') MAPPING_3 = NagiosHostMapping('compute-(.*)', - NOVA_HOST_PLUGIN, + NOVA_HOST_DATASOURCE, '${nagios_host}') MAPPING_4 = NagiosHostMapping('instance-(.*)', - NOVA_INSTANCE_PLUGIN, + NOVA_INSTANCE_DATASOURCE, '${nagios_host}') MAPPINGS = [MAPPING_1, MAPPING_2, MAPPING_3, MAPPING_4] NON_EXISTING_MAPPING_1 = NagiosHostMapping('X', - NOVA_HOST_PLUGIN, + NOVA_HOST_DATASOURCE, 'compute-1') NON_EXISTING_MAPPING_2 = NagiosHostMapping('compute-1', 'X', 'compute-1') NON_EXISTING_MAPPING_3 = NagiosHostMapping('compute-1', - NOVA_HOST_PLUGIN, + NOVA_HOST_DATASOURCE, 'X') NON_EXISTING_MAPPINGS = [NON_EXISTING_MAPPING_1, NON_EXISTING_MAPPING_2, @@ -157,22 +158,22 @@ class TestNagiosConfig(base.BaseTest): mapped_resource = nagios_conf.get_vitrage_resource('compute-1') self.assertIsNotNone(mapped_resource, 'expected Not None') - self.assertEqual(NOVA_HOST_PLUGIN, mapped_resource[0]) + self.assertEqual(NOVA_HOST_DATASOURCE, mapped_resource[0]) self.assertEqual('compute-1', mapped_resource[1]) mapped_resource = nagios_conf.get_vitrage_resource('compute-2') self.assertIsNotNone(mapped_resource, 'expected Not None') - self.assertEqual(NOVA_HOST_PLUGIN, mapped_resource[0]) + self.assertEqual(NOVA_HOST_DATASOURCE, mapped_resource[0]) self.assertEqual('host2', mapped_resource[1]) mapped_resource = nagios_conf.get_vitrage_resource('compute-88') self.assertIsNotNone(mapped_resource, 'expected Not None') - self.assertEqual(NOVA_HOST_PLUGIN, mapped_resource[0]) + self.assertEqual(NOVA_HOST_DATASOURCE, mapped_resource[0]) self.assertEqual('compute-88', mapped_resource[1]) mapped_resource = nagios_conf.get_vitrage_resource('instance-7') self.assertIsNotNone(mapped_resource, 'expected Not None') - self.assertEqual(NOVA_INSTANCE_PLUGIN, mapped_resource[0]) + self.assertEqual(NOVA_INSTANCE_DATASOURCE, mapped_resource[0]) self.assertEqual('instance-7', mapped_resource[1]) @staticmethod diff --git a/vitrage/tests/unit/synchronizer/plugins/nagios/test_nagios_synchronizer.py b/vitrage/tests/unit/datasources/nagios/test_nagios_driver.py similarity index 76% rename from vitrage/tests/unit/synchronizer/plugins/nagios/test_nagios_synchronizer.py rename to vitrage/tests/unit/datasources/nagios/test_nagios_driver.py index f6b1ca5ed..2d813397a 100644 --- a/vitrage/tests/unit/synchronizer/plugins/nagios/test_nagios_synchronizer.py +++ b/vitrage/tests/unit/datasources/nagios/test_nagios_driver.py @@ -15,19 +15,18 @@ from oslo_config import cfg from oslo_log import log as logging -from vitrage.synchronizer.plugins.nagios.properties import ( - NagiosProperties as NagiosProps) +from vitrage.datasources.nagios.properties import NagiosProperties as \ + NagiosProps from vitrage.tests.mocks import utils -from vitrage.tests.unit.synchronizer.plugins.nagios.mock_synchronizer import ( - MockNagiosSynchronizer) -from vitrage.tests.unit.synchronizer.plugins.nagios.nagios_base_test import ( - NagiosBaseTest) +from vitrage.tests.unit.datasources.nagios.mock_driver import MockNagiosDriver +from vitrage.tests.unit.datasources.nagios.nagios_base_test import \ + NagiosBaseTest LOG = logging.getLogger(__name__) # noinspection PyProtectedMember -class NagiosSynchronizerTest(NagiosBaseTest): +class NagiosDriverTest(NagiosBaseTest): OPTS = [ cfg.StrOpt('config_file', @@ -51,7 +50,7 @@ class NagiosSynchronizerTest(NagiosBaseTest): """ # Setup - nagios_synchronizer = MockNagiosSynchronizer(self.conf) + nagios_driver = MockNagiosDriver(self.conf) # Action service_data1 = {NagiosProps.RESOURCE_NAME: 'compute-0', @@ -64,11 +63,11 @@ class NagiosSynchronizerTest(NagiosBaseTest): NagiosProps.SERVICE: 'Uptime', NagiosProps.STATUS: 'OK'} - nagios_synchronizer.set_service_datas([service_data1, - service_data2, - service_data3]) + nagios_driver.set_service_datas([service_data1, + service_data2, + service_data3]) - services = nagios_synchronizer._get_all_alarms() + services = nagios_driver._get_all_alarms() # Test assertions # Services with status OK should not be returned @@ -86,11 +85,11 @@ class NagiosSynchronizerTest(NagiosBaseTest): NagiosProps.SERVICE: 'Uptime', NagiosProps.STATUS: 'OK'} - nagios_synchronizer.set_service_datas([service_data1, - service_data2, - service_data3]) + nagios_driver.set_service_datas([service_data1, + service_data2, + service_data3]) - services = nagios_synchronizer._get_all_alarms() + services = nagios_driver._get_all_alarms() # Test assertions self.assertIsNotNone(services, 'No services returned') @@ -108,11 +107,11 @@ class NagiosSynchronizerTest(NagiosBaseTest): NagiosProps.SERVICE: 'Uptime', NagiosProps.STATUS: 'OK'} - nagios_synchronizer.set_service_datas([service_data1, - service_data2, - service_data3]) + nagios_driver.set_service_datas([service_data1, + service_data2, + service_data3]) - services = nagios_synchronizer._get_all_alarms() + services = nagios_driver._get_all_alarms() # Test assertions self.assertIsNotNone(services, 'No services returned') @@ -131,11 +130,11 @@ class NagiosSynchronizerTest(NagiosBaseTest): NagiosProps.SERVICE: 'Uptime', NagiosProps.STATUS: 'OK'} - nagios_synchronizer.set_service_datas([service_data1, - service_data2, - service_data3]) + nagios_driver.set_service_datas([service_data1, + service_data2, + service_data3]) - services = nagios_synchronizer._get_all_alarms() + services = nagios_driver._get_all_alarms() # Test assertions # The services of service_data1/2 should be returned although their @@ -146,7 +145,7 @@ class NagiosSynchronizerTest(NagiosBaseTest): self._assert_contains(service_data2, services) # Action - services = nagios_synchronizer._get_all_alarms() + services = nagios_driver._get_all_alarms() # Test assertions # Calling get_services again should not return anything, since all @@ -162,7 +161,7 @@ class NagiosSynchronizerTest(NagiosBaseTest): """ # Setup - nagios_synchronizer = MockNagiosSynchronizer(self.conf) + nagios_driver = MockNagiosDriver(self.conf) # Action service_data1 = {NagiosProps.RESOURCE_NAME: 'compute-0', @@ -175,11 +174,11 @@ class NagiosSynchronizerTest(NagiosBaseTest): NagiosProps.SERVICE: 'Uptime', NagiosProps.STATUS: 'OK'} - nagios_synchronizer.set_service_datas([service_data1, - service_data2, - service_data3]) + nagios_driver.set_service_datas([service_data1, + service_data2, + service_data3]) - services = nagios_synchronizer._get_changed_alarms() + services = nagios_driver._get_changed_alarms() # Test assertions # Services with status OK should not be returned @@ -197,11 +196,11 @@ class NagiosSynchronizerTest(NagiosBaseTest): NagiosProps.SERVICE: 'Uptime', NagiosProps.STATUS: 'OK'} - nagios_synchronizer.set_service_datas([service_data1, - service_data2, - service_data3]) + nagios_driver.set_service_datas([service_data1, + service_data2, + service_data3]) - services = nagios_synchronizer._get_changed_alarms() + services = nagios_driver._get_changed_alarms() # Test assertions self.assertIsNotNone(services, 'No services returned') @@ -219,11 +218,11 @@ class NagiosSynchronizerTest(NagiosBaseTest): NagiosProps.SERVICE: 'Uptime', NagiosProps.STATUS: 'OK'} - nagios_synchronizer.set_service_datas([service_data1, - service_data2, - service_data3]) + nagios_driver.set_service_datas([service_data1, + service_data2, + service_data3]) - services = nagios_synchronizer._get_changed_alarms() + services = nagios_driver._get_changed_alarms() # Test assertions self.assertIsNotNone(services, 'No services returned') @@ -242,11 +241,11 @@ class NagiosSynchronizerTest(NagiosBaseTest): NagiosProps.SERVICE: 'Uptime', NagiosProps.STATUS: 'OK'} - nagios_synchronizer.set_service_datas([service_data1, - service_data2, - service_data3]) + nagios_driver.set_service_datas([service_data1, + service_data2, + service_data3]) - services = nagios_synchronizer._get_changed_alarms() + services = nagios_driver._get_changed_alarms() # Test assertions self.assertIsNotNone(services, 'No services returned') @@ -264,11 +263,11 @@ class NagiosSynchronizerTest(NagiosBaseTest): NagiosProps.SERVICE: 'Uptime', NagiosProps.STATUS: 'OK'} - nagios_synchronizer.set_service_datas([service_data1, - service_data2, - service_data3]) + nagios_driver.set_service_datas([service_data1, + service_data2, + service_data3]) - services = nagios_synchronizer._get_changed_alarms() + services = nagios_driver._get_changed_alarms() # Test assertions self.assertIsNotNone(services, 'No services returned') @@ -277,7 +276,7 @@ class NagiosSynchronizerTest(NagiosBaseTest): self._assert_contains(service_data2, services) # Action - services = nagios_synchronizer._get_changed_alarms() + services = nagios_driver._get_changed_alarms() # Test assertions self.assertIsNotNone(services, 'services is None') @@ -287,7 +286,7 @@ class NagiosSynchronizerTest(NagiosBaseTest): """Check get_changes and get_all functionalities """ # Setup - nagios_synchronizer = MockNagiosSynchronizer(self.conf) + nagios_driver = MockNagiosDriver(self.conf) # Action service_data1 = {NagiosProps.RESOURCE_NAME: 'compute-0', @@ -300,11 +299,11 @@ class NagiosSynchronizerTest(NagiosBaseTest): NagiosProps.SERVICE: 'Uptime', NagiosProps.STATUS: 'OK'} - nagios_synchronizer.set_service_datas([service_data1, - service_data2, - service_data3]) + nagios_driver.set_service_datas([service_data1, + service_data2, + service_data3]) - services = nagios_synchronizer._get_changed_alarms() + services = nagios_driver._get_changed_alarms() # Test assertions self.assertIsNotNone(services, 'No services returned') @@ -312,7 +311,7 @@ class NagiosSynchronizerTest(NagiosBaseTest): self._assert_contains(service_data1, services) # Action - services = nagios_synchronizer._get_changed_alarms() + services = nagios_driver._get_changed_alarms() # Test assertions # Calling get_changes for the second time should return nothing @@ -320,7 +319,7 @@ class NagiosSynchronizerTest(NagiosBaseTest): self.assertEqual(0, len(services)) # Action - services = nagios_synchronizer._get_all_alarms() + services = nagios_driver._get_all_alarms() # Test assertions self.assertIsNotNone(services, 'No services returned') @@ -328,7 +327,7 @@ class NagiosSynchronizerTest(NagiosBaseTest): self._assert_contains(service_data1, services) # Action - services = nagios_synchronizer._get_all_alarms() + services = nagios_driver._get_all_alarms() # Test assertions # Calling get_all for the second time should return the same results @@ -347,11 +346,11 @@ class NagiosSynchronizerTest(NagiosBaseTest): NagiosProps.SERVICE: 'Uptime', NagiosProps.STATUS: 'OK'} - nagios_synchronizer.set_service_datas([service_data1, - service_data2, - service_data3]) + nagios_driver.set_service_datas([service_data1, + service_data2, + service_data3]) - services = nagios_synchronizer._get_all_alarms() + services = nagios_driver._get_all_alarms() # Test assertions self.assertIsNotNone(services, 'No services returned') @@ -360,7 +359,7 @@ class NagiosSynchronizerTest(NagiosBaseTest): self._assert_contains(service_data2, services) # Action - services = nagios_synchronizer._get_changed_alarms() + services = nagios_driver._get_changed_alarms() # Test assertions # Calling get_changes after get_all should return nothing @@ -368,7 +367,7 @@ class NagiosSynchronizerTest(NagiosBaseTest): self.assertEqual(0, len(services)) # Action - services = nagios_synchronizer._get_all_alarms() + services = nagios_driver._get_all_alarms() # Test assertions # Calling get_all for the second time should return the same results @@ -388,11 +387,11 @@ class NagiosSynchronizerTest(NagiosBaseTest): NagiosProps.SERVICE: 'Uptime', NagiosProps.STATUS: 'CRITICAL'} - nagios_synchronizer.set_service_datas([service_data1, - service_data2, - service_data3]) + nagios_driver.set_service_datas([service_data1, + service_data2, + service_data3]) - services = nagios_synchronizer._get_changed_alarms() + services = nagios_driver._get_changed_alarms() # Test assertions self.assertIsNotNone(services, 'No services returned') @@ -411,11 +410,11 @@ class NagiosSynchronizerTest(NagiosBaseTest): NagiosProps.SERVICE: 'Uptime', NagiosProps.STATUS: 'CRITICAL'} - nagios_synchronizer.set_service_datas([service_data1, - service_data2, - service_data3]) + nagios_driver.set_service_datas([service_data1, + service_data2, + service_data3]) - services = nagios_synchronizer._get_changed_alarms() + services = nagios_driver._get_changed_alarms() # Test assertions self.assertIsNotNone(services, 'No services returned') @@ -423,14 +422,14 @@ class NagiosSynchronizerTest(NagiosBaseTest): self._assert_contains(service_data1, services) # Action - services = nagios_synchronizer._get_changed_alarms() + services = nagios_driver._get_changed_alarms() # Test assertions self.assertIsNotNone(services, 'services is None') self.assertEqual(0, len(services)) # Action - services = nagios_synchronizer._get_all_alarms() + services = nagios_driver._get_all_alarms() # Test assertions # Calling get_all for the second time should return the same results diff --git a/vitrage/tests/unit/synchronizer/plugins/nagios/test_nagios_parser.py b/vitrage/tests/unit/datasources/nagios/test_nagios_parser.py similarity index 93% rename from vitrage/tests/unit/synchronizer/plugins/nagios/test_nagios_parser.py rename to vitrage/tests/unit/datasources/nagios/test_nagios_parser.py index 536af9060..128919de1 100644 --- a/vitrage/tests/unit/synchronizer/plugins/nagios/test_nagios_parser.py +++ b/vitrage/tests/unit/datasources/nagios/test_nagios_parser.py @@ -13,10 +13,10 @@ # under the License. from oslo_log import log as logging -from vitrage.synchronizer.plugins.nagios.parser import NagiosParser -from vitrage.synchronizer.plugins.nagios.properties import NagiosProperties +from vitrage.datasources.nagios.parser import NagiosParser +from vitrage.datasources.nagios.properties import NagiosProperties from vitrage.tests.mocks import utils -from vitrage.tests.unit.synchronizer.plugins.nagios.nagios_base_test \ +from vitrage.tests.unit.datasources.nagios.nagios_base_test \ import NagiosBaseTest LOG = logging.getLogger(__name__) diff --git a/vitrage/tests/unit/synchronizer/plugins/nagios/test_nagios_transformer.py b/vitrage/tests/unit/datasources/nagios/test_nagios_transformer.py similarity index 86% rename from vitrage/tests/unit/synchronizer/plugins/nagios/test_nagios_transformer.py rename to vitrage/tests/unit/datasources/nagios/test_nagios_transformer.py index 0b79b4b97..9349d88eb 100644 --- a/vitrage/tests/unit/synchronizer/plugins/nagios/test_nagios_transformer.py +++ b/vitrage/tests/unit/datasources/nagios/test_nagios_transformer.py @@ -20,16 +20,15 @@ from vitrage.common.constants import EventAction from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import SyncMode from vitrage.common.constants import VertexProperties as VProps -from vitrage.synchronizer.plugins.base.alarm.properties \ - import AlarmProperties as AlarmProps -from vitrage.synchronizer.plugins.nagios.properties import NagiosProperties -from vitrage.synchronizer.plugins.nagios.properties import NagiosStatus -from vitrage.synchronizer.plugins.nagios.transformer import NagiosTransformer -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.nova.host.transformer import HostTransformer -from vitrage.synchronizer.plugins.transformer_base import TransformerBase +from vitrage.datasources.alarm_properties import AlarmProperties as AlarmProps +from vitrage.datasources.nagios.properties import NagiosProperties +from vitrage.datasources.nagios.properties import NagiosStatus +from vitrage.datasources.nagios.transformer import NagiosTransformer +from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE +from vitrage.datasources.nova.host.transformer import HostTransformer +from vitrage.datasources.transformer_base import TransformerBase from vitrage.tests import base -from vitrage.tests.mocks import mock_syncronizer as mock_sync +from vitrage.tests.mocks import mock_driver as mock_sync LOG = logging.getLogger(__name__) @@ -43,7 +42,7 @@ class NagiosTransformerTest(base.BaseTest): def setUpClass(cls): cls.transformers = {} host_transformer = HostTransformer(cls.transformers) - cls.transformers[NOVA_HOST_PLUGIN] = host_transformer + cls.transformers[NOVA_HOST_DATASOURCE] = host_transformer def test_extract_key(self): LOG.debug('Test get key from nova instance transformer') @@ -87,7 +86,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_PLUGIN: + if neighbor.vertex[VProps.TYPE] == NOVA_HOST_DATASOURCE: self._validate_host_neighbor(neighbors[0], alarm) self._validate_action(alarm, wrapper) @@ -132,7 +131,7 @@ class NagiosTransformerTest(base.BaseTest): key_fields = host_vertex.vertex_id.split(TransformerBase.KEY_SEPARATOR) self.assertEqual(EntityCategory.RESOURCE, key_fields[0]) - self.assertEqual(NOVA_HOST_PLUGIN, key_fields[1]) + self.assertEqual(NOVA_HOST_DATASOURCE, key_fields[1]) self.assertEqual(event[NagiosProperties.RESOURCE_NAME], key_fields[2]) self.assertFalse(host_vertex[VProps.IS_DELETED]) @@ -141,7 +140,7 @@ class NagiosTransformerTest(base.BaseTest): self.assertEqual(EntityCategory.RESOURCE, host_vertex[VProps.CATEGORY]) self.assertEqual(event[NagiosProperties.RESOURCE_NAME], host_vertex[VProps.ID]) - self.assertEqual(NOVA_HOST_PLUGIN, host_vertex[VProps.TYPE]) + self.assertEqual(NOVA_HOST_DATASOURCE, host_vertex[VProps.TYPE]) edge = neighbor.edge self.assertEqual(EdgeLabels.ON, edge.label) diff --git a/vitrage/tests/functional/data_sources/static_physical/__init__.py b/vitrage/tests/unit/datasources/nova/__init__.py similarity index 100% rename from vitrage/tests/functional/data_sources/static_physical/__init__.py rename to vitrage/tests/unit/datasources/nova/__init__.py diff --git a/vitrage/tests/unit/synchronizer/plugins/nova/test_nova_host_transformer.py b/vitrage/tests/unit/datasources/nova/test_nova_host_transformer.py similarity index 83% rename from vitrage/tests/unit/synchronizer/plugins/nova/test_nova_host_transformer.py rename to vitrage/tests/unit/datasources/nova/test_nova_host_transformer.py index a26194dcb..757fd4c0c 100644 --- a/vitrage/tests/unit/synchronizer/plugins/nova/test_nova_host_transformer.py +++ b/vitrage/tests/unit/datasources/nova/test_nova_host_transformer.py @@ -22,14 +22,14 @@ from vitrage.common.constants import EventAction from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import SyncMode from vitrage.common.constants import VertexProperties -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.nova.host.transformer import HostTransformer -from vitrage.synchronizer.plugins.nova.zone import NOVA_ZONE_PLUGIN -from vitrage.synchronizer.plugins.nova.zone.transformer import ZoneTransformer -from vitrage.synchronizer.plugins import transformer_base as tbase -from vitrage.synchronizer.plugins.transformer_base import TransformerBase +from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE +from vitrage.datasources.nova.host.transformer import HostTransformer +from vitrage.datasources.nova.zone import NOVA_ZONE_DATASOURCE +from vitrage.datasources.nova.zone.transformer import ZoneTransformer +from vitrage.datasources import transformer_base as tbase +from vitrage.datasources.transformer_base import TransformerBase from vitrage.tests import base -from vitrage.tests.mocks import mock_syncronizer as mock_sync +from vitrage.tests.mocks import mock_driver as mock_sync LOG = logging.getLogger(__name__) @@ -41,8 +41,10 @@ class NovaHostTransformerTest(base.BaseTest): @classmethod def setUpClass(cls): cls.transformers = {} - cls.transformers[NOVA_ZONE_PLUGIN] = ZoneTransformer(cls.transformers) - cls.transformers[NOVA_HOST_PLUGIN] = HostTransformer(cls.transformers) + cls.transformers[NOVA_ZONE_DATASOURCE] = ZoneTransformer( + cls.transformers) + cls.transformers[NOVA_HOST_DATASOURCE] = HostTransformer( + cls.transformers) def test_create_placeholder_vertex(self): LOG.debug('Nova host transformer test: Test create placeholder vertex') @@ -55,7 +57,7 @@ class NovaHostTransformerTest(base.BaseTest): # Test action properties = { VertexProperties.ID: host_name, - VertexProperties.TYPE: NOVA_HOST_PLUGIN, + VertexProperties.TYPE: NOVA_HOST_DATASOURCE, VertexProperties.SAMPLE_TIMESTAMP: timestamp } placeholder = host_transformer.create_placeholder_vertex(**properties) @@ -63,15 +65,16 @@ class NovaHostTransformerTest(base.BaseTest): # Test assertions observed_id_values = placeholder.vertex_id.split( TransformerBase.KEY_SEPARATOR) - expected_id_values = host_transformer._key_values(NOVA_HOST_PLUGIN, - host_name) + expected_id_values = host_transformer._key_values( + NOVA_HOST_DATASOURCE, + host_name) self.assertEqual(tuple(observed_id_values), expected_id_values) observed_time = placeholder.get(VertexProperties.SAMPLE_TIMESTAMP) self.assertEqual(observed_time, timestamp) observed_subtype = placeholder.get(VertexProperties.TYPE) - self.assertEqual(observed_subtype, NOVA_HOST_PLUGIN) + self.assertEqual(observed_subtype, NOVA_HOST_DATASOURCE) observed_entity_id = placeholder.get(VertexProperties.ID) self.assertEqual(observed_entity_id, host_name) @@ -91,12 +94,13 @@ class NovaHostTransformerTest(base.BaseTest): host_transformer = HostTransformer(self.transformers) # Test action - observed_key_fields = host_transformer._key_values(NOVA_HOST_PLUGIN, - host_name) + observed_key_fields = host_transformer._key_values( + NOVA_HOST_DATASOURCE, + host_name) # Test assertions self.assertEqual(EntityCategory.RESOURCE, observed_key_fields[0]) - self.assertEqual(NOVA_HOST_PLUGIN, observed_key_fields[1]) + self.assertEqual(NOVA_HOST_DATASOURCE, observed_key_fields[1]) self.assertEqual(host_name, observed_key_fields[2]) def test_snapshot_transform(self): @@ -111,7 +115,7 @@ class NovaHostTransformerTest(base.BaseTest): for event in host_events: # Test action - wrapper = self.transformers[NOVA_HOST_PLUGIN].transform(event) + wrapper = self.transformers[NOVA_HOST_DATASOURCE].transform(event) # Test assertions self._validate_vertex_props(wrapper.vertex, event) @@ -130,10 +134,10 @@ class NovaHostTransformerTest(base.BaseTest): zone_name = tbase.extract_field_value(event, 'zone') time = event[SyncProps.SAMPLE_DATE] - zt = self.transformers[NOVA_ZONE_PLUGIN] + zt = self.transformers[NOVA_ZONE_DATASOURCE] properties = { VertexProperties.ID: zone_name, - VertexProperties.TYPE: NOVA_ZONE_PLUGIN, + VertexProperties.TYPE: NOVA_ZONE_DATASOURCE, VertexProperties.SAMPLE_TIMESTAMP: time } expected_neighbor = zt.create_placeholder_vertex(**properties) @@ -161,7 +165,7 @@ class NovaHostTransformerTest(base.BaseTest): ) self.assertEqual( - NOVA_HOST_PLUGIN, + NOVA_HOST_DATASOURCE, vertex[VertexProperties.TYPE] ) diff --git a/vitrage/tests/unit/synchronizer/plugins/nova/test_nova_instance_transformers.py b/vitrage/tests/unit/datasources/nova/test_nova_instance_transformers.py similarity index 87% rename from vitrage/tests/unit/synchronizer/plugins/nova/test_nova_instance_transformers.py rename to vitrage/tests/unit/datasources/nova/test_nova_instance_transformers.py index ed0aa45e6..f5213d5e2 100644 --- a/vitrage/tests/unit/synchronizer/plugins/nova/test_nova_instance_transformers.py +++ b/vitrage/tests/unit/datasources/nova/test_nova_instance_transformers.py @@ -22,15 +22,14 @@ from vitrage.common.constants import EventAction from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import SyncMode from vitrage.common.constants import VertexProperties -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.nova.host.transformer import HostTransformer -from vitrage.synchronizer.plugins.nova.instance import NOVA_INSTANCE_PLUGIN -from vitrage.synchronizer.plugins.nova.instance.transformer import \ - InstanceTransformer -from vitrage.synchronizer.plugins import transformer_base as tbase -from vitrage.synchronizer.plugins.transformer_base import TransformerBase +from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE +from vitrage.datasources.nova.host.transformer import HostTransformer +from vitrage.datasources.nova.instance import NOVA_INSTANCE_DATASOURCE +from vitrage.datasources.nova.instance.transformer import InstanceTransformer +from vitrage.datasources import transformer_base as tbase +from vitrage.datasources.transformer_base import TransformerBase from vitrage.tests import base -from vitrage.tests.mocks import mock_syncronizer as mock_sync +from vitrage.tests.mocks import mock_driver as mock_sync LOG = logging.getLogger(__name__) @@ -42,8 +41,9 @@ class NovaInstanceTransformerTest(base.BaseTest): @classmethod def setUpClass(cls): cls.transformers = {} - cls.transformers[NOVA_HOST_PLUGIN] = HostTransformer(cls.transformers) - cls.transformers[NOVA_INSTANCE_PLUGIN] = \ + cls.transformers[NOVA_HOST_DATASOURCE] = HostTransformer( + cls.transformers) + cls.transformers[NOVA_INSTANCE_DATASOURCE] = \ InstanceTransformer(cls.transformers) def test_create_placeholder_vertex(self): @@ -54,7 +54,7 @@ class NovaInstanceTransformerTest(base.BaseTest): timestamp = datetime.datetime.utcnow() properties = { VertexProperties.ID: instance_id, - VertexProperties.TYPE: NOVA_INSTANCE_PLUGIN, + VertexProperties.TYPE: NOVA_INSTANCE_DATASOURCE, VertexProperties.SAMPLE_TIMESTAMP: timestamp } transformer = InstanceTransformer(self.transformers) @@ -65,7 +65,7 @@ class NovaInstanceTransformerTest(base.BaseTest): # Test assertions observed_id_values = placeholder.vertex_id.split( TransformerBase.KEY_SEPARATOR) - expected_id_values = transformer._key_values(NOVA_INSTANCE_PLUGIN, + expected_id_values = transformer._key_values(NOVA_INSTANCE_DATASOURCE, instance_id) self.assertEqual(tuple(observed_id_values), expected_id_values) @@ -73,7 +73,7 @@ class NovaInstanceTransformerTest(base.BaseTest): self.assertEqual(observed_time, timestamp) observed_type = placeholder.get(VertexProperties.TYPE) - self.assertEqual(observed_type, NOVA_INSTANCE_PLUGIN) + self.assertEqual(observed_type, NOVA_INSTANCE_DATASOURCE) observed_entity_id = placeholder.get(VertexProperties.ID) self.assertEqual(observed_entity_id, instance_id) @@ -97,7 +97,8 @@ class NovaInstanceTransformerTest(base.BaseTest): for event in instance_events: # Test action - wrapper = self.transformers[NOVA_INSTANCE_PLUGIN].transform(event) + wrapper = self.transformers[NOVA_INSTANCE_DATASOURCE].transform( + event) # Test assertions self._validate_vertex_props(wrapper.vertex, event) @@ -126,7 +127,8 @@ class NovaInstanceTransformerTest(base.BaseTest): for event in instance_events: # Test action - wrapper = self.transformers[NOVA_INSTANCE_PLUGIN].transform(event) + wrapper = self.transformers[NOVA_INSTANCE_DATASOURCE].transform( + event) # Test assertions self._validate_vertex_props(wrapper.vertex, event) @@ -161,7 +163,8 @@ class NovaInstanceTransformerTest(base.BaseTest): EntityCategory.RESOURCE, vertex[VertexProperties.CATEGORY] ) - self.assertEqual(NOVA_INSTANCE_PLUGIN, vertex[VertexProperties.TYPE]) + self.assertEqual(NOVA_INSTANCE_DATASOURCE, + vertex[VertexProperties.TYPE]) expected_project = extract_value(event, 'tenant_id') observed_project = vertex[VertexProperties.PROJECT_ID] @@ -196,10 +199,10 @@ class NovaInstanceTransformerTest(base.BaseTest): host_name = tbase.extract_field_value(event, name) time = event[SyncProps.SAMPLE_DATE] - ht = self.transformers[NOVA_HOST_PLUGIN] + ht = self.transformers[NOVA_HOST_DATASOURCE] properties = { VertexProperties.ID: host_name, - VertexProperties.TYPE: NOVA_HOST_PLUGIN, + VertexProperties.TYPE: NOVA_HOST_DATASOURCE, VertexProperties.SAMPLE_TIMESTAMP: time } expected_neighbor = ht.create_placeholder_vertex(**properties) @@ -234,7 +237,7 @@ class NovaInstanceTransformerTest(base.BaseTest): self.assertEqual(EntityCategory.RESOURCE, observed_key_fields[0]) self.assertEqual( - NOVA_INSTANCE_PLUGIN, + NOVA_INSTANCE_DATASOURCE, observed_key_fields[1] ) @@ -242,8 +245,9 @@ class NovaInstanceTransformerTest(base.BaseTest): self.assertEqual(instance_id, observed_key_fields[2]) - key_values = instance_transformer._key_values(NOVA_INSTANCE_PLUGIN, - instance_id) + key_values = instance_transformer._key_values( + NOVA_INSTANCE_DATASOURCE, + instance_id) expected_key = tbase.build_key(key_values) self.assertEqual(expected_key, observed_key) @@ -257,8 +261,9 @@ class NovaInstanceTransformerTest(base.BaseTest): instance_transformer = InstanceTransformer(self.transformers) # Test action - key_fields = instance_transformer._key_values(NOVA_INSTANCE_PLUGIN, - instance_id) + key_fields = instance_transformer._key_values( + NOVA_INSTANCE_DATASOURCE, + instance_id) # Test assertions observed_key = tbase.build_key(key_fields) @@ -278,7 +283,7 @@ class NovaInstanceTransformerTest(base.BaseTest): vertex_id, host_name, time, - self.transformers[NOVA_HOST_PLUGIN] + self.transformers[NOVA_HOST_DATASOURCE] ) # Test assertions diff --git a/vitrage/tests/unit/synchronizer/plugins/nova/test_nova_zone_transformer.py b/vitrage/tests/unit/datasources/nova/test_nova_zone_transformer.py similarity index 85% rename from vitrage/tests/unit/synchronizer/plugins/nova/test_nova_zone_transformer.py rename to vitrage/tests/unit/datasources/nova/test_nova_zone_transformer.py index a9b0230ab..bcd02acc3 100644 --- a/vitrage/tests/unit/synchronizer/plugins/nova/test_nova_zone_transformer.py +++ b/vitrage/tests/unit/datasources/nova/test_nova_zone_transformer.py @@ -20,15 +20,15 @@ from vitrage.common.constants import EdgeLabels from vitrage.common.constants import EntityCategory from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import VertexProperties -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.nova.host.transformer import HostTransformer -from vitrage.synchronizer.plugins.nova.zone import NOVA_ZONE_PLUGIN -from vitrage.synchronizer.plugins.nova.zone.transformer import ZoneTransformer -from vitrage.synchronizer.plugins import OPENSTACK_NODE -from vitrage.synchronizer.plugins import transformer_base as tbase -from vitrage.synchronizer.plugins.transformer_base import TransformerBase +from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE +from vitrage.datasources.nova.host.transformer import HostTransformer +from vitrage.datasources.nova.zone import NOVA_ZONE_DATASOURCE +from vitrage.datasources.nova.zone.transformer import ZoneTransformer +from vitrage.datasources import OPENSTACK_NODE +from vitrage.datasources import transformer_base as tbase +from vitrage.datasources.transformer_base import TransformerBase from vitrage.tests import base -from vitrage.tests.mocks import mock_syncronizer as mock_sync +from vitrage.tests.mocks import mock_driver as mock_sync LOG = logging.getLogger(__name__) @@ -40,8 +40,10 @@ class NovaZoneTransformerTest(base.BaseTest): @classmethod def setUpClass(cls): cls.transformers = {} - cls.transformers[NOVA_HOST_PLUGIN] = HostTransformer(cls.transformers) - cls.transformers[NOVA_ZONE_PLUGIN] = ZoneTransformer(cls.transformers) + cls.transformers[NOVA_HOST_DATASOURCE] = \ + HostTransformer(cls.transformers) + cls.transformers[NOVA_ZONE_DATASOURCE] = \ + ZoneTransformer(cls.transformers) def test_create_placeholder_vertex(self): @@ -55,7 +57,7 @@ class NovaZoneTransformerTest(base.BaseTest): # Test action properties = { VertexProperties.ID: zone_name, - VertexProperties.TYPE: NOVA_ZONE_PLUGIN, + VertexProperties.TYPE: NOVA_ZONE_DATASOURCE, VertexProperties.SAMPLE_TIMESTAMP: timestamp } placeholder = zone_transformer.create_placeholder_vertex(**properties) @@ -64,14 +66,14 @@ class NovaZoneTransformerTest(base.BaseTest): observed_id_values = placeholder.vertex_id.split( TransformerBase.KEY_SEPARATOR) expected_id_values = ZoneTransformer(self.transformers)._key_values( - NOVA_ZONE_PLUGIN, zone_name) + NOVA_ZONE_DATASOURCE, zone_name) self.assertEqual(tuple(observed_id_values), expected_id_values) observed_time = placeholder.get(VertexProperties.SAMPLE_TIMESTAMP) self.assertEqual(observed_time, timestamp) observed_subtype = placeholder.get(VertexProperties.TYPE) - self.assertEqual(observed_subtype, NOVA_ZONE_PLUGIN) + self.assertEqual(observed_subtype, NOVA_ZONE_DATASOURCE) observed_entity_id = placeholder.get(VertexProperties.ID) self.assertEqual(observed_entity_id, zone_name) @@ -90,13 +92,14 @@ class NovaZoneTransformerTest(base.BaseTest): zone_transformer = ZoneTransformer(self.transformers) # Test action - observed_key_fields = zone_transformer._key_values(NOVA_ZONE_PLUGIN, - zone_name) + observed_key_fields = zone_transformer._key_values( + NOVA_ZONE_DATASOURCE, + zone_name) # Test assertions self.assertEqual(EntityCategory.RESOURCE, observed_key_fields[0]) self.assertEqual( - NOVA_ZONE_PLUGIN, + NOVA_ZONE_DATASOURCE, observed_key_fields[1] ) self.assertEqual(zone_name, observed_key_fields[2]) @@ -115,7 +118,7 @@ class NovaZoneTransformerTest(base.BaseTest): for event in zone_events: # Test action - wrapper = self.transformers[NOVA_ZONE_PLUGIN].transform(event) + wrapper = self.transformers[NOVA_ZONE_DATASOURCE].transform(event) # Test assertions vertex = wrapper.vertex @@ -209,15 +212,11 @@ class NovaZoneTransformerTest(base.BaseTest): observed_id = vertex[VertexProperties.ID] self.assertEqual(expected_id, observed_id) - self.assertEqual( - EntityCategory.RESOURCE, - vertex[VertexProperties.CATEGORY] - ) + self.assertEqual(EntityCategory.RESOURCE, + vertex[VertexProperties.CATEGORY]) - self.assertEqual( - NOVA_ZONE_PLUGIN, - vertex[VertexProperties.TYPE] - ) + self.assertEqual(NOVA_ZONE_DATASOURCE, + vertex[VertexProperties.TYPE]) expected_timestamp = event[SyncProps.SAMPLE_DATE] observed_timestamp = vertex[VertexProperties.SAMPLE_TIMESTAMP] diff --git a/vitrage/tests/unit/synchronizer/__init__.py b/vitrage/tests/unit/datasources/static_physical/__init__.py similarity index 100% rename from vitrage/tests/unit/synchronizer/__init__.py rename to vitrage/tests/unit/datasources/static_physical/__init__.py diff --git a/vitrage/tests/unit/synchronizer/plugins/static_physical/test_static_physical_synchronizer.py b/vitrage/tests/unit/datasources/static_physical/test_static_physical_driver.py similarity index 68% rename from vitrage/tests/unit/synchronizer/plugins/static_physical/test_static_physical_synchronizer.py rename to vitrage/tests/unit/datasources/static_physical/test_static_physical_driver.py index 91033242c..7f60366df 100644 --- a/vitrage/tests/unit/synchronizer/plugins/static_physical/test_static_physical_synchronizer.py +++ b/vitrage/tests/unit/datasources/static_physical/test_static_physical_driver.py @@ -22,9 +22,9 @@ from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import SyncMode from vitrage.common.constants import VertexProperties as VProps from vitrage.common import file_utils -from vitrage.synchronizer.plugins.static_physical import STATIC_PHYSICAL_PLUGIN -from vitrage.synchronizer.plugins.static_physical import SWITCH -from vitrage.synchronizer.plugins.static_physical import synchronizer +from vitrage.datasources.static_physical import driver +from vitrage.datasources.static_physical import STATIC_PHYSICAL_DATASOURCE +from vitrage.datasources.static_physical import SWITCH from vitrage.tests import base from vitrage.tests.mocks import utils @@ -32,33 +32,33 @@ from vitrage.tests.mocks import utils LOG = logging.getLogger(__name__) -class TestStaticPhysicalSynchronizer(base.BaseTest): +class TestStaticPhysicalDriver(base.BaseTest): OPTS = [ cfg.StrOpt('transformer', - default='vitrage.synchronizer.plugins.static_physical.' - 'transformer.StaticPhysicalTransformer'), - cfg.StrOpt('synchronizer', - default='vitrage.synchronizer.plugins.static_physical' - '.synchronizer.StaticPhysicalTransformer'), + default='vitrage.datasources.static_physical.transformer.' + 'StaticPhysicalTransformer'), + cfg.StrOpt('driver', + default='vitrage.datasources.static_physical.driver.' + 'StaticPhysicalDriver'), cfg.IntOpt('changes_interval', default=30, min=30, help='interval between checking changes in the ' 'configuration files of the physical topology plugin'), cfg.StrOpt('directory', - default=utils.get_resources_dir() + '/static_plugins'), + default=utils.get_resources_dir() + '/static_datasources'), cfg.ListOpt('entities', default=[SWITCH]) ] CHANGES_OPTS = [ cfg.StrOpt('transformer', - default='vitrage.synchronizer.plugins.static_physical.' - 'transformer.StaticPhysicalTransformer'), - cfg.StrOpt('synchronizer', - default='vitrage.synchronizer.plugins.static_physical' - '.synchronizer.StaticPhysicalTransformer'), + default='vitrage.datasources.static_physical.transformer.' + 'StaticPhysicalTransformer'), + cfg.StrOpt('driver', + default='vitrage.datasources.static_physical.driver.' + 'StaticPhysicalDriver'), cfg.IntOpt('changes_interval', default=30, min=30, @@ -66,20 +66,19 @@ class TestStaticPhysicalSynchronizer(base.BaseTest): 'configuration files of the physical topology plugin'), cfg.StrOpt('directory', default=utils.get_resources_dir() + - '/static_plugins/changes_plugins'), + '/static_datasources/changes_datasources'), ] # noinspection PyAttributeOutsideInit,PyPep8Naming @classmethod def setUpClass(cls): cls.conf = cfg.ConfigOpts() - cls.conf.register_opts(cls.OPTS, group=STATIC_PHYSICAL_PLUGIN) - cls.static_physical_synchronizer = \ - synchronizer.StaticPhysicalSynchronizer(cls.conf) + cls.conf.register_opts(cls.OPTS, group=STATIC_PHYSICAL_DATASOURCE) + cls.static_physical_driver = driver.StaticPhysicalDriver(cls.conf) - def test_static_plugins_loader(self): + def test_static_datasources_loader(self): # Setup - total_static_plugins = \ + total_static_datasources = \ os.listdir(self.conf.static_physical.directory) # Action @@ -87,13 +86,13 @@ class TestStaticPhysicalSynchronizer(base.BaseTest): self.conf.static_physical.directory) # Test assertions - # -1 is because there are 2 files and a folder in static_plugins_dir - self.assertEqual(len(total_static_plugins) - 1, len(static_configs)) + # -1 is because there are 2 files and a folder in static_datasource_dir + self.assertEqual(len(total_static_datasources) - 1, + len(static_configs)) def test_get_all(self): # Action - static_entities = self.static_physical_synchronizer.get_all( - SyncMode.UPDATE) + static_entities = self.static_physical_driver.get_all(SyncMode.UPDATE) # Test assertions self.assertEqual(5, len(static_entities)) @@ -101,16 +100,16 @@ class TestStaticPhysicalSynchronizer(base.BaseTest): # noinspection PyAttributeOutsideInit def test_get_changes(self): # Setup - entities = self.static_physical_synchronizer.get_all(SyncMode.UPDATE) + entities = self.static_physical_driver.get_all(SyncMode.UPDATE) self.assertEqual(5, len(entities)) self.conf = cfg.ConfigOpts() self.conf.register_opts(self.CHANGES_OPTS, - group=STATIC_PHYSICAL_PLUGIN) - self.static_physical_synchronizer.cfg = self.conf + group=STATIC_PHYSICAL_DATASOURCE) + self.static_physical_driver.cfg = self.conf # Action - changes = self.static_physical_synchronizer.get_changes( + changes = self.static_physical_driver.get_changes( EventAction.UPDATE_ENTITY) # Test Assertions @@ -138,7 +137,7 @@ class TestStaticPhysicalSynchronizer(base.BaseTest): self.assertEqual(4, len(changes)) # Action - changes = self.static_physical_synchronizer.get_changes( + changes = self.static_physical_driver.get_changes( EventAction.UPDATE_ENTITY) # Test Assertions diff --git a/vitrage/tests/unit/synchronizer/plugins/static_physical/test_static_physical_transformer.py b/vitrage/tests/unit/datasources/static_physical/test_static_physical_transformer.py similarity index 89% rename from vitrage/tests/unit/synchronizer/plugins/static_physical/test_static_physical_transformer.py rename to vitrage/tests/unit/datasources/static_physical/test_static_physical_transformer.py index 188f5f73e..5fb913aa9 100644 --- a/vitrage/tests/unit/synchronizer/plugins/static_physical/test_static_physical_transformer.py +++ b/vitrage/tests/unit/datasources/static_physical/test_static_physical_transformer.py @@ -20,14 +20,14 @@ from vitrage.common.constants import EdgeLabels from vitrage.common.constants import EntityCategory from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import VertexProperties as VProps -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.nova.host.transformer import HostTransformer -from vitrage.synchronizer.plugins.static_physical import STATIC_PHYSICAL_PLUGIN -from vitrage.synchronizer.plugins.static_physical.transformer \ +from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE +from vitrage.datasources.nova.host.transformer import HostTransformer +from vitrage.datasources.static_physical import STATIC_PHYSICAL_DATASOURCE +from vitrage.datasources.static_physical.transformer \ import StaticPhysicalTransformer -from vitrage.synchronizer.plugins.transformer_base import TransformerBase +from vitrage.datasources.transformer_base import TransformerBase from vitrage.tests import base -from vitrage.tests.mocks import mock_syncronizer as mock_sync +from vitrage.tests.mocks import mock_driver as mock_sync LOG = logging.getLogger(__name__) @@ -38,9 +38,10 @@ class TestStaticPhysicalTransformer(base.BaseTest): @classmethod def setUpClass(cls): cls.transformers = {} - cls.transformers[NOVA_HOST_PLUGIN] = HostTransformer(cls.transformers) - cls.transformers[STATIC_PHYSICAL_PLUGIN] = StaticPhysicalTransformer( + cls.transformers[NOVA_HOST_DATASOURCE] = HostTransformer( cls.transformers) + cls.transformers[STATIC_PHYSICAL_DATASOURCE] = \ + StaticPhysicalTransformer(cls.transformers) def test_create_placeholder_vertex(self): @@ -48,7 +49,7 @@ class TestStaticPhysicalTransformer(base.BaseTest): 'vertex') # Test setup - switch_type = STATIC_PHYSICAL_PLUGIN + switch_type = STATIC_PHYSICAL_DATASOURCE switch_name = 'switch-1' timestamp = datetime.datetime.utcnow() static_transformer = StaticPhysicalTransformer(self.transformers) @@ -89,7 +90,7 @@ class TestStaticPhysicalTransformer(base.BaseTest): LOG.debug('Static Physical transformer test: get key values') # Test setup - switch_type = STATIC_PHYSICAL_PLUGIN + switch_type = STATIC_PHYSICAL_DATASOURCE switch_name = 'switch-1' static_transformer = StaticPhysicalTransformer(self.transformers) @@ -99,7 +100,7 @@ class TestStaticPhysicalTransformer(base.BaseTest): # Test assertions self.assertEqual(EntityCategory.RESOURCE, observed_key_fields[0]) - self.assertEqual(STATIC_PHYSICAL_PLUGIN, observed_key_fields[1]) + self.assertEqual(STATIC_PHYSICAL_DATASOURCE, observed_key_fields[1]) self.assertEqual(switch_name, observed_key_fields[2]) def test_snapshot_transform(self): diff --git a/vitrage/tests/unit/entity_graph/base.py b/vitrage/tests/unit/entity_graph/base.py index 9373e7632..41b7a7e24 100644 --- a/vitrage/tests/unit/entity_graph/base.py +++ b/vitrage/tests/unit/entity_graph/base.py @@ -18,37 +18,41 @@ from vitrage.common.constants import EntityCategory from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import SyncMode from vitrage.common.datetime_utils import utcnow +from vitrage.datasources.nagios import NAGIOS_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.entity_graph.initialization_status import InitializationStatus from vitrage.entity_graph.processor import processor as proc import vitrage.graph.utils as graph_utils -from vitrage.service import load_plugin -from vitrage.synchronizer.plugins.nagios import NAGIOS_PLUGIN -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.nova.instance import NOVA_INSTANCE_PLUGIN -from vitrage.synchronizer.plugins.nova.zone import NOVA_ZONE_PLUGIN +from vitrage.service import load_datasource from vitrage.tests import base -from vitrage.tests.mocks import mock_syncronizer as mock_sync +from vitrage.tests.mocks import mock_driver as mock_sync from vitrage.tests.mocks import utils class TestEntityGraphUnitBase(base.BaseTest): PROCESSOR_OPTS = [ - cfg.StrOpt('states_plugins_dir', - default=utils.get_resources_dir() + '/states_plugins'), + cfg.StrOpt('datasources_states_dir', + default=utils.get_resources_dir() + '/datasources_states'), ] - PLUGINS_OPTS = [ - cfg.ListOpt('plugin_type', - default=[NAGIOS_PLUGIN, - NOVA_HOST_PLUGIN, - NOVA_INSTANCE_PLUGIN, - NOVA_ZONE_PLUGIN], - help='Names of supported synchronizer plugins'), + DATASOURCES_OPTS = [ + cfg.ListOpt('types', + default=[NAGIOS_DATASOURCE, + NOVA_HOST_DATASOURCE, + NOVA_INSTANCE_DATASOURCE, + NOVA_ZONE_DATASOURCE], + help='Names of supported data sources'), - cfg.ListOpt('plugin_path', - default=['vitrage.synchronizer.plugins'], - help='base path for plugins') + cfg.ListOpt('path', + default=['vitrage.datasources'], + help='base path for data sources'), + + cfg.IntOpt('snapshots_interval', + default=1, + min=1) ] NUM_NODES = 1 @@ -57,9 +61,9 @@ class TestEntityGraphUnitBase(base.BaseTest): NUM_INSTANCES = 16 @staticmethod - def load_plugins(conf): - for plugin_name in conf.plugins.plugin_type: - load_plugin(conf, plugin_name, conf.plugins.plugin_path) + def load_datasources(conf): + for datasource in conf.datasources.types: + load_datasource(conf, datasource, conf.datasources.path) def _create_processor_with_graph(self, conf, processor=None): events = self._create_mock_events() diff --git a/vitrage/tests/unit/entity_graph/processor/base.py b/vitrage/tests/unit/entity_graph/processor/base.py index 500e65ba4..a203d608e 100644 --- a/vitrage/tests/unit/entity_graph/processor/base.py +++ b/vitrage/tests/unit/entity_graph/processor/base.py @@ -27,8 +27,8 @@ class TestBaseProcessor(TestEntityGraphUnitBase): def setUpClass(cls): super(TestBaseProcessor, cls).setUpClass() cls.conf = cfg.ConfigOpts() - cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins') - cls.load_plugins(cls.conf) + cls.conf.register_opts(cls.DATASOURCES_OPTS, group='datasources') + cls.load_datasources(cls.conf) cls.transform = transformer_manager.TransformerManager(cls.conf) @staticmethod diff --git a/vitrage/tests/unit/entity_graph/processor/test_processor.py b/vitrage/tests/unit/entity_graph/processor/test_processor.py index 8b3bd238a..d755ca3c0 100644 --- a/vitrage/tests/unit/entity_graph/processor/test_processor.py +++ b/vitrage/tests/unit/entity_graph/processor/test_processor.py @@ -21,12 +21,12 @@ from vitrage.common.constants import SynchronizerProperties as SyncProps from vitrage.common.constants import SyncMode from vitrage.common.constants import VertexProperties as VProps from vitrage.common.datetime_utils import utcnow +from vitrage.datasources.transformer_base import Neighbor from vitrage.entity_graph.initialization_status import InitializationStatus from vitrage.entity_graph.processor import processor as proc from vitrage.entity_graph.states.normalized_resource_state import \ NormalizedResourceState import vitrage.graph.utils as graph_utils -from vitrage.synchronizer.plugins.transformer_base import Neighbor from vitrage.tests.unit.entity_graph.base import TestEntityGraphUnitBase @@ -46,8 +46,8 @@ class TestProcessor(TestEntityGraphUnitBase): super(TestProcessor, cls).setUpClass() cls.conf = cfg.ConfigOpts() cls.conf.register_opts(cls.PROCESSOR_OPTS, group='entity_graph') - cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins') - cls.load_plugins(cls.conf) + cls.conf.register_opts(cls.DATASOURCES_OPTS, group='datasources') + cls.load_datasources(cls.conf) # TODO(Alexey): un skip this test when instance transformer update is ready @unittest.skip('Not ready yet') diff --git a/vitrage/tests/unit/entity_graph/states/test_state_manager.py b/vitrage/tests/unit/entity_graph/states/test_state_manager.py index bddeb573d..f53e860f0 100644 --- a/vitrage/tests/unit/entity_graph/states/test_state_manager.py +++ b/vitrage/tests/unit/entity_graph/states/test_state_manager.py @@ -16,15 +16,15 @@ from oslo_config import cfg 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.datasources.nova.instance import NOVA_INSTANCE_DATASOURCE +from vitrage.datasources.nova.zone import NOVA_ZONE_DATASOURCE from vitrage.entity_graph.states.normalized_resource_state import \ NormalizedResourceState from vitrage.entity_graph.states.state_manager import StateManager from vitrage.graph.utils import create_vertex -from vitrage.service import load_plugin -from vitrage.synchronizer.plugins.nagios import NAGIOS_PLUGIN -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.nova.instance import NOVA_INSTANCE_PLUGIN -from vitrage.synchronizer.plugins.nova.zone import NOVA_ZONE_PLUGIN +from vitrage.service import load_datasource from vitrage.tests import base from vitrage.tests.mocks import utils @@ -32,27 +32,27 @@ from vitrage.tests.mocks import utils class TestStateManager(base.BaseTest): ENTITY_GRAPH_OPTS = [ - cfg.StrOpt('states_plugins_dir', - default=utils.get_resources_dir() + '/states_plugins'), + cfg.StrOpt('datasources_states_dir', + default=utils.get_resources_dir() + '/datasources_states'), ] - PLUGINS_OPTS = [ - cfg.ListOpt('plugin_type', - default=[NAGIOS_PLUGIN, - NOVA_HOST_PLUGIN, - NOVA_INSTANCE_PLUGIN, - NOVA_ZONE_PLUGIN], - help='Names of supported synchronizer plugins'), + DATASOURCES_OPTS = [ + cfg.ListOpt('types', + default=[NAGIOS_DATASOURCE, + NOVA_HOST_DATASOURCE, + NOVA_INSTANCE_DATASOURCE, + NOVA_ZONE_DATASOURCE], + help='Names of supported data sources'), - cfg.ListOpt('plugin_path', - default=['vitrage.synchronizer.plugins'], - help='base path for plugins') + cfg.ListOpt('path', + default=['vitrage.datasources'], + help='base path for datasources') ] @staticmethod - def _load_plugins(conf): - for plugin_name in conf.plugins.plugin_type: - load_plugin(conf, plugin_name, conf.plugins.plugin_path) + def _load_datasources(conf): + for datasource_name in conf.datasources.types: + load_datasource(conf, datasource_name, conf.datasources.path) # noinspection PyAttributeOutsideInit,PyPep8Naming @classmethod @@ -60,40 +60,42 @@ class TestStateManager(base.BaseTest): super(TestStateManager, cls).setUpClass() cls.conf = cfg.ConfigOpts() cls.conf.register_opts(cls.ENTITY_GRAPH_OPTS, group='entity_graph') - cls.conf.register_opts(cls.PLUGINS_OPTS, group='plugins') - cls._load_plugins(cls.conf) + cls.conf.register_opts(cls.DATASOURCES_OPTS, group='datasources') + cls._load_datasources(cls.conf) - def test_load_state_plugins_without_errors(self): + def test_load_datasource_state_without_errors(self): # action state_manager = StateManager(self.conf) # test assertions - # Total plugins plus the evaluator which is not definable - total_plugins = len(self.conf.plugins.plugin_type) + 1 - self.assertEqual(total_plugins, len(state_manager.states_plugins)) + # Total datasources plus the evaluator which is not definable + total_datasources = len(self.conf.datasources.types) + 1 + self.assertEqual(total_datasources, + len(state_manager.datasources_state_confs)) - def test_load_state_plugins_with_errors(self): + def test_load_datasources_state_with_errors(self): # setup entity_graph_opts = [ - cfg.StrOpt('states_plugins_dir', + cfg.StrOpt('datasources_states_dir', default=utils.get_resources_dir() + - '/states_plugins/erroneous_states_plugins'), + '/datasources_states/erroneous_states'), ] conf = cfg.ConfigOpts() conf.register_opts(entity_graph_opts, group='entity_graph') - conf.register_opts(self.PLUGINS_OPTS, group='plugins') - self._load_plugins(conf) + conf.register_opts(self.DATASOURCES_OPTS, group='datasources') + self._load_datasources(conf) # action state_manager = StateManager(conf) # test assertions - missing_states_plugins = 1 - erroneous_states_plugins = 2 - num_valid_plugins = len(state_manager.states_plugins) + \ - missing_states_plugins + erroneous_states_plugins - self.assertEqual(len(conf.plugins.plugin_type), num_valid_plugins) + missing_states = 1 + erroneous_states = 2 + num_valid_datasources = len(state_manager.datasources_state_confs) + \ + missing_states + erroneous_states + self.assertEqual(len(conf.datasources.types), + num_valid_datasources) def test_normalize_state(self): # setup @@ -102,7 +104,7 @@ class TestStateManager(base.BaseTest): # action normalized_state = \ state_manager.normalize_state(EntityCategory.RESOURCE, - NOVA_INSTANCE_PLUGIN, + NOVA_INSTANCE_DATASOURCE, 'BUILDING') # test assertions @@ -114,7 +116,7 @@ class TestStateManager(base.BaseTest): # action state_priority = \ - state_manager.state_priority(NOVA_INSTANCE_PLUGIN, + state_manager.state_priority(NOVA_INSTANCE_DATASOURCE, NormalizedResourceState.RUNNING) # test assertions @@ -127,13 +129,13 @@ class TestStateManager(base.BaseTest): new_vertex1 = create_vertex('12345', entity_state='ACTIVE', entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_INSTANCE_PLUGIN, + entity_type=NOVA_INSTANCE_DATASOURCE, metadata=metadata1) metadata2 = {VProps.VITRAGE_STATE: 'ACTIVE'} new_vertex2 = create_vertex('23456', entity_state='SUSPENDED', entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_INSTANCE_PLUGIN, + entity_type=NOVA_INSTANCE_DATASOURCE, metadata=metadata2) # action @@ -152,18 +154,18 @@ class TestStateManager(base.BaseTest): new_vertex1 = create_vertex('12345', entity_state='ACTIVE', entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_INSTANCE_PLUGIN) + entity_type=NOVA_INSTANCE_DATASOURCE) metadata2 = {VProps.VITRAGE_STATE: 'SUBOPTIMAL'} new_vertex2 = create_vertex('23456', entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_INSTANCE_PLUGIN, + entity_type=NOVA_INSTANCE_DATASOURCE, metadata=metadata2) new_vertex3 = create_vertex('34567', entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_INSTANCE_PLUGIN) + entity_type=NOVA_INSTANCE_DATASOURCE) graph_vertex3 = create_vertex('45678', entity_category=EntityCategory.RESOURCE, - entity_type=NOVA_INSTANCE_PLUGIN) + entity_type=NOVA_INSTANCE_DATASOURCE) # action state_manager.aggregated_state(new_vertex1, diff --git a/vitrage/tests/unit/entity_graph/test_transformer_manager.py b/vitrage/tests/unit/entity_graph/test_transformer_manager.py index 4e6c8bcc0..5dbb1f717 100644 --- a/vitrage/tests/unit/entity_graph/test_transformer_manager.py +++ b/vitrage/tests/unit/entity_graph/test_transformer_manager.py @@ -15,20 +15,16 @@ from oslo_config import cfg from oslo_log import log as logging +from vitrage.datasources.nagios import NAGIOS_DATASOURCE +from vitrage.datasources.nagios.transformer import NagiosTransformer +from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE +from vitrage.datasources.nova.host.transformer import HostTransformer +from vitrage.datasources.nova.instance import NOVA_INSTANCE_DATASOURCE +from vitrage.datasources.nova.instance.transformer import InstanceTransformer +from vitrage.datasources.nova.zone import NOVA_ZONE_DATASOURCE +from vitrage.datasources.nova.zone.transformer import ZoneTransformer from vitrage.entity_graph.transformer_manager import TransformerManager -from vitrage.service import load_plugin -from vitrage.synchronizer.plugins.nagios import NAGIOS_PLUGIN -from vitrage.synchronizer.plugins.nagios.transformer import \ - NagiosTransformer -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.nova.host.transformer import \ - HostTransformer -from vitrage.synchronizer.plugins.nova.instance import NOVA_INSTANCE_PLUGIN -from vitrage.synchronizer.plugins.nova.instance.transformer import \ - InstanceTransformer -from vitrage.synchronizer.plugins.nova.zone import NOVA_ZONE_PLUGIN -from vitrage.synchronizer.plugins.nova.zone.transformer import \ - ZoneTransformer +from vitrage.service import load_datasource from vitrage.tests import base LOG = logging.getLogger(__name__) @@ -37,41 +33,41 @@ LOG = logging.getLogger(__name__) class TransformerManagerTest(base.BaseTest): OPTS = [ - cfg.ListOpt('plugin_type', - default=[NAGIOS_PLUGIN, - NOVA_HOST_PLUGIN, - NOVA_INSTANCE_PLUGIN, - NOVA_ZONE_PLUGIN], - help='Names of supported synchronizer plugins'), + cfg.ListOpt('types', + default=[NAGIOS_DATASOURCE, + NOVA_HOST_DATASOURCE, + NOVA_INSTANCE_DATASOURCE, + NOVA_ZONE_DATASOURCE], + help='Names of supported data sources'), - cfg.ListOpt('plugin_path', - default=['vitrage.synchronizer.plugins'], - help='base path for plugins') + cfg.ListOpt('path', + default=['vitrage.datasources'], + help='base path for data sources') ] # noinspection PyPep8Naming @classmethod def setUpClass(cls): cls.conf = cfg.ConfigOpts() - cls.conf.register_opts(cls.OPTS, group='plugins') + cls.conf.register_opts(cls.OPTS, group='datasources') - for plugin_name in cls.conf.plugins.plugin_type: - load_plugin(cls.conf, plugin_name, cls.conf.plugins.plugin_path) + for datasource in cls.conf.datasources.types: + load_datasource(cls.conf, datasource, cls.conf.datasources.path) cls.manager = TransformerManager(cls.conf) def test_transformer_registration_nagios(self): self.assertIsInstance(self.manager.get_transformer - (NAGIOS_PLUGIN), NagiosTransformer) + (NAGIOS_DATASOURCE), NagiosTransformer) def test_transformer_registration_nova_host(self): self.assertIsInstance(self.manager.get_transformer - (NOVA_HOST_PLUGIN), HostTransformer) + (NOVA_HOST_DATASOURCE), HostTransformer) def test_transformer_registration_nova_instance(self): self.assertIsInstance(self.manager.get_transformer - (NOVA_INSTANCE_PLUGIN), InstanceTransformer) + (NOVA_INSTANCE_DATASOURCE), InstanceTransformer) def test_transformer_registration_nova_zone(self): self.assertIsInstance(self.manager.get_transformer - (NOVA_ZONE_PLUGIN), ZoneTransformer) + (NOVA_ZONE_DATASOURCE), ZoneTransformer) diff --git a/vitrage/tests/unit/evaluator/recipes/test_raise_alarm.py b/vitrage/tests/unit/evaluator/recipes/test_raise_alarm.py index f5b0fc4e6..42b1f94b5 100644 --- a/vitrage/tests/unit/evaluator/recipes/test_raise_alarm.py +++ b/vitrage/tests/unit/evaluator/recipes/test_raise_alarm.py @@ -14,6 +14,7 @@ from oslo_log import log as logging from vitrage.common.constants import NotifierEventTypes +from vitrage.datasources.alarm_properties import AlarmProperties from vitrage.evaluator.actions.base import ActionType from vitrage.evaluator.actions.recipes.action_steps import ADD_VERTEX from vitrage.evaluator.actions.recipes.action_steps import NOTIFY @@ -21,7 +22,6 @@ from vitrage.evaluator.actions.recipes.action_steps import REMOVE_VERTEX from vitrage.evaluator.actions.recipes.raise_alarm import RaiseAlarm from vitrage.evaluator.template import ActionSpecs from vitrage.evaluator.template_fields import TemplateFields as TFields -from vitrage.synchronizer.plugins.base.alarm.properties import AlarmProperties from vitrage.tests import base diff --git a/vitrage/tests/unit/graph/base.py b/vitrage/tests/unit/graph/base.py index 1d97ffc2f..8d5862c35 100644 --- a/vitrage/tests/unit/graph/base.py +++ b/vitrage/tests/unit/graph/base.py @@ -26,12 +26,12 @@ from oslo_log import log as logging from vitrage.common.constants import EdgeLabels as ELabel from vitrage.common.constants import EntityCategory +from vitrage.datasources.nova.host import NOVA_HOST_DATASOURCE +from vitrage.datasources.nova.instance import NOVA_INSTANCE_DATASOURCE +from vitrage.datasources import OPENSTACK_NODE +from vitrage.datasources.static_physical import SWITCH from vitrage.graph import create_graph from vitrage.graph import utils as graph_utils -from vitrage.synchronizer.plugins.nova.host import NOVA_HOST_PLUGIN -from vitrage.synchronizer.plugins.nova.instance import NOVA_INSTANCE_PLUGIN -from vitrage.synchronizer.plugins import OPENSTACK_NODE -from vitrage.synchronizer.plugins.static_physical import SWITCH from vitrage.tests import base LOG = logging.getLogger(__name__) @@ -56,14 +56,14 @@ v_node = graph_utils.create_vertex( entity_type=OPENSTACK_NODE, entity_category=RESOURCE) v_host = graph_utils.create_vertex( - vitrage_id=NOVA_HOST_PLUGIN + '222222222222', + vitrage_id=NOVA_HOST_DATASOURCE + '222222222222', entity_id='222222222222', - entity_type=NOVA_HOST_PLUGIN, + entity_type=NOVA_HOST_DATASOURCE, entity_category=RESOURCE) v_instance = graph_utils.create_vertex( - vitrage_id=NOVA_INSTANCE_PLUGIN + '333333333333', + vitrage_id=NOVA_INSTANCE_DATASOURCE + '333333333333', entity_id='333333333333', - entity_type=NOVA_INSTANCE_PLUGIN, + entity_type=NOVA_INSTANCE_DATASOURCE, entity_category=RESOURCE) v_alarm = graph_utils.create_vertex( vitrage_id=ALARM + '444444444444', @@ -150,7 +150,7 @@ class GraphTestBase(base.BaseTest): for host_id in range(num_of_hosts_per_node): host_to_add = add_connected_vertex(g, RESOURCE, - NOVA_HOST_PLUGIN, + NOVA_HOST_DATASOURCE, host_id, ELabel.CONTAINS, v_node, @@ -176,7 +176,7 @@ class GraphTestBase(base.BaseTest): for j in range(num_of_vms_per_host): vm_to_add = add_connected_vertex(g, RESOURCE, - NOVA_INSTANCE_PLUGIN, + NOVA_INSTANCE_DATASOURCE, self.vm_id, ELabel.CONTAINS, host_to_add, diff --git a/vitrage/tests/unit/graph/test_graph.py b/vitrage/tests/unit/graph/test_graph.py index e2a757b20..aa60a03d6 100644 --- a/vitrage/tests/unit/graph/test_graph.py +++ b/vitrage/tests/unit/graph/test_graph.py @@ -55,7 +55,7 @@ class GraphTest(GraphTestBase): v_from_graph_copy = graph_copy.get_vertex(v_host.vertex_id) self.assertEqual(ALARM, v_from_g[VProps.CATEGORY], 'graph vertex changed after update') - self.assertEqual(NOVA_HOST_PLUGIN, v_from_graph_copy[VProps.TYPE], + self.assertEqual(NOVA_HOST_DATASOURCE, v_from_graph_copy[VProps.TYPE], 'graph copy vertex unchanged after update') def test_vertex_crud(self): @@ -102,7 +102,7 @@ class GraphTest(GraphTestBase): another_vertex = utils.create_vertex( vitrage_id='123', entity_id='456', - entity_category=NOVA_INSTANCE_PLUGIN, + entity_category=NOVA_INSTANCE_DATASOURCE, metadata={'some_meta': 'DATA'} ) g.add_vertex(another_vertex) @@ -230,7 +230,7 @@ class GraphTest(GraphTestBase): v4 = v_alarm v5 = utils.create_vertex( vitrage_id='kuku', - entity_category=NOVA_HOST_PLUGIN) + entity_category=NOVA_HOST_DATASOURCE) g = create_graph('test_neighbors') g.add_vertex(v1) @@ -274,7 +274,7 @@ class GraphTest(GraphTestBase): v1_neighbors = g.neighbors( v_id=v1.vertex_id, - vertex_attr_filter={VProps.TYPE: NOVA_HOST_PLUGIN}) + vertex_attr_filter={VProps.TYPE: NOVA_HOST_DATASOURCE}) self._assert_set_equal({v2}, v1_neighbors, 'Check V1 neighbors, vertex property filter') @@ -303,7 +303,7 @@ class GraphTest(GraphTestBase): v_id=v1.vertex_id, direction=Direction.IN, edge_attr_filter={EProps.RELATIONSHIP_TYPE: relationship_c}, - vertex_attr_filter={VProps.TYPE: NOVA_HOST_PLUGIN}) + vertex_attr_filter={VProps.TYPE: NOVA_HOST_DATASOURCE}) self._assert_set_equal( {v2}, v1_neighbors, 'Check V1 neighbors, vertex/edge property filter and direction') @@ -316,13 +316,14 @@ class GraphTest(GraphTestBase): v2_neighbors = g.neighbors( v_id=v2.vertex_id, - vertex_attr_filter={VProps.CATEGORY: NOVA_HOST_PLUGIN}) + vertex_attr_filter={VProps.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_PLUGIN, ALARM]}) + vertex_attr_filter={VProps.CATEGORY: [NOVA_HOST_DATASOURCE, + ALARM]}) self._assert_set_equal({v4}, v2_neighbors, 'Check v2 neighbors, vertex property filter') @@ -333,8 +334,8 @@ class GraphTest(GraphTestBase): }, vertex_attr_filter={ VProps.CATEGORY: [RESOURCE, ALARM], - VProps.TYPE: [NOVA_HOST_PLUGIN, - NOVA_INSTANCE_PLUGIN, + VProps.TYPE: [NOVA_HOST_DATASOURCE, + NOVA_INSTANCE_DATASOURCE, ALARM_ON_VM, ALARM_ON_HOST] } @@ -350,13 +351,13 @@ class GraphTest(GraphTestBase): v3_neighbors = g.neighbors( v_id=v3.vertex_id, - vertex_attr_filter={VProps.CATEGORY: NOVA_HOST_PLUGIN}, + vertex_attr_filter={VProps.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_PLUGIN}) + vertex_attr_filter={VProps.CATEGORY: NOVA_HOST_DATASOURCE}) self._assert_set_equal({}, v5_neighbors, 'Check neighbors for not connected vertex') diff --git a/vitrage/tests/unit/graph/test_graph_algo.py b/vitrage/tests/unit/graph/test_graph_algo.py index dfa969837..442cfec7b 100644 --- a/vitrage/tests/unit/graph/test_graph_algo.py +++ b/vitrage/tests/unit/graph/test_graph_algo.py @@ -36,7 +36,7 @@ class GraphAlgorithmTest(GraphTestBase): query = { 'or': [ - {'==': {VProps.TYPE: NOVA_HOST_PLUGIN}}, + {'==': {VProps.TYPE: NOVA_HOST_DATASOURCE}}, {'==': {VProps.TYPE: OPENSTACK_NODE}} ] } @@ -48,9 +48,9 @@ class GraphAlgorithmTest(GraphTestBase): query = { 'or': [ - {'==': {VProps.TYPE: NOVA_INSTANCE_PLUGIN}}, + {'==': {VProps.TYPE: NOVA_INSTANCE_DATASOURCE}}, {'==': {VProps.CATEGORY: ALARM}}, - {'==': {VProps.TYPE: NOVA_HOST_PLUGIN}}, + {'==': {VProps.TYPE: NOVA_HOST_DATASOURCE}}, {'==': {VProps.TYPE: OPENSTACK_NODE}} ] } @@ -65,7 +65,7 @@ class GraphAlgorithmTest(GraphTestBase): # Get first host ID neighboring_hosts = self.entity_graph.neighbors( - v_node.vertex_id, {VProps.TYPE: NOVA_HOST_PLUGIN}) + v_node.vertex_id, {VProps.TYPE: NOVA_HOST_DATASOURCE}) first_host_id = neighboring_hosts.pop().vertex_id query = {'!=': {'NOTHING': 'IS EVERYTHING'}} @@ -83,7 +83,7 @@ class GraphAlgorithmTest(GraphTestBase): query = { 'or': [ {'==': {VProps.TYPE: SWITCH}}, - {'==': {VProps.TYPE: NOVA_HOST_PLUGIN}}, + {'==': {VProps.TYPE: NOVA_HOST_DATASOURCE}}, ] } subgraph = ga.graph_query_vertices( @@ -159,11 +159,11 @@ class GraphAlgorithmTest(GraphTestBase): t_v_host = graph_utils.create_vertex( vitrage_id='2', entity_category=RESOURCE, - entity_type=NOVA_HOST_PLUGIN) + entity_type=NOVA_HOST_DATASOURCE) t_v_vm = graph_utils.create_vertex( vitrage_id='3', entity_category=RESOURCE, - entity_type=NOVA_INSTANCE_PLUGIN) + entity_type=NOVA_INSTANCE_DATASOURCE) t_v_vm_alarm = graph_utils.create_vertex( vitrage_id='4', entity_category=ALARM, entity_type=ALARM_ON_VM) t_v_switch = graph_utils.create_vertex( diff --git a/vitrage/tests/unit/synchronizer/plugins/__init__.py b/vitrage/tests/unit/synchronizer/plugins/__init__.py deleted file mode 100644 index dd32b852f..000000000 --- a/vitrage/tests/unit/synchronizer/plugins/__init__.py +++ /dev/null @@ -1,15 +0,0 @@ -# Copyright 2016 - Nokia -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -__author__ = 'stack' diff --git a/vitrage/tests/unit/synchronizer/plugins/cinder/__init__.py b/vitrage/tests/unit/synchronizer/plugins/cinder/__init__.py deleted file mode 100644 index dd32b852f..000000000 --- a/vitrage/tests/unit/synchronizer/plugins/cinder/__init__.py +++ /dev/null @@ -1,15 +0,0 @@ -# Copyright 2016 - Nokia -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -__author__ = 'stack' diff --git a/vitrage/tests/unit/synchronizer/plugins/nagios/__init__.py b/vitrage/tests/unit/synchronizer/plugins/nagios/__init__.py deleted file mode 100644 index dd32b852f..000000000 --- a/vitrage/tests/unit/synchronizer/plugins/nagios/__init__.py +++ /dev/null @@ -1,15 +0,0 @@ -# Copyright 2016 - Nokia -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -__author__ = 'stack' diff --git a/vitrage/tests/unit/synchronizer/plugins/nova/__init__.py b/vitrage/tests/unit/synchronizer/plugins/nova/__init__.py deleted file mode 100644 index dd32b852f..000000000 --- a/vitrage/tests/unit/synchronizer/plugins/nova/__init__.py +++ /dev/null @@ -1,15 +0,0 @@ -# Copyright 2016 - Nokia -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -__author__ = 'stack' diff --git a/vitrage/tests/unit/synchronizer/plugins/static_physical/__init__.py b/vitrage/tests/unit/synchronizer/plugins/static_physical/__init__.py deleted file mode 100644 index dd32b852f..000000000 --- a/vitrage/tests/unit/synchronizer/plugins/static_physical/__init__.py +++ /dev/null @@ -1,15 +0,0 @@ -# Copyright 2016 - Nokia -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -__author__ = 'stack' diff --git a/vitrage_tempest_tests/tests/base_mock.py b/vitrage_tempest_tests/tests/base_mock.py index fb28a71ae..91ca56d54 100644 --- a/vitrage_tempest_tests/tests/base_mock.py +++ b/vitrage_tempest_tests/tests/base_mock.py @@ -19,7 +19,7 @@ from oslo_config import cfg from vitrage.entity_graph.initialization_status import InitializationStatus from vitrage.entity_graph.processor import processor as proc -from vitrage.tests.mocks import mock_syncronizer as mock_sync +from vitrage.tests.mocks import mock_driver as mock_sync from vitrage.tests.mocks import utils @@ -27,8 +27,8 @@ class BaseMock(testtools.TestCase): """Base test class for Vitrage API tests.""" PROCESSOR_OPTS = [ - cfg.StrOpt('states_plugins_dir', - default=utils.get_resources_dir() + '/states_plugins'), + cfg.StrOpt('states_datasources_dir', + default=utils.get_resources_dir() + '/datasources_states'), ] def create_processor_with_graph(self):