openstack
/
vitrage
Code Issues Proposed changes

Merge "create collector service"

This commit is contained in:
Jenkins 2017-06-21 13:12:08 +00:00 committed by Gerrit Code Review
parent 542ca3677d bdfa317e09
commit f6f6f7ee84
30 changed files with 294 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
devstack/plugin.sh
View File

@ -231,6 +231,7 @@ function start_vitrage {
fi
fi
run_process vitrage-collector "$VITRAGE_BIN_DIR/vitrage-collector --config-file $VITRAGE_CONF"
run_process vitrage-graph "$VITRAGE_BIN_DIR/vitrage-graph --config-file $VITRAGE_CONF"
run_process vitrage-notifier "$VITRAGE_BIN_DIR/vitrage-notifier --config-file $VITRAGE_CONF"
}
@ -242,7 +243,7 @@ function stop_vitrage {
restart_apache_server
fi
# Kill the vitrage screen windows
for serv in vitrage-api vitrage-graph vitrage-notifier; do
for serv in vitrage-api vitrage-collector vitrage-graph vitrage-notifier; do
stop_process $serv
done
}

3
devstack/settings
View File

@ -6,6 +6,9 @@ enable_service vitrage-graph
# Notifier
enable_service vitrage-notifier
# Notifier
enable_service vitrage-collector
# Default directories
VITRAGE_DIR=$DEST/vitrage

1
setup.cfg
View File

@ -28,6 +28,7 @@ console_scripts =
vitrage-api = vitrage.cmd.api:main
vitrage-graph = vitrage.cmd.graph:main
vitrage-notifier = vitrage.cmd.notifier:main
vitrage-collector = vitrage.cmd.collector:main
vitrage.entity_graph =
networkx = vitrage.graph.driver.networkx_graph:NXGraph

44
vitrage/cmd/collector.py Normal file
View File

@ -0,0 +1,44 @@
# Copyright 2017 - 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.
import sys
from oslo_service import service as os_service
from vitrage.datasources.listener_service import ListenerService
from vitrage.datasources.collector_notifier import CollectorNotifier
from vitrage.datasources import launcher as datasource_launcher
from vitrage.entity_graph import utils
from vitrage import service
def main():
"""Starts all the datasources drivers services"""
conf = service.prepare_service()
launcher = os_service.ServiceLauncher(conf)
rabbitmq = CollectorNotifier(conf)
callback = datasource_launcher.create_send_to_queue_callback(rabbitmq)
launcher.launch_service(ListenerService(conf,
utils.get_drivers(conf),
callback))
datasources = datasource_launcher.Launcher(conf, callback)
datasources.launch()
launcher.wait()
if __name__ == "__main__":
sys.exit(main())

14
vitrage/cmd/graph.py
View File

@ -13,7 +13,6 @@
# License for the specific language governing permissions and limitations
# under the License.
import multiprocessing
from six.moves import queue
import sys
@ -21,7 +20,6 @@ from oslo_service import service as os_service
from vitrage.api_handler import service as api_handler_svc
from vitrage.common.constants import EntityCategory
from vitrage.datasources import launcher as datasource_launcher
from vitrage.datasources import OPENSTACK_CLUSTER
from vitrage.datasources.transformer_base import CLUSTER_ID
from vitrage import entity_graph
@ -44,20 +42,15 @@ def main():
conf = service.prepare_service()
init_status = InitializationStatus()
mp_queue, evaluator_queue, evaluator, e_graph = init(conf)
evaluator_queue, evaluator, e_graph = init(conf)
launcher = os_service.ServiceLauncher(conf)
datasources = datasource_launcher.Launcher(
conf,
datasource_launcher.create_send_to_queue_callback(mp_queue))
launcher.launch_service(entity_graph_svc.VitrageGraphService(
conf, mp_queue, evaluator_queue, evaluator, e_graph, init_status))
conf, evaluator_queue, evaluator, e_graph, init_status))
launcher.launch_service(api_handler_svc.VitrageApiHandlerService(
conf, e_graph, evaluator.scenario_repo))
datasources.launch()
launcher.launch_service(consistency_svc.VitrageGraphConsistencyService(
conf, evaluator_queue, evaluator, e_graph, init_status))
@ -65,7 +58,6 @@ def main():
def init(conf):
mp_queue = multiprocessing.Queue()
evaluator_q = queue.Queue()
e_graph = entity_graph.get_graph_driver(conf)(
'Entity Graph',
@ -75,7 +67,7 @@ def init(conf):
evaluator = ScenarioEvaluator(conf, e_graph, scenario_repo, evaluator_q)
return mp_queue, evaluator_q, evaluator, e_graph
return evaluator_q, evaluator, e_graph
if __name__ == "__main__":

6
vitrage/datasources/__init__.py
View File

@ -47,5 +47,9 @@ OPTS = [
' in case of fault'),
cfg.StrOpt('notification_topic',
default='vitrage_notifications',
help='Vitrage configured notifications topic')
help='Vitrage configured notifications topic'),
cfg.StrOpt('notification_topic_collector',
default='collector_event_notification',
help='The topic on which event will be sent from the '
'datasources to the graph processor')
]

