openstack
/
vitrage
Code Issues Proposed changes

new e2e tempest to check actions 

Change-Id: I744418aa0407dd4bf34335d37527b32b98785c83
This commit is contained in:
Idan Hefetz 2017-11-21 13:54:42 +00:00
parent d62796bea4
commit 885857cea7
9 changed files with 363 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
devstack/gate_hook.sh
View File

@ -66,7 +66,7 @@ topics = notifications, vitrage_notifications
[[post-config|\$VITRAGE_CONF]]
[DEFAULT]
notifiers = mistral
notifiers = mistral,nova
[static_physical]
changes_interval = 5

2
devstack/post_test_hook.sh
View File

@ -18,7 +18,7 @@ DEVSTACK_PATH="$BASE/new"
if [ "$1" = "api" ]; then
TESTS="topology"
elif [ "$1" = "datasources" ]; then
TESTS="datasources|test_events|notifiers"
TESTS="datasources|test_events|notifiers|e2e"
else
TESTS="topology"
fi

30
vitrage_tempest_tests/tests/common/general_utils.py Normal file
View File

@ -0,0 +1,30 @@
# 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 six
def get_first_match(list_of_dicts, subset_dict):
for d in list_of_dicts:
if is_subset(subset_dict, d):
return d
def get_all_matchs(list_of_dicts, subset_dict):
# TODO(idan_hefetz) this method can replace the notorious
# TODO(idan_hefetz) '_filter_list_by_pairs_parameters'
return [d for d in list_of_dicts if is_subset(subset_dict, d)]
def is_subset(subset, full):
return six.viewitems(subset) <= six.viewitems(full)

36
vitrage_tempest_tests/tests/common/tempest_clients.py
View File

@ -33,6 +33,10 @@ class TempestClients(object):
@classmethod
def vitrage(cls):
"""vitrage client
:rtype: vitrageclient.v1.client.Client
"""
if not cls._vitrage:
cls._vitrage = vc.Client(
'1', session=keystone_client.get_session(cls._conf))
@ -40,48 +44,80 @@ class TempestClients(object):
@classmethod
def ceilometer(cls):
"""ceilometer client
:rtype: ceilometerclient.v2.client.Client
"""
if not cls._ceilometer:
cls._ceilometer = os_clients.ceilometer_client(cls._conf)
return cls._ceilometer
@classmethod
def nova(cls):
"""nova client
:rtype: novaclient.v2.client.Client
"""
if not cls._nova:
cls._nova = os_clients.nova_client(cls._conf)
return cls._nova
@classmethod
def cinder(cls):
"""cinder client
:rtype: cinderclient.v2.client.Client
"""
if not cls._cinder:
cls._cinder = os_clients.cinder_client(cls._conf)
return cls._cinder
@classmethod
def glance(cls):
"""glance client
:rtype: glanceclient.v2.client.Client
"""
if not cls._glance:
cls._glance = os_clients.glance_client(cls._conf)
return cls._glance
@classmethod
def neutron(cls):
"""neutron client
:rtype: neutronclient.v2_0.client.Client
"""
if not cls._neutron:
cls._neutron = os_clients.neutron_client(cls._conf)
return cls._neutron
@classmethod
def heat(cls):
"""heat client
:rtype: heatclient.v1.client.Client
"""
if not cls._heat:
cls._heat = os_clients.heat_client(cls._conf)
return cls._heat
@classmethod
def mistral(cls):
"""mistral client
:rtype: mistralclient.v2.client.Client
"""
if not cls._mistral:
cls._mistral = os_clients.mistral_client(cls._conf)
return cls._mistral
@classmethod
def aodh(cls):
"""aodh client
:rtype: aodhclient.v2.client.Client
"""
if not cls._aodh:
cls._aodh = os_clients.aodh_client(cls._conf)
return cls._aodh

24
vitrage_tempest_tests/tests/common/vitrage_utils.py
View File

@ -11,13 +11,31 @@
# 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 datetime import datetime
from vitrage.common.constants import VertexProperties as VProps
from vitrage.datasources import NOVA_HOST_DATASOURCE
from vitrage_tempest_tests.tests.api.event.base import DOWN
from vitrage_tempest_tests.tests.api.event.base import UP
from vitrage_tempest_tests.tests.common.general_utils import get_first_match
from vitrage_tempest_tests.tests.common.tempest_clients import TempestClients
def generate_fake_host_alarm(hostname, event_type, enabled=True):
details = {
'hostname': hostname,
'source': 'fake_tempest_monitor',
'cause': 'another alarm',
'severity': 'critical',
'status': DOWN if enabled else UP,
'monitor_id': 'fake tempest monitor id',
'monitor_event_id': '111',
}
event_time = datetime.now()
event_time_iso = event_time.isoformat()
TempestClients.vitrage().event.post(event_time_iso, event_type, details)
def get_first_host():
nodes = TempestClients.vitrage().topology.get(all_tenants=True)['nodes']
return next(
(n for n in nodes if n[VProps.VITRAGE_TYPE] == NOVA_HOST_DATASOURCE),
None)
return get_first_match(nodes, {VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE})

