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