baro_tests/config_server.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 """Classes used by collectd.py"""
  16
  17 import time
  18 import os.path
  19 import os
  20 import re
  21
  22 from opnfv.deployment import factory
  23 import paramiko
  24 from functest.utils import constants
  25
  26 ID_RSA_PATH = '/root/.ssh/id_rsa'
  27 SSH_KEYS_SCRIPT = '/home/opnfv/barometer/baro_utils/get_ssh_keys.sh'
  28 DEF_PLUGIN_INTERVAL = 10
  29 COLLECTD_CONF = '/etc/collectd.conf'
  30 COLLECTD_CONF_DIR = '/etc/collectd/collectd.conf.d'
  31 NOTIFICATION_FILE = '/var/log/python-notifications.dump'
  32 COLLECTD_NOTIFICATION = '/etc/collectd_notification_dump.py'
  33 APEX_IP = os.getenv("INSTALLER_IP").rstrip('\n')
  34 APEX_USER = 'root'
  35 APEX_USER_STACK = 'stack'
  36 APEX_PKEY = '/root/.ssh/id_rsa'
  37
  38
  39 class Node(object):
  40     """Node configuration class"""
  41     def __init__(self, attrs):
  42         self.__null = attrs[0]
  43         self.__id = attrs[1]
  44         self.__name = attrs[2]
  45         self.__status = attrs[3] if attrs[3] else None
  46         self.__taskState = attrs[4]
  47         self.__pwrState = attrs[5]
  48         self.__ip = re.sub('^[a-z]+=', '', attrs[6])
  49
  50     def get_name(self):
  51         """Get node name"""
  52         return self.__name
  53
  54     def get_id(self):
  55         """Get node ID"""
  56         return self.__id
  57
  58     def get_ip(self):
  59         """Get node IP address"""
  60         return self.__ip
  61
  62     def get_roles(self):
  63         """Get node role"""
  64         return self.__roles
  65
  66
  67 def get_apex_nodes():
  68     handler = factory.Factory.get_handler('apex',
  69                                           APEX_IP,
  70                                           APEX_USER_STACK,
  71                                           APEX_PKEY)
  72     nodes = handler.get_nodes()
  73     return nodes
  74
  75
  76 class ConfigServer(object):
  77     """Class to get env configuration"""
  78     def __init__(self, host, user, logger, priv_key=None):
  79         self.__host = host
  80         self.__user = user
  81         self.__passwd = None
  82         self.__priv_key = priv_key
  83         self.__nodes = list()
  84         self.__logger = logger
  85
  86         self.__private_key_file = ID_RSA_PATH
  87         if not os.path.isfile(self.__private_key_file):
  88             self.__logger.error(
  89                 "Private key file '{}'".format(self.__private_key_file)
  90                 + " not found.")
  91             raise IOError("Private key file '{}' not found.".format(
  92                 self.__private_key_file))
  93
  94         # get list of available nodes
  95         ssh, sftp = self.__open_sftp_session(
  96             self.__host, self.__user, self.__passwd)
  97         attempt = 1
  98         fuel_node_passed = False
  99
 100         while (attempt <= 10) and not fuel_node_passed:
 101             stdin, stdout, stderr = ssh.exec_command(
 102                 "source stackrc; nova list")
 103             stderr_lines = stderr.readlines()
 104             if stderr_lines:
 105                 self.__logger.warning(
 106                     "'Apex node' command failed (try {}):".format(attempt))
 107                 for line in stderr_lines:
 108                     self.__logger.debug(line.strip())
 109             else:
 110                 fuel_node_passed = True
 111                 if attempt > 1:
 112                     self.__logger.info(
 113                         "'Apex node' command passed (try {})".format(attempt))
 114             attempt += 1
 115         if not fuel_node_passed:
 116             self.__logger.error(
 117                 "'Apex node' command failed. This was the last try.")
 118             raise OSError(
 119                 "'Apex node' command failed. This was the last try.")
 120         node_table = stdout.readlines()\
 121
 122         # skip table title and parse table values
 123
 124         for entry in node_table[3:]:
 125             if entry[0] == '+' or entry[0] == '\n':
 126                 print entry
 127                 pass
 128             else:
 129                 self.__nodes.append(
 130                     Node([str(x.strip(' \n')) for x in entry.split('|')]))
 131
 132     def get_controllers(self):
 133         # Get list of controllers
 134         print self.__nodes[0]._Node__ip
 135         return (
 136             [node for node in self.__nodes if 'controller' in node.get_name()])
 137
 138     def get_computes(self):
 139         # Get list of computes
 140         return (
 141             [node for node in self.__nodes if 'compute' in node.get_name()])
 142
 143     def get_nodes(self):
 144         # Get list of nodes
 145         return self.__nodes
 146
 147     def __open_sftp_session(self, host, user, passwd=None):
 148         # Connect to given host.
 149         """Keyword arguments:
 150         host -- host to connect
 151         user -- user to use
 152         passwd -- password to use
 153
 154         Return tuple of SSH and SFTP client instances.
 155         """
 156         # create SSH client
 157         ssh = paramiko.SSHClient()
 158         ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
 159
 160         # try a direct access using password or private key
 161         if not passwd and not self.__priv_key:
 162             # get private key
 163             self.__priv_key = paramiko.RSAKey.from_private_key_file(
 164                 self.__private_key_file)
 165
 166         # connect to the server
 167         ssh.connect(
 168             host, username=user, password=passwd, pkey=self.__priv_key)
 169         sftp = ssh.open_sftp()
 170
 171         # return SFTP client instance
 172         return ssh, sftp
 173
 174     def get_plugin_interval(self, compute, plugin):
 175         """Find the plugin interval in collectd configuration.
 176
 177         Keyword arguments:
 178         compute -- compute node instance
 179         plugin -- plug-in name
 180
 181         If found, return interval value, otherwise the default value"""
 182         default_interval = DEF_PLUGIN_INTERVAL
 183         compute_name = compute.get_name()
 184         nodes = get_apex_nodes()
 185         for node in nodes:
 186             if compute_name == node.get_dict()['name']:
 187                 stdout = node.run_cmd(
 188                     'cat /etc/collectd/collectd.conf.d/{}.conf'.format(plugin))
 189                 if stdout is None:
 190                     return default_interval
 191                 for line in stdout.split('\n'):
 192                     if 'Interval' in line:
 193                         return 1
 194         return default_interval
 195
 196     def get_plugin_config_values(self, compute, plugin, parameter):
 197         """Get parameter values from collectd config file.
 198
 199         Keyword arguments:
 200         compute -- compute node instance
 201         plugin -- plug-in name
 202         parameter -- plug-in parameter
 203
 204         Return list of found values."""
 205         default_values = []
 206         compute_name = compute.get_name()
 207         nodes = get_apex_nodes()
 208         for node in nodes:
 209             if compute_name == node.get_dict()['name']:
 210                 stdout = node.run_cmd(
 211                     'cat /etc/collectd/collectd.conf.d/{}.conf' .format(plugin))
 212                 if stdout is None:
 213                     return default_values
 214                 for line in stdout.split('\n'):
 215                     if 'Interfaces' in line:
 216                         return line.split(' ', 1)[1]
 217                     elif 'Bridges' in line:
 218                         return line.split(' ', 1)[1]
 219                     elif 'Cores' in line:
 220                         return line.split(' ', 1)[1]
 221                     else:
 222                         pass
 223         return default_values
 224
 225     def execute_command(self, command, host_ip=None, ssh=None):
 226         """Execute command on node and return list of lines of standard output.
 227
 228         Keyword arguments:
 229         command -- command
 230         host_ip -- IP of the node
 231         ssh -- existing open SSH session to use
 232
 233         One of host_ip or ssh must not be None. If both are not None,
 234         existing ssh session is used.
 235         """
 236         if host_ip is None and ssh is None:
 237             raise ValueError('One of host_ip or ssh must not be None.')
 238         if ssh is None:
 239             ssh, sftp = self.__open_sftp_session(host_ip, 'root', 'opnfvapex')
 240         stdin, stdout, stderr = ssh.exec_command(command)
 241         return stdout.readlines()
 242
 243     def get_ovs_interfaces(self, compute):
 244         """Get list of configured OVS interfaces
 245
 246         Keyword arguments:
 247         compute -- compute node instance
 248         """
 249         compute_name = compute.get_name()
 250         nodes = get_apex_nodes()
 251         for node in nodes:
 252             if compute_name == node.get_dict()['name']:
 253                 stdout = node.run_cmd('sudo ovs-vsctl list-br')
 254         return stdout
 255
 256     def is_gnocchi_running(self, controller):
 257         """Check whether Gnocchi is running on controller.
 258
 259         Keyword arguments:
 260         controller -- controller node instance
 261
 262         Return boolean value whether Gnocchi is running.
 263         """
 264         gnocchi_present = False
 265         controller_name = controller.get_name()
 266         nodes = get_apex_nodes()
 267         for node in nodes:
 268             if controller_name == node.get_dict()['name']:
 269                 node.put_file(constants.ENV_FILE, 'overcloudrc.v3')
 270                 stdout = node.run_cmd(
 271                     "source overcloudrc.v3;"
 272                     + "openstack catalog list | grep gnocchi")
 273                 if stdout is None:
 274                     return False
 275                 elif 'gnocchi' in stdout:
 276                     gnocchi_present = True
 277                     return gnocchi_present
 278                 else:
 279                     return False
 280         return gnocchi_present
 281
 282     def is_aodh_running(self, controller):
 283         """Check whether aodh service is running on controller
 284         """
 285         aodh_present = False
 286         controller_name = controller.get_name()
 287         nodes = get_apex_nodes()
 288         for node in nodes:
 289             if controller_name == node.get_dict()['name']:
 290                 node.put_file(constants.ENV_FILE, 'overcloudrc.v3')
 291                 stdout = node.run_cmd(
 292                     "source overcloudrc.v3;"
 293                     + "openstack catalog list | grep aodh")
 294                 if stdout is None:
 295                     return False
 296                 elif 'aodh' in stdout:
 297                     aodh_present = True
 298                     return aodh_present
 299                 else:
 300                     return False
 301         return aodh_present
 302
 303     def is_mcelog_installed(self, compute, package):
 304         """Check whether package exists on compute node.
 305
 306         Keyword arguments:
 307         compute -- compute node instance
 308         package -- Linux package to search for
 309
 310         Return boolean value whether package is installed.
 311         """
 312         compute_name = compute.get_name()
 313         nodes = get_apex_nodes()
 314         for node in nodes:
 315             if compute_name == node.get_dict()['name']:
 316                 stdout = node.run_cmd(
 317                     'rpm -qa | grep mcelog')
 318                 if stdout is None:
 319                     return 0
 320                 elif 'mcelog' in stdout:
 321                     return 1
 322                 else:
 323                     return 0
 324
 325     def is_rdt_available(self, compute):
 326         """Check whether the compute node is a virtual machine."""
 327         compute_name = compute.get_name()
 328         nodes = get_apex_nodes()
 329         for node in nodes:
 330             if compute_name == node.get_dict()['name']:
 331                 stdout = node.run_cmd('cat /proc/cpuinfo | grep hypervisor')
 332                 if 'hypervisor' in stdout:
 333                     return False
 334         return True
 335
 336     def is_libpqos_on_node(self, compute):
 337         """Check whether libpqos is present on compute node"""
 338
 339         compute_name = compute.get_name()
 340         nodes = get_apex_nodes()
 341         for node in nodes:
 342             if compute_name == node.get_dict()['name']:
 343                 stdout = node.run_cmd('ls /usr/local/lib/ | grep libpqos')
 344                 if 'libpqos' in stdout:
 345                     return True
 346         return False
 347
 348     def check_aodh_plugin_included(self, compute):
 349         """Check if aodh plugin is included in collectd.conf file.
 350         If not, try to enable it.
 351
 352         Keyword arguments:
 353         compute -- compute node instance
 354
 355         Return boolean value whether AODH plugin is included
 356         or it's enabling was successful.
 357         """
 358         compute_name = compute.get_name()
 359         nodes = get_apex_nodes()
 360         for node in nodes:
 361             if compute_name == node.get_dict()['name']:
 362                 aodh_conf = node.run_cmd('ls /etc/collectd/collectd.conf.d')
 363                 if 'aodh.conf' not in aodh_conf:
 364                     self.__logger.info(
 365                         "AODH Plugin not included in {}".format(compute_name))
 366                     return False
 367                 else:
 368                     self.__logger.info(
 369                         "AODH plugin present in compute node {}" .format(
 370                             compute_name))
 371                     return True
 372         return True
 373
 374     def check_gnocchi_plugin_included(self, compute):
 375         """Check if gnocchi plugin is included in collectd.conf file.
 376         If not, try to enable it.
 377
 378         Keyword arguments:
 379         compute -- compute node instance
 380
 381         Return boolean value whether gnocchi plugin is included
 382         or it's enabling was successful.
 383         """
 384         compute_name = compute.get_name()
 385         nodes = get_apex_nodes()
 386         for node in nodes:
 387             if compute_name == node.get_dict()['name']:
 388                 gnocchi_conf = node.run_cmd('ls /etc/collectd/collectd.conf.d')
 389                 if 'collectd-ceilometer-plugin.conf' not in gnocchi_conf:
 390                     self.__logger.info(
 391                         "Gnocchi Plugin not included in node {}".format(
 392                             compute_name))
 393                     return False
 394                 else:
 395                     self.__logger.info(
 396                         "Gnocchi plugin available in compute node {}" .format(
 397                             compute_name))
 398                     return True
 399         return True
 400
 401     def check_snmp_plugin_included(self, compute):
 402         """Check if SNMP plugin is active in compute node.
 403         """
 404         snmp_mib = '/usr/share/snmp/mibs/Intel-Rdt.txt'
 405         snmp_string = 'INTEL-RDT-MIB::intelRdt'
 406         compute_name = compute.get_name()
 407         nodes = get_apex_nodes()
 408         for node in nodes:
 409             if compute_name == node.get_dict()['name']:
 410                 stdout = node.run_cmd(
 411                     'snmpwalk -v2c -m {0} -c public localhost {1}' .format(
 412                         snmp_mib, snmp_string))
 413                 self.__logger.info("snmp output = {}" .format(stdout))
 414                 if 'OID' in stdout:
 415                     return False
 416                 else:
 417                     return True
 418
 419     def enable_plugins(
 420             self, compute, plugins, error_plugins, create_backup=True):
 421         """Enable plugins on compute node
 422
 423         Keyword arguments:
 424         compute -- compute node instance
 425         plugins -- list of plugins to be enabled
 426
 427         Return boolean value indicating whether function was successful.
 428         """
 429         csv_file = os.path.dirname(os.path.realpath(__file__)) + '/csv.conf'
 430         plugins = sorted(plugins)
 431         compute_name = compute.get_name()
 432         nodes = get_apex_nodes()
 433         for node in nodes:
 434             if compute_name == node.get_dict()['name']:
 435                 node.put_file(csv_file, 'csv.conf')
 436                 node.run_cmd(
 437                     'sudo cp csv.conf '
 438                     + '/etc/collectd/collectd.conf.d/csv.conf')
 439         return True
 440
 441     def restart_collectd(self, compute):
 442         """Restart collectd on compute node.
 443
 444         Keyword arguments:
 445         compute -- compute node instance
 446
 447         Retrun tuple with boolean indicating success and list of warnings
 448         received during collectd start.
 449         """
 450         compute_name = compute.get_name()
 451         nodes = get_apex_nodes()
 452
 453         def get_collectd_processes(compute_node):
 454             """Get number of running collectd processes.
 455
 456             Keyword arguments:
 457             ssh_session -- instance of SSH session in which to check
 458                 for processes
 459             """
 460             stdout = compute_node.run_cmd("pgrep collectd")
 461             return len(stdout)
 462
 463         for node in nodes:
 464             if compute_name == node.get_dict()['name']:
 465                 # node.run_cmd('su; "opnfvapex"')
 466                 self.__logger.info('Stopping collectd service...')
 467                 node.run_cmd('sudo systemctl stop collectd')
 468                 time.sleep(10)
 469                 if get_collectd_processes(node):
 470                     self.__logger.error('Collectd is still running...')
 471                     return False, []
 472                 self.__logger.info('Starting collectd service...')
 473                 stdout = node.run_cmd('sudo systemctl start collectd')
 474                 time.sleep(10)
 475                 warning = [
 476                     output.strip() for output in stdout if 'WARN: ' in output]
 477                 if get_collectd_processes(node) == 0:
 478                     self.__logger.error('Collectd is still not running...')
 479                     return False, warning
 480         return True, warning
 481
 482     def test_plugins_with_aodh(
 483             self, compute, plugin_interval, logger,
 484             criteria_list=[]):
 485
 486         metric_id = {}
 487         timestamps1 = {}
 488         timestamps2 = {}
 489         nodes = get_apex_nodes()
 490         for node in nodes:
 491             if node.is_controller():
 492                 self.__logger.info('Getting AODH Alarm list on {}' .format(
 493                     (node.get_dict()['name'])))
 494                 node.put_file(constants.ENV_FILE, 'overcloudrc.v3')
 495                 stdout = node.run_cmd(
 496                     "source overcloudrc.v3;"
 497                     + "aodh alarm list | grep {0} | grep {1}"
 498                     .format(criteria_list, compute))
 499                 if stdout is None:
 500                     self.__logger.info("aodh alarm list was empty")
 501                     return False
 502                 for line in stdout.splitlines():
 503                     line = line.replace('|', "")
 504                     metric_id = line.split()[0]
 505                     stdout = node.run_cmd(
 506                         'source overcloudrc.v3; aodh alarm show {}' .format(
 507                             metric_id))
 508                     if stdout is None:
 509                         self.__logger.info("aodh alarm list was empty")
 510                         return False
 511                     for line in stdout.splitlines()[3: -1]:
 512                         line = line.replace('|', "")
 513                         if line.split()[0] == 'timestamp':
 514                             timestamps1 = line.split()[1]
 515                         else:
 516                             pass
 517                     time.sleep(12)
 518                     stdout = node.run_cmd(
 519                         "source overcloudrc.v3; aodh alarm show {}" .format(
 520                             metric_id))
 521                     if stdout is None:
 522                         self.__logger.info("aodh alarm list was empty")
 523                         return False
 524                     for line in stdout.splitlines()[3:-1]:
 525                         line = line.replace('|', "")
 526                         if line.split()[0] == 'timestamp':
 527                             timestamps2 = line.split()[1]
 528                         else:
 529                             pass
 530                     if timestamps1 == timestamps2:
 531                         self.__logger.info(
 532                             "Data not updated after interval of 12 seconds")
 533                         return False
 534                     else:
 535                         self.__logger.info("PASS")
 536                         return True
 537
 538     def test_plugins_with_gnocchi(
 539             self, compute, plugin_interval, logger,
 540             criteria_list=[]):
 541
 542         metric_id = {}
 543         timestamps1 = {}
 544         timestamps2 = {}
 545         nodes = get_apex_nodes()
 546         if plugin_interval > 15:
 547             sleep_time = plugin_interval*2
 548         else:
 549             sleep_time = 30
 550
 551         for node in nodes:
 552             if node.is_controller():
 553                 self.__logger.info('Getting gnocchi metric list on {}' .format(
 554                     (node.get_dict()['name'])))
 555                 node.put_file(constants.ENV_FILE, 'overcloudrc.v3')
 556                 stdout = node.run_cmd(
 557                     "source overcloudrc.v3;"
 558                     + "gnocchi metric list | grep {0} | grep {1}"
 559                     .format(criteria_list, compute))
 560                 if stdout is None:
 561                         self.__logger.info("gnocchi list was empty")
 562                         return False
 563                 for line in stdout.splitlines():
 564                     line = line.replace('|', "")
 565                     metric_id = line.split()[0]
 566                     stdout = node.run_cmd(
 567                         'source overcloudrc.v3;gnocchi measures show {}'.format(
 568                             metric_id))
 569                     if stdout is None:
 570                         self.__logger.info("gnocchi list was empty")
 571                         return False
 572                     for line in stdout.splitlines()[3: -1]:
 573                         if line[0] == '+':
 574                             pass
 575                         else:
 576                             timestamps1 = line.replace('|', "")
 577                             timestamps1 = timestamps1.split()[0]
 578                     time.sleep(sleep_time)
 579                     stdout = node.run_cmd(
 580                         "source overcloudrc.v3;gnocchi measures show {}".format(
 581                             metric_id))
 582                     if stdout is None:
 583                         self.__logger.info("gnocchi measures was empty")
 584                         return False
 585                     for line in stdout.splitlines()[3:-1]:
 586                         if line[0] == '+':
 587                             pass
 588                         else:
 589                             timestamps2 = line.replace('|', "")
 590                             timestamps2 = timestamps2.split()[0]
 591                     if timestamps1 == timestamps2:
 592                         self.__logger.info(
 593                             "Plugin Interval is {}" .format(plugin_interval))
 594                         self.__logger.info(
 595                             "Data not updated after {} seconds".format(
 596                                 sleep_time))
 597                         return False
 598                     else:
 599                         self.__logger.info("PASS")
 600                         return True
 601         return False
 602
 603     def test_plugins_with_snmp(
 604             self, compute, plugin_interval, logger, plugin, snmp_mib_files=[],
 605             snmp_mib_strings=[], snmp_in_commands=[]):
 606
 607         if plugin == 'hugepages' or 'intel_rdt' or 'mcelog':
 608             nodes = get_apex_nodes()
 609             for node in nodes:
 610                 if compute == node.get_dict()['name']:
 611                     stdout = node.run_cmd(
 612                         'snmpwalk -v2c -m {0} -c public localhost {1}' .format(
 613                             snmp_mib_files, snmp_mib_strings))
 614                     self.__logger.info("{}" .format(stdout))
 615                     if stdout is None:
 616                         self.__logger.info("No output from snmpwalk")
 617                         return False
 618                     elif 'OID' in stdout:
 619                         self.__logger.info("SNMP query failed")
 620                         return False
 621                     else:
 622                         counter1 = stdout.split()[3]
 623                     time.sleep(10)
 624                     stdout = node.run_cmd(
 625                         'snmpwalk -v2c -m {0} -c public localhost {1}' .format(
 626                             snmp_mib_files, snmp_mib_strings))
 627                     self.__logger.info("{}" .format(stdout))
 628                     if stdout is None:
 629                         self.__logger.info("No output from snmpwalk")
 630                     elif 'OID' in stdout:
 631                         self.__logger.info(
 632                             "SNMP query failed during second check")
 633                         self.__logger.info("waiting for 10 sec")
 634                         time.sleep(10)
 635                     stdout = node.run_cmd(
 636                         'snmpwalk -v2c -m {0} -c public localhost {1}' .format(
 637                             snmp_mib_files, snmp_mib_strings))
 638                     self.__logger.info("{}" .format(stdout))
 639                     if stdout is None:
 640                         self.__logger.info("No output from snmpwalk")
 641                     elif 'OID' in stdout:
 642                         self.__logger.info("SNMP query failed again")
 643                         self.__logger.info("Failing this test case")
 644                         return False
 645                     else:
 646                         counter2 = stdout.split()[3]
 647
 648                     if counter1 == counter2:
 649                         return False
 650                     else:
 651                         return True
 652         else:
 653             return False