15
vitrage_tempest_tests/tests/e2e/__init__.py Normal file
View File

@ -0,0 +1,15 @@
# 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.
__author__ = 'stack'

189
vitrage_tempest_tests/tests/e2e/test_basic_actions.py Normal file
View File

@ -0,0 +1,189 @@
# 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 time
from oslo_log import log as logging
from vitrage.common.constants import EntityCategory
from vitrage.common.constants import VertexProperties as VProps
from vitrage.datasources.doctor import DOCTOR_DATASOURCE
from vitrage.evaluator.actions.evaluator_event_transformer import \
VITRAGE_DATASOURCE
from vitrage_tempest_tests.tests.base import BaseVitrageTempest
from vitrage_tempest_tests.tests.common import general_utils as g_utils
from vitrage_tempest_tests.tests.common.tempest_clients import TempestClients
from vitrage_tempest_tests.tests.common import vitrage_utils
from vitrage_tempest_tests.tests import utils
LOG = logging.getLogger(__name__)
TRIGGER_ALARM_1 = 'e2e.test_basic_actions.trigger.alarm1'
TRIGGER_ALARM_2 = 'e2e.test_basic_actions.trigger.alarm2'
DEDUCED = 'e2e.test_basic_actions.deduced.alarm'
TRIGGER_ALARM_2_PROPS = {
VProps.NAME: TRIGGER_ALARM_2,
VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
VProps.VITRAGE_TYPE: DOCTOR_DATASOURCE,
}
DEDUCED_PROPS = {
VProps.NAME: DEDUCED,
VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
VProps.VITRAGE_TYPE: VITRAGE_DATASOURCE,
}
class TestBasicActions(BaseVitrageTempest):
@classmethod
def setUpClass(cls):
super(TestBasicActions, cls).setUpClass()
host = vitrage_utils.get_first_host()
if not host:
raise Exception("No host found")
if not host.get(VProps.VITRAGE_AGGREGATED_STATE) == 'AVAILABLE':
raise Exception("Host is not running %s", str(host))
cls.orig_host = host
def _trigger_do_action(self, trigger_name):
vitrage_utils.generate_fake_host_alarm(
self.orig_host.get('name'),
enabled=True,
event_type=trigger_name
)
time.sleep(2)
def _trigger_undo_action(self, trigger_name):
vitrage_utils.generate_fake_host_alarm(
self.orig_host.get('name'),
enabled=False,
event_type=trigger_name
)
time.sleep(2)
@utils.tempest_logger
def test_action_set_state(self):
try:
# Do
self._trigger_do_action(TRIGGER_ALARM_1)
curr_host = vitrage_utils.get_first_host()
self.assertEqual(
'ERROR',
curr_host.get(VProps.VITRAGE_AGGREGATED_STATE),
'state should change after set_state action')
# Undo
self._trigger_undo_action(TRIGGER_ALARM_1)
curr_host = vitrage_utils.get_first_host()
self.assertEqual(
self.orig_host.get(VProps.VITRAGE_AGGREGATED_STATE),
curr_host.get(VProps.VITRAGE_AGGREGATED_STATE),
'state should change after set_state action')
except Exception as e:
self._handle_exception(e)
raise
finally:
self._trigger_undo_action(TRIGGER_ALARM_1)
@utils.tempest_logger
def test_action_mark_down_host(self):
try:
host_name = self.orig_host.get(VProps.NAME)
# Do
self._trigger_do_action(TRIGGER_ALARM_1)
nova_service = TempestClients.nova().services.list(
host=host_name, binary='nova-compute')[0]
self.assertEqual("down", str(nova_service.state))
# Undo
self._trigger_undo_action(TRIGGER_ALARM_1)
nova_service = TempestClients.nova().services.list(
host=host_name, binary='nova-compute')[0]
self.assertEqual("up", str(nova_service.state))
except Exception as e:
self._handle_exception(e)
raise
finally:
self._trigger_undo_action(TRIGGER_ALARM_1)
@utils.tempest_logger
def test_action_deduce_alarm(self):
try:
host_id = self.orig_host.get(VProps.VITRAGE_ID)
# Do
self._trigger_do_action(TRIGGER_ALARM_2)
self._check_deduced(1, DEDUCED_PROPS, host_id)
# Undo
self._trigger_undo_action(TRIGGER_ALARM_2)
self._check_deduced(0, DEDUCED_PROPS, host_id)
except Exception as e:
self._handle_exception(e)
raise
finally:
self._trigger_undo_action(TRIGGER_ALARM_2)
def _check_deduced(self, deduced_count, deduced_props, resource_id):
alarms = TempestClients.vitrage().alarm.list(
vitrage_id=resource_id,
all_tenants=True)
deduces = g_utils.get_all_matchs(alarms, deduced_props)
self.assertEqual(
deduced_count,
len(deduces),
'Expected %s deduces\n - \n%s\n - \n%s' %
(str(deduced_count), str(alarms), str(deduces)))
@utils.tempest_logger
def test_action_add_causal_relationship(self):
try:
# Do
self._trigger_do_action(TRIGGER_ALARM_2)
alarms = TempestClients.vitrage().alarm.list(
vitrage_id=self.orig_host.get(VProps.VITRAGE_ID),
all_tenants=True)
deduced = g_utils.get_all_matchs(alarms, DEDUCED_PROPS)[0]
trigger = g_utils.get_all_matchs(alarms, TRIGGER_ALARM_2_PROPS)[0]
# Get Rca for the deduced
rca = TempestClients.vitrage().rca.get(
deduced[VProps.VITRAGE_ID], all_tenants=True)
self._check_rca(rca, [deduced, trigger], DEDUCED_PROPS)
# Get Rca for the trigger
rca = TempestClients.vitrage().rca.get(
trigger[VProps.VITRAGE_ID], all_tenants=True)
self._check_rca(rca, [deduced, trigger], TRIGGER_ALARM_2_PROPS)
except Exception as e:
self._handle_exception(e)
raise
finally:
self._trigger_undo_action(TRIGGER_ALARM_2)
def _check_rca(self, rca, expected_alarms, inspected):
self.assertEqual(len(expected_alarms), len(rca['nodes']))
for expected_alarm in expected_alarms:
self.assertIsNotNone(
g_utils.get_first_match(rca['nodes'], expected_alarm),
'expected_alarm is not in the rca %s' % str(expected_alarm))
rca_inspected = rca['nodes'][rca['inspected_index']]
self.assertEqual(
True,
g_utils.is_subset(inspected, rca_inspected),
'Invalid inspected item \n%s\n%s' %
(str(rca_inspected), str(inspected)))

