baro_tests/collectd.py

   1 # -*- coding: utf-8 -*-
   2
   3 # Licensed under the Apache License, Version 2.0 (the "License"); you may
   4 # not use this file except in compliance with the License. You may obtain
   5 # a copy of the License at
   6 #
   7 #      http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  11 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  12 # License for the specific language governing permissions and limitations
  13 # under the License.
  14
  15 """Executing test of plugins"""
  16
  17 import requests
  18 from keystoneclient.v3 import client
  19 import os
  20 import sys
  21 import time
  22 import logging
  23 import config_server
  24 import tests
  25 import subprocess
  26 from opnfv.deployment import factory
  27
  28 AODH_NAME = 'aodh'
  29 GNOCCHI_NAME = 'gnocchi'
  30 ID_RSA_SRC = '/root/.ssh/id_rsa'
  31 ID_RSA_DST_DIR = '/home/opnfv/.ssh'
  32 ID_RSA_DST = ID_RSA_DST_DIR + '/id_rsa'
  33 APEX_IP = subprocess.check_output("echo $INSTALLER_IP", shell=True)
  34 APEX_USER = 'root'
  35 APEX_USER_STACK = 'stack'
  36 APEX_PKEY = '/root/.ssh/id_rsa'
  37
  38
  39 class KeystoneException(Exception):
  40     """Keystone exception class"""
  41     def __init__(self, message, exc=None, response=None):
  42         """
  43         Keyword arguments:
  44         message -- error message
  45         exc -- exception
  46         response -- response
  47         """
  48         if exc:
  49             message += "\nReason: %s" % exc
  50         super(KeystoneException, self).__init__(message)
  51
  52         self.response = response
  53         self.exception = exc
  54
  55
  56 class InvalidResponse(KeystoneException):
  57     """Invalid Keystone exception class"""
  58     def __init__(self, exc, response):
  59         """
  60         Keyword arguments:
  61         exc -- exception
  62         response -- response
  63         """
  64         super(InvalidResponse, self).__init__(
  65             "Invalid response", exc, response)
  66
  67
  68 class GnocchiClient(object):
  69     # Gnocchi Client to authenticate and request meters
  70     def __init__(self):
  71         self._auth_token = None
  72         self._gnocchi_url = None
  73         self._meter_list = None
  74
  75     def auth_token(self):
  76         # Get auth token
  77         self._auth_server()
  78         return self._auth_token
  79
  80     def get_gnocchi_url(self):
  81         # Get Gnocchi  URL
  82         return self._gnocchi_url
  83
  84     def get_gnocchi_metrics(self, criteria=None):
  85         # Subject to change if metric gathering is different for gnocchi
  86         self._request_meters(criteria)
  87         return self._meter_list
  88
  89     def _auth_server(self):
  90         # Request token in authentication server
  91         logger.debug('Connecting to the auth server {}'.format(
  92             os.environ['OS_AUTH_URL']))
  93         keystone = client.Client(username=os.environ['OS_USERNAME'],
  94                                  password=os.environ['OS_PASSWORD'],
  95                                  tenant_name=os.environ['OS_USERNAME'],
  96                                  auth_url=os.environ['OS_AUTH_URL'])
  97         self._auth_token = keystone.auth_token
  98         for service in keystone.service_catalog.get_data():
  99             if service['name'] == GNOCCHI_NAME:
 100                 for service_type in service['endpoints']:
 101                     if service_type['interface'] == 'internal':
 102                         self._gnocchi_url = service_type['url']
 103
 104         if self._gnocchi_url is None:
 105             logger.warning('Gnocchi is not registered in service catalog')
 106
 107     def _request_meters(self, criteria):
 108         """Request meter list values from ceilometer
 109
 110         Keyword arguments:
 111         criteria -- criteria for ceilometer meter list
 112         """
 113         if criteria is None:
 114             url = self._gnocchi_url + ('/v2/metric?limit=400')
 115         else:
 116             url = self._gnocchi_url \
 117                 + ('/v3/metric/%s?q.field=metric&limit=400' % criteria)
 118         headers = {'X-Auth-Token': self._auth_token}
 119         resp = requests.get(url, headers=headers)
 120         try:
 121             resp.raise_for_status()
 122             self._meter_list = resp.json()
 123         except (KeyError, ValueError, requests.exceptions.HTTPError) as err:
 124             raise InvalidResponse(err, resp)
 125
 126
 127 class AodhClient(object):
 128     # Gnocchi Client to authenticate and request meters
 129     def __init__(self):
 130         self._auth_token = None
 131         self._aodh_url = None
 132         self._meter_list = None
 133
 134     def auth_token(self):
 135         # Get auth token
 136         self._auth_server()
 137         return self._auth_token
 138
 139     def get_aodh_url(self):
 140         # Get Gnocchi  URL
 141         return self._gnocchi_url
 142
 143     def get_aodh_metrics(self, criteria=None):
 144         # Subject to change if metric gathering is different for gnocchi
 145         self._request_meters(criteria)
 146         return self._meter_list
 147
 148     def _auth_server(self):
 149         # Request token in authentication server
 150         logger.debug('Connecting to the AODH auth server {}'.format(
 151             os.environ['OS_AUTH_URL']))
 152         keystone = client.Client(username=os.environ['OS_USERNAME'],
 153                                  password=os.environ['OS_PASSWORD'],
 154                                  tenant_name=os.environ['OS_USERNAME'],
 155                                  auth_url=os.environ['OS_AUTH_URL'])
 156         self._auth_token = keystone.auth_token
 157         for service in keystone.service_catalog.get_data():
 158             if service['name'] == AODH_NAME:
 159                 for service_type in service['endpoints']:
 160                     if service_type['interface'] == 'internal':
 161                         self._gnocchi_url = service_type['url']
 162
 163         if self._aodh_url is None:
 164             logger.warning('Aodh is not registered in service catalog')
 165
 166
 167 class SNMPClient(object):
 168     """Client to request SNMP meters"""
 169     def __init__(self, conf, compute_node):
 170         """
 171         Keyword arguments:
 172         conf -- ConfigServer instance
 173         compute_node -- Compute node object
 174         """
 175         self.conf = conf
 176         self.compute_node = compute_node
 177
 178     def get_snmp_metrics(self, compute_node, mib_file, mib_strings):
 179         snmp_output = {}
 180         if mib_file is None:
 181             cmd = "snmpwalk -v 2c -c public localhost IF-MIB::interfaces"
 182             ip = compute_node.get_ip()
 183             snmp_output = self.conf.execute_command(cmd, ip)
 184         else:
 185             for mib_string in mib_strings:
 186                 snmp_output[mib_string] = self.conf.execute_command(
 187                     "snmpwalk -v2c -m {} -c public localhost {}".format(
 188                         mib_file, mib_string), compute_node.get_ip())
 189         return snmp_output
 190
 191
 192 class CSVClient(object):
 193     """Client to request CSV meters"""
 194     def __init__(self, conf):
 195         """
 196         Keyword arguments:
 197         conf -- ConfigServer instance
 198         """
 199         self.conf = conf
 200
 201     def get_csv_metrics(
 202             self, compute_node, plugin_subdirectories, meter_categories):
 203         """Get CSV metrics.
 204
 205         Keyword arguments:
 206         compute_node -- compute node instance
 207         plugin_subdirectories -- list of subdirectories of plug-in
 208         meter_categories -- categories which will be tested
 209
 210         Return list of metrics.
 211         """
 212         stdout = self.conf.execute_command(
 213             "date '+%Y-%m-%d'", compute_node.get_ip())
 214         date = stdout[0].strip()
 215         metrics = []
 216         for plugin_subdir in plugin_subdirectories:
 217             for meter_category in meter_categories:
 218                 stdout = self.conf.execute_command(
 219                     "tail -2 /var/lib/collectd/csv/"
 220                     + "{0}.jf.intel.com/{1}/{2}-{3}".format(
 221                         compute_node.get_name(), plugin_subdir, meter_category,
 222                         date),
 223                     compute_node.get_ip())
 224                 # Storing last two values
 225                 values = stdout
 226                 if len(values) < 2:
 227                     logger.error(
 228                         'Getting last two CSV entries of meter category '
 229                         + '{0} in {1} subdir failed'.format(
 230                             meter_category, plugin_subdir))
 231                 else:
 232                     old_value = int(values[0][0:values[0].index('.')])
 233                     new_value = int(values[1][0:values[1].index('.')])
 234                     metrics.append((
 235                         plugin_subdir, meter_category, old_value, new_value))
 236         return metrics
 237
 238
 239 def get_csv_categories_for_ipmi(conf, compute_node):
 240     """Get CSV metrics.
 241
 242     Keyword arguments:
 243     compute_node -- compute node instance
 244
 245     Return list of categories.
 246     """
 247     stdout = conf.execute_command(
 248         "date '+%Y-%m-%d'", compute_node.get_ip())
 249     date = stdout[0].strip()
 250     categories = conf.execute_command(
 251         "ls /var/lib/collectd/csv/{0}.jf.intel.com/ipmi | grep {1}".format(
 252             compute_node.get_name(), date), compute_node.get_ip())
 253     return [category.strip()[:-11] for category in categories]
 254
 255
 256 def _process_result(compute_node, test, result, results_list):
 257     """Print test result and append it to results list.
 258
 259     Keyword arguments:
 260     test -- testcase name
 261     result -- boolean test result
 262     results_list -- results list
 263     """
 264     if result:
 265         logger.info(
 266             'Compute node {0} test case {1} PASSED.'.format(
 267                 compute_node, test))
 268     else:
 269         logger.error(
 270             'Compute node {0} test case {1} FAILED.'.format(
 271                 compute_node, test))
 272     results_list.append((compute_node, test, result))
 273
 274
 275 def _print_label(label):
 276     """Print label on the screen
 277
 278     Keyword arguments:
 279     label -- label string
 280     """
 281     label = label.strip()
 282     length = 70
 283     if label != '':
 284         label = ' ' + label + ' '
 285     length_label = len(label)
 286     length1 = (length - length_label) / 2
 287     length2 = length - length_label - length1
 288     length1 = max(3, length1)
 289     length2 = max(3, length2)
 290     logger.info(('=' * length1) + label + ('=' * length2))
 291
 292
 293 def _print_plugin_label(plugin, node_name):
 294     """Print plug-in label.
 295
 296     Keyword arguments:
 297     plugin -- plug-in name
 298     node_id -- node ID
 299     """
 300     _print_label(
 301         'Node {0}: Plug-in {1} Test case execution'.format(node_name, plugin))
 302
 303
 304 def _print_final_result_of_plugin(
 305         plugin, compute_ids, results, out_plugins, out_plugin):
 306     """Print final results of plug-in.
 307
 308     Keyword arguments:
 309     plugin -- plug-in name
 310     compute_ids -- list of compute node IDs
 311     results -- results list
 312     out_plugins -- list of out plug-ins
 313     out_plugin -- used out plug-in
 314     """
 315     print_line = ''
 316     for id in compute_ids:
 317         if out_plugins[id] == out_plugin:
 318             if (id, plugin, True) in results:
 319                 print_line += ' PASS   |'
 320             elif (id, plugin, False) in results \
 321                     and out_plugins[id] == out_plugin:
 322                 print_line += ' FAIL   |'
 323             else:
 324                 print_line += ' NOT EX |'
 325         elif out_plugin == 'Gnocchi':
 326             print_line += ' NOT EX |'
 327         else:
 328             print_line += ' NOT EX |'
 329     return print_line
 330
 331
 332 def print_overall_summary(compute_ids, tested_plugins, results, out_plugins):
 333     """Print overall summary table.
 334
 335     Keyword arguments:
 336     compute_ids -- list of compute IDs
 337     tested_plugins -- list of plug-ins
 338     results -- results list
 339     out_plugins --  list of used out plug-ins
 340     """
 341     compute_node_names = ['Node-{}'.format(i) for i in range(
 342         len((compute_ids)))]
 343     # compute_node_names = ['Node-{}'.format(id) for id in compute_ids]
 344     all_computes_in_line = ''
 345     for compute in compute_node_names:
 346         all_computes_in_line += '| ' + compute + (' ' * (7 - len(compute)))
 347     line_of_nodes = '| Test           ' + all_computes_in_line + '|'
 348     logger.info('=' * 70)
 349     logger.info('+' + ('-' * ((9 * len(compute_node_names))+16)) + '+')
 350     logger.info(
 351         '|' + ' ' * ((9*len(compute_node_names))/2)
 352         + ' OVERALL SUMMARY'
 353         + ' ' * (
 354             9*len(compute_node_names) - (9*len(compute_node_names))/2)
 355         + '|')
 356     logger.info(
 357         '+' + ('-' * 16) + '+' + (('-' * 8) + '+') * len(compute_node_names))
 358     logger.info(line_of_nodes)
 359     logger.info(
 360         '+' + ('-' * 16) + '+' + (('-' * 8) + '+') * len(compute_node_names))
 361     out_plugins_print = ['Gnocchi']
 362     if 'SNMP' in out_plugins.values():
 363         out_plugins_print.append('SNMP')
 364     if 'AODH' in out_plugins.values():
 365         out_plugins_print.append('AODH')
 366     if 'CSV' in out_plugins.values():
 367         out_plugins_print.append('CSV')
 368     for out_plugin in out_plugins_print:
 369         output_plugins_line = ''
 370         for id in compute_ids:
 371             out_plugin_result = 'FAIL'
 372             if out_plugin == 'Gnocchi':
 373                 out_plugin_result = \
 374                     'PASS' if out_plugins[id] == out_plugin else 'FAIL'
 375             if out_plugin == 'AODH':
 376                 if out_plugins[id] == out_plugin:
 377                     out_plugin_result = \
 378                         'PASS' if out_plugins[id] == out_plugin else 'FAIL'
 379             if out_plugin == 'SNMP':
 380                 if out_plugins[id] == out_plugin:
 381                     out_plugin_result = \
 382                         'PASS' if out_plugins[id] == out_plugin else 'FAIL'
 383             if out_plugin == 'CSV':
 384                 if out_plugins[id] == out_plugin:
 385                     out_plugin_result = \
 386                         'PASS' if [
 387                             plugin for comp_id, plugin, res in results
 388                             if comp_id == id and res] else 'FAIL'
 389                 else:
 390                     out_plugin_result = 'SKIP'
 391             output_plugins_line += '| ' + out_plugin_result + '   '
 392         logger.info(
 393             '| OUT:{}'.format(out_plugin) + (' ' * (11 - len(out_plugin)))
 394             + output_plugins_line + '|')
 395         for plugin in sorted(tested_plugins.values()):
 396             line_plugin = _print_final_result_of_plugin(
 397                 plugin, compute_ids, results, out_plugins, out_plugin)
 398             logger.info(
 399                 '|  IN:{}'.format(plugin) + (' ' * (11-len(plugin)))
 400                 + '|' + line_plugin)
 401         logger.info(
 402             '+' + ('-' * 16) + '+'
 403             + (('-' * 8) + '+') * len(compute_node_names))
 404     logger.info('=' * 70)
 405
 406
 407 def _exec_testcase(
 408         test_labels, name, gnocchi_running, aodh_running, snmp_running,
 409         controllers, compute_node, conf, results, error_plugins, out_plugins):
 410     """Execute the testcase.
 411
 412     Keyword arguments:
 413     test_labels -- dictionary of plug-in IDs and their display names
 414     name -- plug-in ID, key of test_labels dictionary
 415     ceilometer_running -- boolean indicating whether Ceilometer is running
 416     compute_node -- compute node ID
 417     conf -- ConfigServer instance
 418     results -- results list
 419     error_plugins -- list of tuples with plug-in errors
 420         (plugin, error_description, is_critical):
 421         plugin -- plug-in ID, key of test_labels dictionary
 422         error_decription -- description of the error
 423         is_critical -- boolean value indicating whether error is critical
 424     """
 425     ovs_interfaces = conf.get_ovs_interfaces(compute_node)
 426     ovs_configured_interfaces = conf.get_plugin_config_values(
 427         compute_node, 'ovs_events', 'Interfaces')
 428     ovs_configured_bridges = conf.get_plugin_config_values(
 429          compute_node, 'ovs_stats', 'Bridges')
 430     ovs_existing_configured_int = [
 431         interface for interface in ovs_interfaces
 432         if interface in ovs_configured_interfaces]
 433     ovs_existing_configured_bridges = [
 434         bridge for bridge in ovs_interfaces
 435         if bridge in ovs_configured_bridges]
 436     plugin_prerequisites = {
 437         'intel_rdt': [(
 438             conf.is_libpqos_on_node(compute_node),
 439             'libpqos must be installed.')],
 440         'mcelog': [(
 441             conf.is_installed(compute_node, 'mcelog'),
 442             'mcelog must be installed.')],
 443         'ovs_events': [(
 444             len(ovs_existing_configured_int) > 0 or len(ovs_interfaces) > 0,
 445             'Interfaces must be configured.')],
 446         'ovs_stats': [(
 447             len(ovs_existing_configured_bridges) > 0,
 448             'Bridges must be configured.')]}
 449     gnocchi_criteria_lists = {
 450         'hugepages': ['hugepages'],
 451         'mcelog': ['mcelog'],
 452         'ovs_events': ['interface-ovs-system'],
 453         'ovs_stats': ['ovs_stats-br0.br0']}
 454     aodh_criteria_lists = {
 455         'mcelog': ['mcelog.errors'],
 456         'ovs_events': ['ovs_events.gauge']}
 457     snmp_mib_files = {
 458         'intel_rdt': '/usr/share/snmp/mibs/Intel-Rdt.txt',
 459         'hugepages': '/usr/share/snmp/mibs/Intel-Hugepages.txt',
 460         'mcelog': '/usr/share/snmp/mibs/Intel-Mcelog.txt'}
 461     snmp_mib_strings = {
 462         'intel_rdt': [
 463             'INTEL-RDT-MIB::rdtLlc.1',
 464             'INTEL-RDT-MIB::rdtIpc.1',
 465             'INTEL-RDT-MIB::rdtMbmRemote.1',
 466             'INTEL-RDT-MIB::rdtMbmLocal.1'],
 467         'hugepages': [
 468             'INTEL-HUGEPAGES-MIB::hugepagesPageFree'],
 469         'mcelog': [
 470             'INTEL-MCELOG-MIB::memoryCorrectedErrors.1',
 471             'INTEL-MCELOG-MIB::memoryCorrectedErrors.2']}
 472     nr_hugepages = int(time.time()) % 10000
 473     snmp_in_commands = {
 474         'intel_rdt': None,
 475         'hugepages': 'echo {} > /sys/kernel/'.format(nr_hugepages)
 476                      + 'mm/hugepages/hugepages-2048kB/nr_hugepages',
 477         'mcelog': '/root/mce-inject_df < /root/corrected'}
 478     csv_subdirs = {
 479         'intel_rdt': [
 480             'intel_rdt-{}'.format(core)
 481             for core in conf.get_plugin_config_values(
 482                 compute_node, 'intel_rdt', 'Cores')],
 483         'hugepages': [
 484             'hugepages-mm-2048Kb', 'hugepages-node0-2048Kb',
 485             'hugepages-node1-2048Kb', 'hugepages-mm-1048576Kb',
 486             'hugepages-node0-1048576Kb', 'hugepages-node1-1048576Kb'],
 487         'ipmi': ['ipmi'],
 488         'mcelog': [
 489             'mcelog-SOCKET_0_CHANNEL_0_DIMM_any',
 490             'mcelog-SOCKET_0_CHANNEL_any_DIMM_any'],
 491         'ovs_stats': [
 492             'ovs_stats-{0}.{0}'.format(interface)
 493             for interface in ovs_existing_configured_bridges],
 494         'ovs_events': [
 495             'ovs_events-{}'.format(interface)
 496             for interface in (
 497                 ovs_existing_configured_int
 498                 if len(ovs_existing_configured_int) > 0 else ovs_interfaces)]}
 499     csv_meter_categories_ipmi = get_csv_categories_for_ipmi(conf, compute_node)
 500     csv_meter_categories = {
 501         'intel_rdt': [
 502             'bytes-llc', 'ipc', 'memory_bandwidth-local',
 503             'memory_bandwidth-remote'],
 504         'hugepages': ['vmpage_number-free', 'vmpage_number-used'],
 505         'ipmi': csv_meter_categories_ipmi,
 506         'mcelog': [
 507             'errors-corrected_memory_errors',
 508             'errors-uncorrected_memory_errors',
 509             'errors-corrected_memory_errors_in_24h',
 510             'errors-uncorrected_memory_errors_in_24h'],
 511         'ovs_stats': [
 512             'if_collisions', 'if_dropped', 'if_errors', 'if_packets',
 513             'if_rx_errors-crc', 'if_rx_errors-frame', 'if_rx_errors-over',
 514             'if_rx_octets', 'if_tx_octets'],
 515         'ovs_events': ['gauge-link_status']}
 516
 517     _print_plugin_label(
 518         test_labels[name] if name in test_labels else name,
 519         compute_node.get_name())
 520     plugin_critical_errors = [
 521         error for plugin, error, critical in error_plugins
 522         if plugin == name and critical]
 523     if plugin_critical_errors:
 524         logger.error('Following critical errors occurred:'.format(name))
 525         for error in plugin_critical_errors:
 526             logger.error(' * ' + error)
 527         _process_result(
 528             compute_node.get_id(), test_labels[name], False, results)
 529     else:
 530         plugin_errors = [
 531             error for plugin, error, critical in error_plugins
 532             if plugin == name and not critical]
 533         if plugin_errors:
 534             logger.warning('Following non-critical errors occured:')
 535             for error in plugin_errors:
 536                 logger.warning(' * ' + error)
 537         failed_prerequisites = []
 538         if name in plugin_prerequisites:
 539             failed_prerequisites = [
 540                 prerequisite_name for prerequisite_passed,
 541                 prerequisite_name in plugin_prerequisites[name]
 542                 if not prerequisite_passed]
 543         if failed_prerequisites:
 544             logger.error(
 545                 '{} test will not be executed, '.format(name)
 546                 + 'following prerequisites failed:')
 547             for prerequisite in failed_prerequisites:
 548                 logger.error(' * {}'.format(prerequisite))
 549         else:
 550             if gnocchi_running:
 551                 plugin_interval = conf.get_plugin_interval(compute_node, name)
 552                 res = conf.test_plugins_with_gnocchi(
 553                     compute_node.get_id(), plugin_interval, logger,
 554                     criteria_list=gnocchi_criteria_lists[name])
 555             elif aodh_running:
 556                 res = conf.test_plugins_with_aodh(
 557                    compute_node.get_id(), plugin_interval,
 558                    logger, creteria_list=aodh_criteria_lists[name])
 559             elif snmp_running:
 560                 res = \
 561                     name in snmp_mib_files and name in snmp_mib_strings \
 562                     and tests.test_snmp_sends_data(
 563                         compute_node,
 564                         conf.get_plugin_interval(compute_node, name), logger,
 565                         SNMPClient(conf, compute_node), snmp_mib_files[name],
 566                         snmp_mib_strings[name], snmp_in_commands[name], conf)
 567             else:
 568                 res = tests.test_csv_handles_plugin_data(
 569                     compute_node, conf.get_plugin_interval(compute_node, name),
 570                     name, csv_subdirs[name], csv_meter_categories[name],
 571                     logger, CSVClient(conf))
 572             if res and plugin_errors:
 573                 logger.info(
 574                     'Test works, but will be reported as failure,'
 575                     + 'because of non-critical errors.')
 576                 res = False
 577             _process_result(
 578                 compute_node.get_id(), test_labels[name], res, results)
 579
 580
 581 def get_results_for_ovs_events(
 582         plugin_labels, plugin_name, gnocchi_running,
 583         compute_node, conf, results, error_plugins):
 584     """ Testing OVS Events with python plugin
 585     """
 586     plugin_label = 'OVS events'
 587     res = conf.enable_ovs_events(
 588         compute_node, plugin_label, error_plugins, create_backup=False)
 589     _process_result(
 590         compute_node.get_id(), plugin_label, res, results)
 591     logger.info("Results for OVS Events = {}" .format(results))
 592
 593
 594 def mcelog_install():
 595     """Install mcelog on compute nodes."""
 596     _print_label('Enabling mcelog on compute nodes')
 597     handler = factory.Factory.get_handler('apex',
 598                                           APEX_IP,
 599                                           APEX_USER_STACK,
 600                                           APEX_PKEY)
 601     nodes = handler.get_nodes()
 602     for node in nodes:
 603         if node.is_compute():
 604             centos_release = node.run_cmd('uname -r')
 605             if '3.10.0-514.26.2.el7.x86_64' not in centos_release:
 606                 logger.info(
 607                     'Mcelog will not be enabled '
 608                     + 'on node-{0}, '.format(node.get_dict()['id'])
 609                     + 'unsupported CentOS release found ({1}).'.format(
 610                         centos_release))
 611             else:
 612                 logger.info(
 613                     'Checking if  mcelog is enabled'
 614                     + ' on node-{}...'.format(node.get_dict()['id']))
 615                 res = node.run_cmd('ls')
 616             if 'mce-inject_ea' and 'corrected' in res:
 617                 logger.info(
 618                     'Mcelog seems to be already installed '
 619                     + 'on node-{}.'.format(node.get_dict()['id']))
 620                 node.run_cmd('modprobe mce-inject_ea')
 621                 node.run_cmd('mce-inject_ea < corrected')
 622             else:
 623                 logger.info(
 624                     'Mcelog will be enabled on node-{}...'.format(
 625                         node.get_dict()['id']))
 626                 node.put_file(
 627                     '/usr/local/lib/python2.7/dist-packages/baro_tests/'
 628                     + 'mce-inject_ea', 'mce-inject_ea')
 629                 node.run_cmd('chmod a+x mce-inject_ea')
 630                 node.run_cmd('echo "CPU 0 BANK 0" > corrected')
 631                 node.run_cmd(
 632                     'echo "STATUS 0xcc00008000010090" >>'
 633                     + ' corrected')
 634                 node.run_cmd(
 635                     'echo "ADDR 0x0010FFFFFFF" >> corrected')
 636                 node.run_cmd('modprobe mce-inject')
 637                 node.run_cmd('mce-inject_ea < corrected')
 638     logger.info('Mcelog is installed on all compute nodes')
 639
 640
 641 def mcelog_delete():
 642     """Uninstall mcelog from compute nodes."""
 643     handler = factory.Factory.get_handler(
 644             'apex', APEX_IP, APEX_USER, APEX_PKEY)
 645     nodes = handler.get_nodes()
 646     for node in nodes:
 647         if node.is_compute():
 648             output = node.run_cmd('ls')
 649             if 'mce-inject_ea' in output:
 650                 node.run_cmd('rm mce-inject_ea')
 651             if 'corrected' in output:
 652                 node.run_cmd('rm corrected')
 653             node.run_cmd('systemctl restart mcelog')
 654     logger.info('Mcelog is deleted from all compute nodes')
 655
 656
 657 def get_ssh_keys():
 658     if not os.path.isdir(ID_RSA_DST_DIR):
 659         os.makedirs(ID_RSA_DST_DIR)
 660     if not os.path.isfile(ID_RSA_DST):
 661         logger.info(
 662             "RSA key file {} doesn't exist".format(ID_RSA_DST)
 663             + ", it will be downloaded from installer node.")
 664         handler = factory.Factory.get_handler(
 665             'apex', APEX_IP, APEX_USER, APEX_PKEY)
 666         apex = handler.get_installer_node()
 667         apex.get_file(ID_RSA_SRC, ID_RSA_DST)
 668     else:
 669         logger.info("RSA key file {} exists.".format(ID_RSA_DST))
 670
 671
 672 def _check_logger():
 673     """Check whether there is global logger available and if not, define one."""
 674     if 'logger' not in globals():
 675         global logger
 676         logger = logger.Logger("barometercollectd").getLogger()
 677
 678
 679 def main(bt_logger=None):
 680     """Check each compute node sends gnocchi metrics.
 681
 682     Keyword arguments:
 683     bt_logger -- logger instance
 684     """
 685     logging.getLogger("paramiko").setLevel(logging.WARNING)
 686     logging.getLogger("stevedore").setLevel(logging.WARNING)
 687     logging.getLogger("opnfv.deployment.manager").setLevel(logging.WARNING)
 688     if bt_logger is None:
 689         _check_logger()
 690     else:
 691         global logger
 692         logger = bt_logger
 693     _print_label("Starting barometer tests suite")
 694     get_ssh_keys()
 695     conf = config_server.ConfigServer(APEX_IP, APEX_USER, logger)
 696     controllers = conf.get_controllers()
 697     if len(controllers) == 0:
 698         logger.error('No controller nodes found!')
 699         return 1
 700     computes = conf.get_computes()
 701     if len(computes) == 0:
 702         logger.error('No compute nodes found!')
 703         return 1
 704
 705     _print_label(
 706         'Display of Control and Compute nodes available in the set up')
 707     logger.info('controllers: {}'.format([('{0}: {1} ({2})'.format(
 708         node.get_id(), node.get_name(),
 709         node.get_ip())) for node in controllers]))
 710     logger.info('computes: {}'.format([('{0}: {1} ({2})'.format(
 711         node.get_id(), node.get_name(), node.get_ip()))
 712         for node in computes]))
 713
 714     mcelog_install()
 715     gnocchi_running_on_con = False
 716     aodh_running_on_con = False
 717     snmp_running = False
 718     _print_label('Testing Gnocchi, AODH and SNMP on controller nodes')
 719
 720     for controller in controllers:
 721         gnocchi_client = GnocchiClient()
 722         gnocchi_client.auth_token()
 723         gnocchi_running = (
 724             gnocchi_running_on_con and conf.is_gnocchi_running(controller))
 725         aodh_client = AodhClient()
 726         aodh_client.auth_token()
 727         aodh_running = (
 728             aodh_running_on_con and conf.is_aodh_running(controller))
 729     if gnocchi_running:
 730         logger.info("Gnocchi is running on controller.")
 731     elif aodh_running:
 732         logger.error("Gnocchi is not running on controller.")
 733         logger.info("AODH is running on controller.")
 734     elif snmp_running:
 735         logger.error("Gnocchi is not running on Controller")
 736         logger.error("AODH is not running on controller.")
 737         logger.info("SNMP is running on controller.")
 738     else:
 739         logger.error("Gnocchi is not running on Controller")
 740         logger.error("AODH is not running on controller.")
 741         logger.error("SNMP is not running on controller.")
 742         logger.info("CSV will be enabled on compute nodes.")
 743
 744     compute_ids = []
 745     compute_node_names = []
 746     results = []
 747     plugin_labels = {
 748         'intel_rdt': 'Intel RDT',
 749         'hugepages': 'Hugepages',
 750         # 'ipmi': 'IPMI',
 751         'mcelog': 'Mcelog',
 752         'ovs_stats': 'OVS stats',
 753         'ovs_events': 'OVS events'}
 754     out_plugins = {
 755         'gnocchi': 'Gnocchi',
 756         'aodh': 'AODH',
 757         'snmp': 'SNMP',
 758         'csv': 'CSV'}
 759     for compute_node in computes:
 760         node_id = compute_node.get_id()
 761         node_name = compute_node.get_name()
 762         out_plugins[node_id] = 'CSV'
 763         compute_ids.append(node_id)
 764         compute_node_names.append(node_name)
 765         plugins_to_enable = []
 766         _print_label('NODE {}: Test Gnocchi Plug-in'.format(node_name))
 767         logger.info('Checking if gnocchi plug-in is included in compute nodes.')
 768         if not conf.check_gnocchi_plugin_included(compute_node):
 769             logger.error('Gnocchi plug-in is not included.')
 770             logger.info(
 771                 'Testcases on node {} will not be executed'.format(node_name))
 772         else:
 773             collectd_restarted, collectd_warnings = \
 774                 conf.restart_collectd(compute_node)
 775             sleep_time = 5
 776             logger.info(
 777                 'Sleeping for {} seconds after collectd restart...'.format(
 778                     sleep_time))
 779             time.sleep(sleep_time)
 780             if not collectd_restarted:
 781                 for warning in collectd_warnings:
 782                     logger.warning(warning)
 783                 logger.error(
 784                     'Restart of collectd on node {} failed'.format(node_name))
 785                 logger.info(
 786                     'Testcases on node {} will not be executed'.format(
 787                         node_name))
 788             else:
 789                 for warning in collectd_warnings:
 790                     logger.warning(warning)
 791
 792                 if gnocchi_running:
 793                     out_plugins[node_id] = 'Gnocchi'
 794                     logger.info("Gnocchi is active and collecting data")
 795                 elif aodh_running:
 796                     out_plugins[node_id] = 'AODH'
 797                     logger.info("AODH withh be tested")
 798                     _print_label('Node {}: Test AODH' .format(node_name))
 799                     logger.info("Checking if AODH is running")
 800                     logger.info("AODH is running")
 801                 elif snmp_running:
 802                     out_plugins[node_id] = 'SNMP'
 803                     logger.info("SNMP will be tested.")
 804                     _print_label('NODE {}: Test SNMP'.format(node_id))
 805                     logger.info("Checking if SNMP is running.")
 806                     logger.info("SNMP is running.")
 807                 else:
 808                     plugins_to_enable.append('csv')
 809                     out_plugins[node_id] = 'CSV'
 810                     logger.error("Gnocchi, AODH, SNMP are not running")
 811                     logger.info(
 812                         "CSV will be enabled for verification "
 813                         + "of test plugins.")
 814                 if plugins_to_enable:
 815                     _print_label(
 816                         'NODE {}: Enabling Test Plug-in '.format(node_name)
 817                         + 'and Test case execution')
 818                 error_plugins = []
 819                 if plugins_to_enable and not conf.enable_plugins(
 820                         compute_node, plugins_to_enable, error_plugins,
 821                         create_backup=False):
 822                     logger.error(
 823                         'Failed to test plugins on node {}.'.format(node_id))
 824                     logger.info(
 825                         'Testcases on node {} will not be executed'.format(
 826                             node_id))
 827                 else:
 828                     if plugins_to_enable:
 829                         collectd_restarted, collectd_warnings = \
 830                             conf.restart_collectd(compute_node)
 831                         sleep_time = 30
 832                         logger.info(
 833                             'Sleeping for {} seconds'.format(sleep_time)
 834                             + ' after collectd restart...')
 835                         time.sleep(sleep_time)
 836                     if plugins_to_enable and not collectd_restarted:
 837                         for warning in collectd_warnings:
 838                             logger.warning(warning)
 839                         logger.error(
 840                             'Restart of collectd on node {} failed'.format(
 841                                 node_id))
 842                         logger.info(
 843                             'Testcases on node {}'.format(node_id)
 844                             + ' will not be executed.')
 845                     else:
 846                         if collectd_warnings:
 847                             for warning in collectd_warnings:
 848                                 logger.warning(warning)
 849
 850                         for plugin_name in sorted(plugin_labels.keys()):
 851                             _exec_testcase(
 852                                 plugin_labels, plugin_name, gnocchi_running,
 853                                 aodh_running, snmp_running, controllers,
 854                                 compute_node, conf, results, error_plugins,
 855                                 out_plugins[node_id])
 856
 857             _print_label('NODE {}: Restoring config file'.format(node_name))
 858             conf.restore_config(compute_node)
 859         mcelog_delete()
 860     print_overall_summary(compute_ids, plugin_labels, results, out_plugins)
 861
 862     if ((len([res for res in results if not res[2]]) > 0)
 863             or (len(results) < len(computes) * len(plugin_labels))):
 864         logger.error('Some tests have failed or have not been executed')
 865         return 1
 866     return 0
 867
 868
 869 if __name__ == '__main__':
 870     sys.exit(main())