6
vitrage/datasources/cinder/volume/driver.py
View File

@ -42,7 +42,7 @@ class CinderVolumeDriver(DriverBase):
search_opts={'all_tenants': 1})),
CINDER_VOLUME_DATASOURCE,
datasource_action,
'manager')
*self.properties_to_filter_out())
def enrich_event(self, event, event_type):
event[DSProps.EVENT_TYPE] = event_type
@ -51,6 +51,10 @@ class CinderVolumeDriver(DriverBase):
CINDER_VOLUME_DATASOURCE,
DatasourceAction.UPDATE)[0]
@staticmethod
def properties_to_filter_out():
return ['manager']
@staticmethod
def get_event_types():
return ['volume.create.start',

53
vitrage/datasources/collector_notifier.py Normal file
View File

@ -0,0 +1,53 @@
# Copyright 2017 - 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_log import log
import oslo_messaging
from vitrage.messaging import get_transport
LOG = log.getLogger(__name__)
class CollectorNotifier(object):
"""Allows writing to message bus"""
def __init__(self, conf):
self.oslo_notifier = None
try:
topic = conf.datasources.notification_topic_collector
self.oslo_notifier = oslo_messaging.Notifier(
get_transport(conf),
driver='messagingv2',
publisher_id='datasources.events',
topics=[topic])
except Exception as e:
LOG.info('Collector notifier - missing configuration %s'
% str(e))
@property
def enabled(self):
return self.oslo_notifier is not None
def notify_when_applicable(self, enriched_event):
"""Callback subscribed to driver.graph updates
:param enriched_event: the event with enriched data added by the driver
"""
try:
self.oslo_notifier.info({}, '', enriched_event)
except Exception as e:
LOG.exception('Datasource event cannot be notified - %s\n'
'Error - %s', enriched_event, e)

5
vitrage/datasources/driver_base.py
View File

@ -114,3 +114,8 @@ class DriverBase(object):
"""
return []
@staticmethod
def properties_to_filter_out():
"""Return a list of properties to be removed from the event"""
return []

43
vitrage/datasources/heat/stack/driver.py
View File

@ -15,10 +15,14 @@
from vitrage.common.constants import DatasourceAction
from vitrage.common.constants import DatasourceProperties as DSProps
from vitrage.datasources.cinder.volume import CINDER_VOLUME_DATASOURCE
from vitrage.datasources.cinder.volume.driver import CinderVolumeDriver
from vitrage.datasources.driver_base import DriverBase
from vitrage.datasources.heat.stack import HEAT_STACK_DATASOURCE
from vitrage.datasources.neutron.network.driver import NetworkDriver
from vitrage.datasources.neutron.network import NEUTRON_NETWORK_DATASOURCE
from vitrage.datasources.neutron.port.driver import PortDriver
from vitrage.datasources.neutron.port import NEUTRON_PORT_DATASOURCE
from vitrage.datasources.nova.instance.driver import InstanceDriver
from vitrage.datasources.nova.instance import NOVA_INSTANCE_DATASOURCE
from vitrage import os_clients
@ -28,13 +32,20 @@ class HeatStackDriver(DriverBase):
_client = None
conf = None
RESOURCE_TYPE_CONVERSION = {
RESOURCE_TYPE = {
'OS::Nova::Server': NOVA_INSTANCE_DATASOURCE,
'OS::Cinder::Volume': CINDER_VOLUME_DATASOURCE,
'OS::Neutron::Net': NEUTRON_NETWORK_DATASOURCE,
'OS::Neutron::Port': NEUTRON_PORT_DATASOURCE
}
RESOURCE_DRIVERS = {
'OS::Nova::Server': InstanceDriver,
'OS::Cinder::Volume': CinderVolumeDriver,
'OS::Neutron::Net': NetworkDriver,
'OS::Neutron::Port': PortDriver
}
def __init__(self, conf):
super(HeatStackDriver, self).__init__()
HeatStackDriver.conf = conf
@ -72,19 +83,21 @@ class HeatStackDriver(DriverBase):
event = HeatStackDriver._retrieve_stack_resources(
event, event['stack_identity'])
return HeatStackDriver.make_pickleable([event],
HEAT_STACK_DATASOURCE,
DatasourceAction.UPDATE)[0]
return HeatStackDriver.make_pickleable(
[event],
HEAT_STACK_DATASOURCE,
DatasourceAction.UPDATE,
*self.properties_to_filter_out())[0]
def _filter_resource_types(self):
types = self.conf.datasources.types
tmp_dict = {}
for key, value in HeatStackDriver.RESOURCE_TYPE_CONVERSION.items():
for key, value in HeatStackDriver.RESOURCE_TYPE.items():
if value in types:
tmp_dict[key] = value
HeatStackDriver.RESOURCE_TYPE_CONVERSION = tmp_dict
HeatStackDriver.RESOURCE_TYPE = tmp_dict
def _make_stacks_list(self, stacks):
return [stack.__dict__ for stack in stacks]
@ -93,14 +106,28 @@ class HeatStackDriver(DriverBase):
return [self._retrieve_stack_resources(stack, stack['id'])
for stack in stacks]
@staticmethod
def properties_to_filter_out():
return ['manager', '_info']
@staticmethod
def _retrieve_stack_resources(stack, stack_id):
resources = HeatStackDriver.client().resources.list(stack_id)
stack['resources'] = [resource.__dict__ for resource in resources
if resource.__dict__['resource_type'] in
HeatStackDriver.RESOURCE_TYPE_CONVERSION]
HeatStackDriver.RESOURCE_TYPE]
HeatStackDriver._filter_stack_resources(stack)
return stack
@staticmethod
def _filter_stack_resources(stack):
for resource in stack['resources']:
props = HeatStackDriver.RESOURCE_DRIVERS[
resource['resource_type']].properties_to_filter_out()
for prop in props:
if prop in resource:
del resource[prop]
def get_all(self, datasource_action):
stacks = HeatStackDriver.client().stacks.list(global_tenant=True)
stacks_list = self._make_stacks_list(stacks)
@ -108,4 +135,4 @@ class HeatStackDriver(DriverBase):
return self.make_pickleable(stacks_with_resources,
HEAT_STACK_DATASOURCE,
datasource_action,
'manager')
*self.properties_to_filter_out())

4
vitrage/datasources/heat/stack/transformer.py
View File

@ -32,7 +32,7 @@ import vitrage.graph.utils as graph_utils
class HeatStackTransformer(ResourceTransformerBase):
RESOURCE_TYPE_CONVERSION = {
RESOURCE_TYPE = {
'OS::Nova::Server': NOVA_INSTANCE_DATASOURCE,
'OS::Cinder::Volume': CINDER_VOLUME_DATASOURCE,
'OS::Neutron::Net': NEUTRON_NETWORK_DATASOURCE,
@ -124,7 +124,7 @@ class HeatStackTransformer(ResourceTransformerBase):
for neighbor in entity_event['resources']:
neighbor_id = neighbor['physical_resource_id']
neighbor_datasource_type = \
self.RESOURCE_TYPE_CONVERSION[neighbor['resource_type']]
self.RESOURCE_TYPE[neighbor['resource_type']]
neighbors.append(self._create_neighbor(entity_event,
neighbor_id,
neighbor_datasource_type,

37
vitrage/datasources/launcher.py
View File

@ -16,19 +16,15 @@
import itertools
from oslo_service import service as os_service
from oslo_utils import importutils as utils
from vitrage.common.constants import DatasourceOpts as DSOpts
from vitrage.common.constants import UpdateMethod
from vitrage.datasources.listener_service import ListenerService
from vitrage.datasources.services import ChangesService
from vitrage.datasources.services import SnapshotsService
from vitrage.utils import opt_exists
from vitrage.entity_graph import utils
def create_send_to_queue_callback(queue):
def create_send_to_queue_callback(rabbitq):
def send_to_queue_callback(event):
queue.put(event)
rabbitq.notify_when_applicable(event)
return send_to_queue_callback
@ -37,43 +33,26 @@ class Launcher(object):
def __init__(self, conf, callback):
self.conf = conf
self.callback = callback
self.snapshot_datasources = self._register_snapshot_datasources(conf)
self.drivers = utils.get_drivers(conf)
self.services = self._register_services()
def launch(self):
# launcher = os_service.ServiceLauncher(self.conf) # For Debugging
launcher = os_service.ProcessLauncher(self.conf)
for service in self.services:
launcher.launch_service(service, 1)
@staticmethod
def _register_snapshot_datasources(conf):
return {datasource: utils.import_object(conf[datasource].driver, conf)
for datasource in conf.datasources.types}
def _register_services(self):
pull_datasources = self._get_pull_datasources(self.conf)
pull_datasources = utils.get_pull_datasources(self.conf)
changes_services = \
(ChangesService(self.conf,
[self.snapshot_datasources[datasource]],
[self.drivers[datasource]],
self.conf[datasource].changes_interval,
self.callback)
for datasource in pull_datasources)
snapshot_service = (SnapshotsService(self.conf,
self.snapshot_datasources,
self.drivers,
self.callback),)
listener_service = (ListenerService(self.conf,
self.snapshot_datasources,
self.callback),)
return itertools.chain(changes_services,
snapshot_service,
listener_service)
@staticmethod
def _get_pull_datasources(conf):
return (datasource for datasource in conf.datasources.types
if conf[datasource].update_method.lower() == UpdateMethod.PULL
and opt_exists(conf[datasource], DSOpts.CHANGES_INTERVAL))
snapshot_service)

12
vitrage/datasources/listener_service.py
View File

@ -18,7 +18,7 @@ from oslo_log import log
import oslo_messaging
from oslo_service import service as os_service
from vitrage.common.constants import UpdateMethod
from vitrage.entity_graph import utils
from vitrage import messaging
@ -47,6 +47,9 @@ class ListenerService(os_service.Service):
def stop(self, graceful=False):
LOG.info("Vitrage data source Listener Service - Stopping...")
# Should it be here?
# self.listener.stop()
# self.listener.wait()
super(ListenerService, self).stop(graceful)
LOG.info("Vitrage data source Listener Service - Stopped!")
@ -54,7 +57,7 @@ class ListenerService(os_service.Service):
@classmethod
def _create_callbacks_by_events_dict(cls, drivers, conf):
ret = defaultdict(list)
push_drivers = cls._get_push_drivers(drivers, conf)
push_drivers = utils.get_push_datasources(drivers, conf)
for driver in push_drivers:
for event in driver.get_event_types():
@ -62,11 +65,6 @@ class ListenerService(os_service.Service):
return ret
@staticmethod
def _get_push_drivers(drivers, conf):
return (driver_cls for datasource, driver_cls in drivers.items()
if conf[datasource].update_method.lower() == UpdateMethod.PUSH)
def _get_topic_listener(self, conf, topic, callback):
# Create a listener for each topic
transport = messaging.get_transport(conf)

6
vitrage/datasources/nova/host/driver.py
View File

@ -32,4 +32,8 @@ class HostDriver(NovaDriverBase):
self.filter_none_compute_hosts(self.client.hosts.list()),
NOVA_HOST_DATASOURCE,
datasource_action,
'manager')
*self.properties_to_filter_out())
@staticmethod
def properties_to_filter_out():
return ['manager']

8
vitrage/datasources/nova/instance/driver.py
View File

@ -30,9 +30,7 @@ class InstanceDriver(NovaDriverBase):
search_opts={'all_tenants': 1})),
NOVA_INSTANCE_DATASOURCE,
datasource_action,
'manager',
'OS-EXT-SRV-ATTR:user_data',
'_info')
*self.properties_to_filter_out())
def enrich_event(self, event, event_type):
event[DSProps.EVENT_TYPE] = event_type
@ -41,6 +39,10 @@ class InstanceDriver(NovaDriverBase):
NOVA_INSTANCE_DATASOURCE,
DatasourceAction.UPDATE)[0]
@staticmethod
def properties_to_filter_out():
return ['manager', 'OS-EXT-SRV-ATTR:user_data', '_info']
@staticmethod
def get_event_types():
# Add event_types to receive notifications about

7
vitrage/datasources/nova/zone/driver.py
View File

@ -32,5 +32,8 @@ class ZoneDriver(NovaDriverBase):
self.client.availability_zones.list()),
NOVA_ZONE_DATASOURCE,
datasource_action,
'manager',
'_info')
*self.properties_to_filter_out())
@staticmethod
def properties_to_filter_out():
return ['manager', '_info']

33
vitrage/entity_graph/service.py
View File

@ -15,9 +15,11 @@
import datetime
from oslo_log import log
import oslo_messaging
from oslo_service import service as os_service
from vitrage.entity_graph.processor import processor as proc
from vitrage import messaging
LOG = log.getLogger(__name__)
@ -26,31 +28,33 @@ class VitrageGraphService(os_service.Service):
def __init__(self,
conf,
event_queue,
evaluator_queue,
evaluator,
entity_graph,
initialization_status):
super(VitrageGraphService, self).__init__()
self.queue = event_queue
self.conf = conf
self.evaluator = evaluator
self.processor = proc.Processor(self.conf,
initialization_status,
e_graph=entity_graph)
self.evaluator_queue = evaluator_queue
self.listener = self._create_datasources_event_listener(conf)
def start(self):
LOG.info("Vitrage Graph Service - Starting...")
super(VitrageGraphService, self).start()
self.tg.add_timer(0.1, self._process_event_non_blocking)
self.listener.start()
LOG.info("Vitrage Graph Service - Started!")
def stop(self, graceful=False):
LOG.info("Vitrage Graph Service - Stopping...")
self.listener.stop()
self.listener.wait()
super(VitrageGraphService, self).stop(graceful)
LOG.info("Vitrage Graph Service - Stopped!")
@ -68,14 +72,12 @@ class VitrageGraphService(os_service.Service):
the queue they are done when timer returns.
"""
start_time = datetime.datetime.now()
while not self.evaluator_queue.empty() or not self.queue.empty():
while not self.evaluator_queue.empty():
time_delta = datetime.datetime.now() - start_time
if time_delta.total_seconds() >= 2:
break
if not self.evaluator_queue.empty():
self.do_process(self.evaluator_queue)
elif not self.queue.empty():
self.do_process(self.queue)
def do_process(self, queue):
try:
@ -83,3 +85,24 @@ class VitrageGraphService(os_service.Service):
self.processor.process_event(event)
except Exception as e:
LOG.exception("Exception: %s", e)
def _create_datasources_event_listener(self, conf):
topic = conf.datasources.notification_topic_collector
transport = messaging.get_transport(conf)
targets = [oslo_messaging.Target(topic=topic)]
return messaging.get_notification_listener(
transport, targets,
[PushNotificationsEndpoint(self.processor.process_event)],
allow_requeue=True)
class PushNotificationsEndpoint(object):
def __init__(self, process_event_callback):
self.process_event_callback = process_event_callback
def info(self, ctxt, publisher_id, event_type, payload, metadata):
try:
self.process_event_callback(payload)
except Exception as e:
LOG.exception(e)

35
vitrage/entity_graph/utils.py Normal file
View File

@ -0,0 +1,35 @@
# Copyright 2017 - 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_utils import importutils as utils
from vitrage.common.constants import DatasourceOpts as DSOpts
from vitrage.common.constants import UpdateMethod
from vitrage.utils import opt_exists
def get_drivers(conf):
return {datasource: utils.import_object(conf[datasource].driver, conf)
for datasource in conf.datasources.types}
def get_pull_datasources(conf):
return (datasource for datasource in conf.datasources.types
if conf[datasource].update_method.lower() == UpdateMethod.PULL
and opt_exists(conf[datasource], DSOpts.CHANGES_INTERVAL))
def get_push_datasources(drivers, conf):
return (driver_cls for datasource, driver_cls in drivers.items()
if conf[datasource].update_method.lower() == UpdateMethod.PUSH)

11
vitrage/tests/unit/datasources/test_datasource_update_method.py
View File

@ -17,12 +17,11 @@ from oslo_utils import importutils as utils
from vitrage.common.constants import DatasourceOpts as DSOpts
from vitrage.common.constants import UpdateMethod
from vitrage.datasources.launcher import Launcher
from vitrage.datasources.listener_service import ListenerService
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.zabbix import ZABBIX_DATASOURCE
from vitrage.entity_graph import utils as graph_utils
from vitrage.tests import base
@ -174,20 +173,20 @@ class DatasourceUpdateMethod(base.BaseTest):
def test_datasource_update_method_push(self):
drivers = {driver: utils.import_class(self.conf[driver].driver)
for driver in self.conf.datasources.types}
push_drivers = ListenerService._get_push_drivers(
drivers=drivers, conf=self.conf)
push_drivers = graph_utils.get_push_datasources(drivers=drivers,
conf=self.conf)
self.assertSequenceEqual(set(push_drivers), {utils.import_class(
self.conf[NOVA_INSTANCE_DATASOURCE].driver), utils.import_class(
self.conf[ZABBIX_DATASOURCE_PUSH].driver)})
def test_datasource_update_method_pull(self):
pull_drivers = tuple(Launcher._get_pull_datasources(self.conf))
pull_drivers = tuple(graph_utils.get_pull_datasources(self.conf))
self.assertSequenceEqual(pull_drivers,
(NAGIOS_DATASOURCE,
ZABBIX_DATASOURCE_PULL))
def test_datasource_update_method_pull_with_no_changes_interval(self):
pull_drivers = tuple(Launcher._get_pull_datasources(self.conf))
pull_drivers = tuple(graph_utils.get_pull_datasources(self.conf))
self.assertNotIn(ZABBIX_DATASOURCE_PULL_NO_INTERVAL, pull_drivers)
def test_datasources_notification_topic(self):

4
vitrage_tempest_tests/tests/api/alarms/test_alarms.py
View File

@ -13,7 +13,6 @@
# under the License.
import json
import traceback
from oslo_log import log as logging
@ -49,8 +48,7 @@ class TestAlarms(BaseAlarmsTest):
api_alarms, cli_alarms, AODH_DATASOURCE,
utils.uni2str(instances[0].id))
except Exception as e:
LOG.exception(e)
traceback.print_exc()
self._handle_exception(e)
raise
finally:
self._delete_ceilometer_alarms()