70
vitrage_tempest_tests/tests/resources/templates/api/e2e_test_basic_actions.yaml Normal file
View File

@ -0,0 +1,70 @@
metadata:
name: e2e_test_basic_actions
description: this template includes vitrage basic actions
definitions:
entities:
- entity:
category: ALARM
name: e2e.test_basic_actions.trigger.alarm1
template_id: trigger_alarm_1
- entity:
category: ALARM
name: e2e.test_basic_actions.trigger.alarm2
template_id: trigger_alarm_2
- entity:
category: ALARM
type: vitrage
name: e2e.test_basic_actions.deduced.alarm
template_id: deduced_alarm
- entity:
category: RESOURCE
type: nova.host
template_id: host
relationships:
- relationship:
source: trigger_alarm_1
relationship_type: on
target: host
template_id : trigger_alarm_1_on_host
- relationship:
source: trigger_alarm_2
relationship_type: on
target: host
template_id : trigger_alarm_2_on_host
- relationship:
source: deduced_alarm
relationship_type: on
target: host
template_id : deduced_alarm_on_host
scenarios:
- scenario:
condition: trigger_alarm_1_on_host
actions:
- action:
action_type: set_state
action_target:
target: host
properties:
state: ERROR
- action:
action_type: mark_down
action_target:
target: host
- scenario:
condition: trigger_alarm_2_on_host
actions:
- action:
action_type: raise_alarm
action_target:
target: host
properties:
alarm_name: e2e.test_basic_actions.deduced.alarm
severity: WARNING
- scenario:
condition: trigger_alarm_2_on_host and deduced_alarm_on_host
actions:
- action:
action_type: add_causal_relationship
action_target:
source: trigger_alarm_2
target: deduced_alarm

9
vitrage_tempest_tests/tests/utils.py
View File

@ -17,12 +17,10 @@ from functools import wraps
import socket
import time
from oslo_config import cfg
from oslo_config.cfg import NoSuchOptError
from oslo_log import log as logging
import os
import oslo_messaging
import re
import subprocess
@ -115,13 +113,6 @@ def change_terminal_dir(path):
LOG.debug("The path is : " + path)
def get_client():
transport = oslo_messaging.get_transport(cfg.CONF)
cfg.CONF.set_override('rpc_backend', 'rabbit')
target = oslo_messaging.Target(topic='rpcapiv1')
return oslo_messaging.RPCClient(transport, target)
def get_regex_result(pattern, text):
p = re.compile(pattern)
m = p.search(text)