173 lines
6.8 KiB
Python
173 lines
6.8 KiB
Python
# 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.
|
|
|
|
import json
|
|
|
|
from oslo_log import log as logging
|
|
from testtools import matchers
|
|
|
|
from vitrage_tempest_plugin.tests.base import BaseVitrageTempest
|
|
from vitrage_tempest_plugin.tests.base import IsNotEmpty
|
|
from vitrage_tempest_plugin.tests.common import aodh_utils
|
|
from vitrage_tempest_plugin.tests.common.constants import AODH_DATASOURCE
|
|
from vitrage_tempest_plugin.tests.common.constants import NOVA_HOST_DATASOURCE
|
|
from vitrage_tempest_plugin.tests.common.constants import \
|
|
NOVA_INSTANCE_DATASOURCE
|
|
from vitrage_tempest_plugin.tests.common.constants \
|
|
import OperationalAlarmSeverity
|
|
from vitrage_tempest_plugin.tests.common.constants \
|
|
import OperationalResourceState
|
|
from vitrage_tempest_plugin.tests.common.constants import VertexProperties \
|
|
as VProps
|
|
from vitrage_tempest_plugin.tests.common.constants import VITRAGE_DATASOURCE
|
|
from vitrage_tempest_plugin.tests.common import general_utils as g_utils
|
|
from vitrage_tempest_plugin.tests.common import nova_utils
|
|
from vitrage_tempest_plugin.tests.common import vitrage_utils
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
RCA_ALARM_NAME = 'rca_test_host_alarm'
|
|
VITRAGE_ALARM_NAME = 'instance_deduce'
|
|
|
|
|
|
class BaseRcaTest(BaseVitrageTempest):
|
|
|
|
@staticmethod
|
|
def _clean_all():
|
|
nova_utils.delete_all_instances()
|
|
aodh_utils.delete_all_aodh_alarms()
|
|
|
|
def _create_alarm(self, resource_id, alarm_name, unic=False):
|
|
aodh_utils.create_aodh_alarm(resource_id=resource_id,
|
|
name=alarm_name,
|
|
unic=unic)
|
|
|
|
list_alarms = self.vitrage_client.alarm.list(vitrage_id='all',
|
|
all_tenants=True)
|
|
expected_alarm = g_utils.all_matches(
|
|
list_alarms,
|
|
resource_id=resource_id,
|
|
vitrage_type=AODH_DATASOURCE)
|
|
if not expected_alarm:
|
|
return None
|
|
return expected_alarm[0]
|
|
|
|
def _compare_rca(self, api_rca, cli_rca):
|
|
self.assertThat(api_rca, IsNotEmpty(),
|
|
'The rca taken from api is empty')
|
|
self.assertIsNotNone(cli_rca, 'The rca taken from cli is empty')
|
|
|
|
LOG.debug("The rca taken from cli is : %s", cli_rca)
|
|
LOG.debug("The rca taken by api is : %s", api_rca)
|
|
|
|
parsed_rca = json.loads(cli_rca)
|
|
sorted_cli_graph = self._clean_timestamps(sorted(parsed_rca.items()))
|
|
sorted_api_graph = self._clean_timestamps(sorted(api_rca.items()))
|
|
self.assert_list_equal(sorted_cli_graph, sorted_api_graph)
|
|
|
|
def _validate_rca(self, rca):
|
|
self.assertThat(rca, IsNotEmpty, 'The rca is empty')
|
|
LOG.debug("The rca alarms list is : %s", rca)
|
|
|
|
resource_alarm = g_utils.all_matches(
|
|
rca,
|
|
vitrage_type=AODH_DATASOURCE,
|
|
name=RCA_ALARM_NAME)
|
|
|
|
deduce_alarms = g_utils.all_matches(
|
|
rca,
|
|
vitrage_type=VITRAGE_DATASOURCE,
|
|
name=VITRAGE_ALARM_NAME,
|
|
severity=OperationalAlarmSeverity.WARNING)
|
|
|
|
self.assertThat(rca, matchers.HasLength(3))
|
|
self.assertThat(resource_alarm, matchers.HasLength(1))
|
|
self.assertThat(deduce_alarms, matchers.HasLength(2))
|
|
|
|
def _validate_deduce_alarms(self, alarms, instances):
|
|
"""Validate alarm existence """
|
|
self.assertThat(alarms, IsNotEmpty(), 'The alarms list is empty')
|
|
LOG.debug("The alarms list is : %s", alarms)
|
|
|
|
# Find the vitrage_id of the deduced alarms using their original id.
|
|
vitrage_resources = self.vitrage_client.resource.list(
|
|
all_tenants=False)
|
|
vitrage_instance_0_id = g_utils.first_match(vitrage_resources,
|
|
id=instances[0].id)
|
|
|
|
vitrage_instance_1_id = g_utils.first_match(vitrage_resources,
|
|
id=instances[1].id)
|
|
|
|
# Find the deduced alarms based on their properties
|
|
deduce_alarms_1 = g_utils.all_matches(
|
|
alarms,
|
|
vitrage_type=VITRAGE_DATASOURCE,
|
|
name=VITRAGE_ALARM_NAME,
|
|
vitrage_resource_type=NOVA_INSTANCE_DATASOURCE,
|
|
vitrage_resource_id=vitrage_instance_0_id[VProps.VITRAGE_ID])
|
|
|
|
deduce_alarms_2 = g_utils.all_matches(
|
|
alarms,
|
|
vitrage_type=VITRAGE_DATASOURCE,
|
|
name=VITRAGE_ALARM_NAME,
|
|
vitrage_resource_type=NOVA_INSTANCE_DATASOURCE,
|
|
vitrage_resource_id=vitrage_instance_1_id[VProps.VITRAGE_ID])
|
|
|
|
self.assertThat(alarms, matchers.HasLength(3),
|
|
"Expected 3 alarms - 1 on host and 2 deduced")
|
|
self.assertThat(deduce_alarms_1, matchers.HasLength(1),
|
|
"Deduced alarm not found")
|
|
self.assertThat(deduce_alarms_2, matchers.HasLength(1),
|
|
"Deduced alarm not found")
|
|
|
|
def _validate_set_state(self, topology, instances):
|
|
self.assertThat(topology, IsNotEmpty(), 'The topology graph is empty')
|
|
host = g_utils.all_matches(
|
|
topology,
|
|
vitrage_type=NOVA_HOST_DATASOURCE,
|
|
id=self._get_hostname(),
|
|
vitrage_state=OperationalResourceState.ERROR,
|
|
vitrage_aggregated_state=OperationalResourceState.ERROR)
|
|
|
|
vm1 = g_utils.all_matches(
|
|
topology,
|
|
vitrage_type=NOVA_INSTANCE_DATASOURCE,
|
|
id=instances[0].id,
|
|
vitrage_state=OperationalResourceState.SUBOPTIMAL,
|
|
vitrage_aggregated_state=OperationalResourceState.SUBOPTIMAL)
|
|
|
|
vm2 = g_utils.all_matches(
|
|
topology,
|
|
vitrage_type=NOVA_INSTANCE_DATASOURCE,
|
|
id=instances[1].id,
|
|
vitrage_state=OperationalResourceState.SUBOPTIMAL,
|
|
vitrage_aggregated_state=OperationalResourceState.SUBOPTIMAL)
|
|
|
|
self.assertThat(host, matchers.HasLength(1))
|
|
self.assertThat(vm1, matchers.HasLength(1))
|
|
self.assertThat(vm2, matchers.HasLength(1))
|
|
|
|
@staticmethod
|
|
def _get_hostname():
|
|
host = vitrage_utils.get_first_host()
|
|
return host.get(VProps.ID)
|
|
|
|
@staticmethod
|
|
def _clean_timestamps(alist):
|
|
try:
|
|
del alist[5][1][0][VProps.VITRAGE_SAMPLE_TIMESTAMP]
|
|
del alist[5][1][0][VProps.UPDATE_TIMESTAMP]
|
|
except Exception:
|
|
pass
|
|
return alist
|