11
vitrage_tempest_tests/tests/api/base.py
View File

@ -13,6 +13,7 @@
# under the License.
import time
import traceback
from oslo_log import log as logging
from oslotest import base
@ -379,3 +380,13 @@ class BaseApiTest(base.BaseTestCase):
if not public_nets:
return None
return public_nets[0]
def _print_entity_graph(self):
api_graph = self.vitrage_client.topology.get(all_tenants=True)
graph = self._create_graph_from_graph_dictionary(api_graph)
LOG.info('Entity Graph: \n%s', graph.json_output_graph())
def _handle_exception(self, exception):
traceback.print_exc()
LOG.exception(exception)
self._print_entity_graph()

8
vitrage_tempest_tests/tests/api/datasources/test_aodh.py
View File

@ -12,8 +12,6 @@
# License for the specific language governing permissions and limitations
# under the License.
import traceback
from oslo_log import log as logging
from vitrage_tempest_tests.tests import utils
@ -59,8 +57,7 @@ class TestAodhAlarm(BaseAlarmsTest):
num_edges,
entities)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._delete_ceilometer_alarms()
@ -90,8 +87,7 @@ class TestAodhAlarm(BaseAlarmsTest):
num_edges,
entities)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._delete_ceilometer_alarms()

5
vitrage_tempest_tests/tests/api/datasources/test_cinder_volume.py
View File

@ -12,8 +12,6 @@
# License for the specific language governing permissions and limitations
# under the License.
import traceback
from oslo_log import log as logging
from vitrage_tempest_tests.tests.api.topology.base import BaseTopologyTest
from vitrage_tempest_tests.tests import utils
@ -58,8 +56,7 @@ class TestCinderVolume(BaseTopologyTest):
num_edges,
entities)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._rollback_to_default()

4
vitrage_tempest_tests/tests/api/datasources/test_heat_stack.py
View File

@ -13,7 +13,6 @@
# under the License.
import time
import traceback
from oslo_log import log as logging
from vitrage_tempest_tests.tests import utils
@ -66,8 +65,7 @@ class TestHeatStack(BaseTopologyTest):
num_edges,
entities)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._delete_stacks()

5
vitrage_tempest_tests/tests/api/datasources/test_neutron.py
View File

@ -12,8 +12,6 @@
# License for the specific language governing permissions and limitations
# under the License.
import traceback
from oslo_log import log as logging
from vitrage.common.constants import VertexProperties as VProps
@ -66,8 +64,7 @@ class TestNeutron(BaseTopologyTest):
num_edges,
entities)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._delete_instances()

5
vitrage_tempest_tests/tests/api/datasources/test_nova.py
View File

@ -12,8 +12,6 @@
# License for the specific language governing permissions and limitations
# under the License.
import traceback
from oslo_log import log as logging
from vitrage_tempest_tests.tests.api.topology.base import BaseTopologyTest
from vitrage_tempest_tests.tests import utils
@ -54,8 +52,7 @@ class TestNova(BaseTopologyTest):
num_edges,
entities)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._rollback_to_default()

4
vitrage_tempest_tests/tests/api/datasources/test_static_physical.py
View File

@ -15,7 +15,6 @@
import os
import socket
import time
import traceback
from oslo_log import log as logging
from vitrage_tempest_tests.tests.api.base import BaseApiTest
@ -57,8 +56,7 @@ class TestStaticPhysical(BaseApiTest):
num_edges,
entities)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._delete_switches()

17
vitrage_tempest_tests/tests/api/rca/test_rca.py
View File

@ -12,8 +12,6 @@
# License for the specific language governing permissions and limitations
# under the License.
import traceback
from oslo_log import log as logging
from vitrage.common.constants import VertexProperties as VProps
@ -54,8 +52,7 @@ class TestRca(BaseRcaTest):
self._compare_rca(api_rca, cli_rca)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._clean_all()
@ -84,8 +81,7 @@ class TestRca(BaseRcaTest):
self._validate_relationship(links=api_rca['links'],
alarms=api_rca['nodes'])
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._clean_all()
@ -108,8 +104,7 @@ class TestRca(BaseRcaTest):
self._validate_deduce_alarms(alarms=api_alarms,
instances=instances)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._clean_all()
@ -133,8 +128,7 @@ class TestRca(BaseRcaTest):
self._validate_set_state(topology=topology['nodes'],
instances=instances)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._clean_all()
@ -159,8 +153,7 @@ class TestRca(BaseRcaTest):
self._validate_notifier(alarms=ceilometer_alarms,
vitrage_alarms=vitrage_alarms)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._clean_all()

19
vitrage_tempest_tests/tests/api/resources/test_resources.py
View File

@ -13,7 +13,6 @@
# under the License.
import json
import traceback
from oslo_log import log as logging
@ -53,8 +52,7 @@ class TestResource(BaseApiTest):
self._compare_resources(api_resources, cli_resources)
except Exception as e:
LOG.exception(e)
traceback.print_exc()
self._handle_exception(e)
raise
finally:
self._delete_instances()
@ -72,8 +70,7 @@ class TestResource(BaseApiTest):
resources = self.vitrage_client.resource.list()
self.assertEqual(4, len(resources))
except Exception as e:
LOG.exception(e)
traceback.print_exc()
self._handle_exception(e)
raise
finally:
self._delete_instances()
@ -92,8 +89,7 @@ class TestResource(BaseApiTest):
resources = self.vitrage_client.resource.list(all_tenants=True)
self.assertEqual(4, len(resources))
except Exception as e:
LOG.exception(e)
traceback.print_exc()
self._handle_exception(e)
raise
finally:
self._delete_instances()
@ -113,8 +109,7 @@ class TestResource(BaseApiTest):
all_tenants=False)
self.assertEqual(1, len(resources))
except Exception as e:
LOG.exception(e)
traceback.print_exc()
self._handle_exception(e)
raise
finally:
self._delete_instances()
@ -131,8 +126,7 @@ class TestResource(BaseApiTest):
all_tenants=False)
self.assertEqual(0, len(resources))
except Exception as e:
LOG.exception(e)
traceback.print_exc()
self._handle_exception(e)
raise
finally:
self._delete_instances()
@ -158,8 +152,7 @@ class TestResource(BaseApiTest):
self.vitrage_client.resource.show('test_for_no_existing')
self.assertIsNone(resource)
except Exception as e:
LOG.exception(e)
traceback.print_exc()
self._handle_exception(e)
raise
finally:
self._delete_instances()

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

@ -12,8 +12,6 @@
# License for the specific language governing permissions and limitations
# under the License.
import traceback
from oslo_log import log as logging
from vitrage_tempest_tests.tests.api.topology.base import BaseTopologyTest
@ -90,8 +88,7 @@ class TestTopology(BaseTopologyTest):
num_edges,
entities)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._rollback_to_default()
@ -127,8 +124,7 @@ class TestTopology(BaseTopologyTest):
num_edges,
entities)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._rollback_to_default()
@ -162,8 +158,7 @@ class TestTopology(BaseTopologyTest):
num_edges,
entities)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._rollback_to_default()
@ -192,8 +187,7 @@ class TestTopology(BaseTopologyTest):
self.num_default_edges,
entities)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._rollback_to_default()
@ -222,8 +216,7 @@ class TestTopology(BaseTopologyTest):
self.num_default_edges,
entities)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._rollback_to_default()
@ -257,8 +250,7 @@ class TestTopology(BaseTopologyTest):
num_edges,
entities)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._rollback_to_default()
@ -290,8 +282,7 @@ class TestTopology(BaseTopologyTest):
self.num_default_edges,
entities)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._rollback_to_default()
@ -328,8 +319,7 @@ class TestTopology(BaseTopologyTest):
num_edges,
entities)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._rollback_to_default()
@ -383,8 +373,7 @@ class TestTopology(BaseTopologyTest):
0,
len(api_graph['links']), 'num of edges')
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._rollback_to_default()
@ -409,8 +398,7 @@ class TestTopology(BaseTopologyTest):
# Test Assertions
self.assertEqual({}, api_graph)
except Exception as e:
traceback.print_exc()
LOG.exception(e)
self._handle_exception(e)
raise
finally:
self._rollback_to_default()