Added Functest testcases for Barometer project

Added different method to get user credentials of the installer
nodes instead of reading from installer_params.yaml

Change-Id: I97419c942e1cd9f943a62c36dbce424872a10cb1
Signed-off-by: Sharada Shiddibhavi <sharada.shiddibhavi@intel.com>

diff --git a/baro_tests/collectd.py b/baro_tests/collectd.py
index 5ac3c8f..9e9b3f6 100644 (file)
--- a/baro_tests/collectd.py
+++ b/baro_tests/collectd.py
@@ -1,4 +1,3 @@
-"""Executing test of plugins"""

 # -*- coding: utf-8 -*-
 
 # Licensed under the Apache License, Version 2.0 (the "License"); you may
 # -*- coding: utf-8 -*-
 
 # Licensed under the Apache License, Version 2.0 (the "License"); you may


@@ -13,26 +12,27 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
 # License for the specific language governing permissions and limitations
 # under the License.
 

+"""Executing test of plugins"""
+

 import requests
 from keystoneclient.v3 import client
 import os
 import requests
 from keystoneclient.v3 import client
 import os

-import pkg_resources
+import sys

 import time
 import logging
 import time
 import logging

-from config_server import *
-from tests import *
+import config_server
+import tests
+import subprocess

 from opnfv.deployment import factory
 from opnfv.deployment import factory

-from functest.utils import functest_utils

 
 

-CEILOMETER_NAME = 'ceilometer'
+GNOCCHI_NAME = 'gnocchi'

 ID_RSA_SRC = '/root/.ssh/id_rsa'
 ID_RSA_DST_DIR = '/home/opnfv/.ssh'
 ID_RSA_DST = ID_RSA_DST_DIR + '/id_rsa'
 ID_RSA_SRC = '/root/.ssh/id_rsa'
 ID_RSA_DST_DIR = '/home/opnfv/.ssh'
 ID_RSA_DST = ID_RSA_DST_DIR + '/id_rsa'

-INSTALLER_PARAMS_YAML = pkg_resources.resource_filename(
-    'functest', 'ci/installer_params.yaml')
-FUEL_IP = functest_utils.get_parameter_from_yaml('fuel.ip', INSTALLER_PARAMS_YAML)
-FUEL_USER = functest_utils.get_parameter_from_yaml('fuel.user', INSTALLER_PARAMS_YAML)
-FUEL_PW = functest_utils.get_parameter_from_yaml('fuel.password', INSTALLER_PARAMS_YAML)
+APEX_IP = subprocess.check_output("echo $INSTALLER_IP", shell=True)
+APEX_USER = 'root'
+APEX_USER_STACK = 'stack'
+APEX_PKEY = '/root/.ssh/id_rsa'

 
 
 class KeystoneException(Exception):
 
 
 class KeystoneException(Exception):


@@ -64,53 +64,44 @@ class InvalidResponse(KeystoneException):
             "Invalid response", exc, response)
 
 
             "Invalid response", exc, response)
 
 

-class CeilometerClient(object):
-    """Ceilometer Client to authenticate and request meters"""
-    def __init__(self, bc_logger):
-        """
-        Keyword arguments:
-        bc_logger - logger instance
-        """
+class GnocchiClient(object):
+    # Gnocchi Client to authenticate and request meters
+    def __init__(self):

         self._auth_token = None
         self._auth_token = None

-        self._ceilometer_url = None
+        self._gnocchi_url = None

         self._meter_list = None
         self._meter_list = None

-        self._logger = bc_logger

 
     def auth_token(self):
 
     def auth_token(self):

-        """Get auth token"""
+        # Get auth token

         self._auth_server()
         return self._auth_token
 
         self._auth_server()
         return self._auth_token
 

-    def get_ceilometer_url(self):
-        """Get Ceilometer URL"""
-        return self._ceilometer_url
+    def get_gnocchi_url(self):
+        # Get Gnocchi  URL
+        return self._gnocchi_url

 
 

-    def get_ceil_metrics(self, criteria=None):
-        """Get Ceilometer metrics for given criteria
-
-        Keyword arguments:
-        criteria -- criteria for ceilometer meter list
-        """
+    def get_gnocchi_metrics(self, criteria=None):
+        # Subject to change if metric gathering is different for gnocchi

         self._request_meters(criteria)
         return self._meter_list
 
     def _auth_server(self):
         self._request_meters(criteria)
         return self._meter_list
 
     def _auth_server(self):

-        """Request token in authentication server"""
-        self._logger.debug('Connecting to the auth server {}'.format(os.environ['OS_AUTH_URL']))
+        # Request token in authentication server
+        logger.debug('Connecting to the auth server {}'.format(
+            os.environ['OS_AUTH_URL']))

         keystone = client.Client(username=os.environ['OS_USERNAME'],
                                  password=os.environ['OS_PASSWORD'],
         keystone = client.Client(username=os.environ['OS_USERNAME'],
                                  password=os.environ['OS_PASSWORD'],

-                                 tenant_name=os.environ['OS_TENANT_NAME'],
+                                 tenant_name=os.environ['OS_USERNAME'],

                                  auth_url=os.environ['OS_AUTH_URL'])
         self._auth_token = keystone.auth_token
         for service in keystone.service_catalog.get_data():
                                  auth_url=os.environ['OS_AUTH_URL'])
         self._auth_token = keystone.auth_token
         for service in keystone.service_catalog.get_data():

-            if service['name'] == CEILOMETER_NAME:
+            if service['name'] == GNOCCHI_NAME:

                 for service_type in service['endpoints']:
                     if service_type['interface'] == 'internal':
                 for service_type in service['endpoints']:
                     if service_type['interface'] == 'internal':

-                        self._ceilometer_url = service_type['url']
-                        break
+                        self._gnocchi_url = service_type['url']

 
 

-        if self._ceilometer_url is None:
-            self._logger.warning('Ceilometer is not registered in service catalog')
+        if self._gnocchi_url is None:
+            logger.warning('Gnocchi is not registered in service catalog')

 
     def _request_meters(self, criteria):
         """Request meter list values from ceilometer
 
     def _request_meters(self, criteria):
         """Request meter list values from ceilometer


@@ -119,9 +110,10 @@ class CeilometerClient(object):
         criteria -- criteria for ceilometer meter list
         """
         if criteria is None:
         criteria -- criteria for ceilometer meter list
         """
         if criteria is None:

-            url = self._ceilometer_url + ('/v2/samples?limit=400')
+            url = self._gnocchi_url + ('/v3/resource?limit=400')

         else:
         else:

-            url = self._ceilometer_url + ('/v2/meters/%s?q.field=resource_id&limit=400' % criteria)
+            url = self._gnocchi_url \
+                + ('/v3/resource/%s?q.field=resource_id&limit=400' % criteria)

         headers = {'X-Auth-Token': self._auth_token}
         resp = requests.get(url, headers=headers)
         try:
         headers = {'X-Auth-Token': self._auth_token}
         resp = requests.get(url, headers=headers)
         try:


@@ -133,16 +125,15 @@ class CeilometerClient(object):
 
 class CSVClient(object):
     """Client to request CSV meters"""
 
 class CSVClient(object):
     """Client to request CSV meters"""

-    def __init__(self, bc_logger, conf):
+    def __init__(self, conf):

         """
         Keyword arguments:
         """
         Keyword arguments:

-        bc_logger - logger instance

         conf -- ConfigServer instance
         """
         conf -- ConfigServer instance
         """

-        self._logger = bc_logger

         self.conf = conf
 
         self.conf = conf
 

-    def get_csv_metrics(self, compute_node, plugin_subdirectories, meter_categories):
+    def get_csv_metrics(
+            self, compute_node, plugin_subdirectories, meter_categories):

         """Get CSV metrics.
 
         Keyword arguments:
         """Get CSV metrics.
 
         Keyword arguments:


@@ -152,34 +143,48 @@ class CSVClient(object):
 
         Return list of metrics.
         """
 
         Return list of metrics.
         """

-        stdout = self.conf.execute_command("date '+%Y-%m-%d'", compute_node.get_ip())
+        stdout = self.conf.execute_command(
+            "date '+%Y-%m-%d'", compute_node.get_ip())

         date = stdout[0].strip()
         metrics = []
         for plugin_subdir in plugin_subdirectories:
             for meter_category in meter_categories:
                 stdout = self.conf.execute_command(
         date = stdout[0].strip()
         metrics = []
         for plugin_subdir in plugin_subdirectories:
             for meter_category in meter_categories:
                 stdout = self.conf.execute_command(

-                    "tail -2 /var/lib/collectd/csv/node-"
-                    + "{0}.domain.tld/{1}/{2}-{3}".format(
-                        compute_node.get_id(), plugin_subdir, meter_category, date),
+                    "tail -2 /var/lib/collectd/csv/"
+                    + "{0}.jf.intel.com/{1}/{2}-{3}".format(
+                        compute_node.get_name(), plugin_subdir, meter_category,
+                        date),

                     compute_node.get_ip())
                 # Storing last two values
                 values = stdout
                 if len(values) < 2:
                     compute_node.get_ip())
                 # Storing last two values
                 values = stdout
                 if len(values) < 2:

-                    self._logger.error(
+                    logger.error(

                         'Getting last two CSV entries of meter category '
                         'Getting last two CSV entries of meter category '

-                        + '{0} in {1} subdir failed'.format(meter_category, plugin_subdir))
+                        + '{0} in {1} subdir failed'.format(
+                            meter_category, plugin_subdir))

                 else:
                     old_value = int(values[0][0:values[0].index('.')])
                     new_value = int(values[1][0:values[1].index('.')])
                 else:
                     old_value = int(values[0][0:values[0].index('.')])
                     new_value = int(values[1][0:values[1].index('.')])

-                    metrics.append((plugin_subdir, meter_category, old_value, new_value))
+                    metrics.append((
+                        plugin_subdir, meter_category, old_value, new_value))

         return metrics
 
 
         return metrics
 
 

-def _check_logger():
-    """Check whether there is global logger available and if not, define one."""
-    if 'logger' not in globals():
-        global logger
-        logger = logger.Logger("barometercollectd").getLogger()
+def get_csv_categories_for_ipmi(conf, compute_node):
+    """Get CSV metrics.
+
+    Keyword arguments:
+    compute_node -- compute node instance
+
+    Return list of categories.
+    """
+    stdout = conf.execute_command(
+        "date '+%Y-%m-%d'", compute_node.get_ip())
+    date = stdout[0].strip()
+    categories = conf.execute_command(
+        "ls /var/lib/collectd/csv/{0}.jf.intel.com/ipmi | grep {1}".format(
+            compute_node.get_name(), date), compute_node.get_ip())
+    return [category.strip()[:-11] for category in categories]

 
 
 def _process_result(compute_node, test, result, results_list):
 
 
 def _process_result(compute_node, test, result, results_list):


@@ -191,9 +196,13 @@ def _process_result(compute_node, test, result, results_list):
     results_list -- results list
     """
     if result:
     results_list -- results list
     """
     if result:

-        logger.info('Compute node {0} test case {1} PASSED.'.format(compute_node, test))
+        logger.info(
+            'Compute node {0} test case {1} PASSED.'.format(
+                compute_node, test))

     else:
     else:

-        logger.error('Compute node {0} test case {1} FAILED.'.format(compute_node, test))
+        logger.error(
+            'Compute node {0} test case {1} FAILED.'.format(
+                compute_node, test))

     results_list.append((compute_node, test, result))
 
 
     results_list.append((compute_node, test, result))
 
 


@@ -215,17 +224,19 @@ def _print_label(label):
     logger.info(('=' * length1) + label + ('=' * length2))
 
 
     logger.info(('=' * length1) + label + ('=' * length2))
 
 

-def _print_plugin_label(plugin, node_id):
+def _print_plugin_label(plugin, node_name):

     """Print plug-in label.
 
     Keyword arguments:
     plugin -- plug-in name
     node_id -- node ID
     """
     """Print plug-in label.
 
     Keyword arguments:
     plugin -- plug-in name
     node_id -- node ID
     """

-    _print_label('Node {0}: Plug-in {1} Test case execution'.format(node_id, plugin))
+    _print_label(
+        'Node {0}: Plug-in {1} Test case execution'.format(node_name, plugin))

 
 
 
 

-def _print_final_result_of_plugin(plugin, compute_ids, results, out_plugins, out_plugin):
+def _print_final_result_of_plugin(
+        plugin, compute_ids, results, out_plugins, out_plugin):

     """Print final results of plug-in.
 
     Keyword arguments:
     """Print final results of plug-in.
 
     Keyword arguments:


@@ -240,11 +251,12 @@ def _print_final_result_of_plugin(plugin, compute_ids, results, out_plugins, out
         if out_plugins[id] == out_plugin:
             if (id, plugin, True) in results:
                 print_line += ' PASS   |'
         if out_plugins[id] == out_plugin:
             if (id, plugin, True) in results:
                 print_line += ' PASS   |'

-            elif (id, plugin, False) in results and out_plugins[id] == out_plugin:
+            elif (id, plugin, False) in results \
+                    and out_plugins[id] == out_plugin:

                 print_line += ' FAIL   |'
             else:
                 print_line += ' NOT EX |'
                 print_line += ' FAIL   |'
             else:
                 print_line += ' NOT EX |'

-        elif out_plugin == 'Ceilometer':
+        elif out_plugin == 'Gnocchi':

             print_line += ' NOT EX |'
         else:
             print_line += ' SKIP   |'
             print_line += ' NOT EX |'
         else:
             print_line += ' SKIP   |'


@@ -260,34 +272,50 @@ def print_overall_summary(compute_ids, tested_plugins, results, out_plugins):
     results -- results list
     out_plugins --  list of used out plug-ins
     """
     results -- results list
     out_plugins --  list of used out plug-ins
     """

-    compute_node_names = ['Node-{}'.format(id) for id in compute_ids]
+    compute_node_names = ['Node-{}'.format(i) for i in range(
+        len((compute_ids)))]
+    # compute_node_names = ['Node-{}'.format(id) for id in compute_ids]

     all_computes_in_line = ''
     for compute in compute_node_names:
     all_computes_in_line = ''
     for compute in compute_node_names:

-        all_computes_in_line = all_computes_in_line + '| ' + compute + (' ' * (7 - len(compute)))
+        all_computes_in_line += '| ' + compute + (' ' * (7 - len(compute)))

     line_of_nodes = '| Test           ' + all_computes_in_line + '|'
     logger.info('=' * 70)
     logger.info('+' + ('-' * ((9 * len(compute_node_names))+16)) + '+')
     logger.info(
     line_of_nodes = '| Test           ' + all_computes_in_line + '|'
     logger.info('=' * 70)
     logger.info('+' + ('-' * ((9 * len(compute_node_names))+16)) + '+')
     logger.info(

-        '|' + ' ' * ((9*len(compute_node_names))/2) + ' OVERALL SUMMARY'
-        + ' ' * (9*len(compute_node_names) - (9*len(compute_node_names))/2) + '|')
-    logger.info('+' + ('-' * 16) + '+' + (('-' * 8) + '+') * len(compute_node_names))
+        '|' + ' ' * ((9*len(compute_node_names))/2)
+        + ' OVERALL SUMMARY'
+        + ' ' * (
+            9*len(compute_node_names) - (9*len(compute_node_names))/2)
+        + '|')
+    logger.info(
+        '+' + ('-' * 16) + '+' + (('-' * 8) + '+') * len(compute_node_names))

     logger.info(line_of_nodes)
     logger.info(line_of_nodes)

-    logger.info('+' + ('-' * 16) + '+' + (('-' * 8) + '+') * len(compute_node_names))
-    out_plugins_print = ['Ceilometer']
+    logger.info(
+        '+' + ('-' * 16) + '+' + (('-' * 8) + '+') * len(compute_node_names))
+    out_plugins_print = ['Gnocchi']
+    if 'SNMP' in out_plugins.values():
+        out_plugins_print.append('SNMP')

     if 'CSV' in out_plugins.values():
         out_plugins_print.append('CSV')
     for out_plugin in out_plugins_print:
         output_plugins_line = ''
         for id in compute_ids:
             out_plugin_result = '----'
     if 'CSV' in out_plugins.values():
         out_plugins_print.append('CSV')
     for out_plugin in out_plugins_print:
         output_plugins_line = ''
         for id in compute_ids:
             out_plugin_result = '----'

-            if out_plugin == 'Ceilometer':
-                out_plugin_result = 'PASS' if out_plugins[id] == out_plugin else 'FAIL'
+            if out_plugin == 'Gnocchi':
+                out_plugin_result = \
+                    'PASS' if out_plugins[id] == out_plugin else 'FAIL'
+            if out_plugin == 'SNMP':
+                if out_plugins[id] == out_plugin:
+                    out_plugin_result = \
+                        'PASS' if out_plugins[id] == out_plugin else 'FAIL'
+                else:
+                    out_plugin_result = 'SKIP'

             if out_plugin == 'CSV':
                 if out_plugins[id] == out_plugin:
                     out_plugin_result = \
                         'PASS' if [
             if out_plugin == 'CSV':
                 if out_plugins[id] == out_plugin:
                     out_plugin_result = \
                         'PASS' if [

-                            plugin for comp_id, plugin,
-                            res in results if comp_id == id and res] else 'FAIL'
+                            plugin for comp_id, plugin, res in results
+                            if comp_id == id and res] else 'FAIL'

                 else:
                     out_plugin_result = 'SKIP'
             output_plugins_line += '| ' + out_plugin_result + '   '
                 else:
                     out_plugin_result = 'SKIP'
             output_plugins_line += '| ' + out_plugin_result + '   '


@@ -297,13 +325,17 @@ def print_overall_summary(compute_ids, tested_plugins, results, out_plugins):
         for plugin in sorted(tested_plugins.values()):
             line_plugin = _print_final_result_of_plugin(
                 plugin, compute_ids, results, out_plugins, out_plugin)
         for plugin in sorted(tested_plugins.values()):
             line_plugin = _print_final_result_of_plugin(
                 plugin, compute_ids, results, out_plugins, out_plugin)

-            logger.info('|  IN:{}'.format(plugin) + (' ' * (11-len(plugin))) + '|' + line_plugin)
-        logger.info('+' + ('-' * 16) + '+' + (('-' * 8) + '+') * len(compute_node_names))
+            logger.info(
+                '|  IN:{}'.format(plugin) + (' ' * (11-len(plugin)))
+                + '|' + line_plugin)
+        logger.info(
+            '+' + ('-' * 16) + '+'
+            + (('-' * 8) + '+') * len(compute_node_names))

     logger.info('=' * 70)
 
 
 def _exec_testcase(
     logger.info('=' * 70)
 
 
 def _exec_testcase(

-        test_labels, name, ceilometer_running, compute_node,
+        test_labels, name, gnocchi_running, compute_node,

         conf, results, error_plugins):
     """Execute the testcase.
 
         conf, results, error_plugins):
     """Execute the testcase.
 


@@ -314,7 +346,8 @@ def _exec_testcase(
     compute_node -- compute node ID
     conf -- ConfigServer instance
     results -- results list
     compute_node -- compute node ID
     conf -- ConfigServer instance
     results -- results list

-    error_plugins -- list of tuples with plug-in errors (plugin, error_description, is_critical):
+    error_plugins -- list of tuples with plug-in errors
+        (plugin, error_description, is_critical):

         plugin -- plug-in ID, key of test_labels dictionary
         error_decription -- description of the error
         is_critical -- boolean value indicating whether error is critical
         plugin -- plug-in ID, key of test_labels dictionary
         error_decription -- description of the error
         is_critical -- boolean value indicating whether error is critical


@@ -322,46 +355,94 @@ def _exec_testcase(
     ovs_interfaces = conf.get_ovs_interfaces(compute_node)
     ovs_configured_interfaces = conf.get_plugin_config_values(
         compute_node, 'ovs_events', 'Interfaces')
     ovs_interfaces = conf.get_ovs_interfaces(compute_node)
     ovs_configured_interfaces = conf.get_plugin_config_values(
         compute_node, 'ovs_events', 'Interfaces')

+    ovs_configured_bridges = conf.get_plugin_config_values(
+         compute_node, 'ovs_stats', 'Bridges')

     ovs_existing_configured_int = [
         interface for interface in ovs_interfaces
         if interface in ovs_configured_interfaces]
     ovs_existing_configured_int = [
         interface for interface in ovs_interfaces
         if interface in ovs_configured_interfaces]

+    ovs_existing_configured_bridges = [
+        bridge for bridge in ovs_interfaces
+        if bridge in ovs_configured_bridges]

     plugin_prerequisites = {
     plugin_prerequisites = {

-        'mcelog': [(conf.is_installed(compute_node, 'mcelog'), 'mcelog must be installed.')],
+        'intel_rdt': [(
+            conf.is_libpqos_on_node(compute_node),
+            'libpqos must be installed.')],
+        'mcelog': [(
+            conf.is_installed(compute_node, 'mcelog'),
+            'mcelog must be installed.')],

         'ovs_events': [(
             len(ovs_existing_configured_int) > 0 or len(ovs_interfaces) > 0,
         'ovs_events': [(
             len(ovs_existing_configured_int) > 0 or len(ovs_interfaces) > 0,

-            'Interfaces must be configured.')]}
+            'Interfaces must be configured.')],
+        'ovs_stats': [(
+            len(ovs_existing_configured_bridges) > 0,
+            'Bridges must be configured.')]}

     ceilometer_criteria_lists = {
     ceilometer_criteria_lists = {

+        'intel_rdt': [
+            'intel_rdt.ipc', 'intel_rdt.bytes',
+            'intel_rdt.memory_bandwidth'],

         'hugepages': ['hugepages.vmpage_number'],
         'hugepages': ['hugepages.vmpage_number'],

+        'ipmi': ['ipmi.temperature', 'ipmi.voltage'],

         'mcelog': ['mcelog.errors'],
         'mcelog': ['mcelog.errors'],

+        'ovs_stats': ['interface.if_packets'],

         'ovs_events': ['ovs_events.gauge']}
     ceilometer_substr_lists = {
         'ovs_events': ['ovs_events.gauge']}
     ceilometer_substr_lists = {

-        'ovs_events': ovs_existing_configured_int if len(ovs_existing_configured_int) > 0 else ovs_interfaces}
+        'ovs_events': ovs_existing_configured_int if len(
+            ovs_existing_configured_int) > 0 else ovs_interfaces}

     csv_subdirs = {
     csv_subdirs = {

+        'intel_rdt': [
+            'intel_rdt-{}'.format(core)
+            for core in conf.get_plugin_config_values(
+                compute_node, 'intel_rdt', 'Cores')],

         'hugepages': [
         'hugepages': [

-            'hugepages-mm-2048Kb', 'hugepages-node0-2048Kb', 'hugepages-node1-2048Kb',
-            'hugepages-mm-1048576Kb', 'hugepages-node0-1048576Kb', 'hugepages-node1-1048576Kb'],
-        'mcelog': ['mcelog-SOCKET_0_CHANNEL_0_DIMM_any', 'mcelog-SOCKET_0_CHANNEL_any_DIMM_any'],
+            'hugepages-mm-2048Kb', 'hugepages-node0-2048Kb',
+            'hugepages-node1-2048Kb', 'hugepages-mm-1048576Kb',
+            'hugepages-node0-1048576Kb', 'hugepages-node1-1048576Kb'],
+        'ipmi': ['ipmi'],
+        'mcelog': [
+            'mcelog-SOCKET_0_CHANNEL_0_DIMM_any',
+            'mcelog-SOCKET_0_CHANNEL_any_DIMM_any'],
+        'ovs_stats': [
+            'ovs_stats-{0}.{0}'.format(interface)
+            for interface in ovs_existing_configured_bridges],

         'ovs_events': [
             'ovs_events-{}'.format(interface)
         'ovs_events': [
             'ovs_events-{}'.format(interface)

-            for interface in (ovs_existing_configured_int if len(ovs_existing_configured_int) > 0 else ovs_interfaces)]}
+            for interface in (
+                ovs_existing_configured_int
+                if len(ovs_existing_configured_int) > 0 else ovs_interfaces)]}
+    csv_meter_categories_ipmi = get_csv_categories_for_ipmi(conf, compute_node)

     csv_meter_categories = {
     csv_meter_categories = {

+        'intel_rdt': [
+            'bytes-llc', 'ipc', 'memory_bandwidth-local',
+            'memory_bandwidth-remote'],

         'hugepages': ['vmpage_number-free', 'vmpage_number-used'],
         'hugepages': ['vmpage_number-free', 'vmpage_number-used'],

+        'ipmi': csv_meter_categories_ipmi,

         'mcelog': [
         'mcelog': [

-            'errors-corrected_memory_errors', 'errors-uncorrected_memory_errors',
-            'errors-corrected_memory_errors_in_24h', 'errors-uncorrected_memory_errors_in_24h'],
+            'errors-corrected_memory_errors',
+            'errors-uncorrected_memory_errors',
+            'errors-corrected_memory_errors_in_24h',
+            'errors-uncorrected_memory_errors_in_24h'],
+        'ovs_stats': [
+            'if_collisions', 'if_dropped', 'if_errors', 'if_packets',
+            'if_rx_errors-crc', 'if_rx_errors-frame', 'if_rx_errors-over',
+            'if_rx_octets', 'if_tx_octets'],

         'ovs_events': ['gauge-link_status']}
 
         'ovs_events': ['gauge-link_status']}
 

-    _print_plugin_label(test_labels[name] if name in test_labels else name, compute_node.get_id())
+    _print_plugin_label(
+        test_labels[name] if name in test_labels else name,
+        compute_node.get_name())

     plugin_critical_errors = [
     plugin_critical_errors = [

-        error for plugin, error, critical in error_plugins if plugin == name and critical]
+        error for plugin, error, critical in error_plugins
+        if plugin == name and critical]

     if plugin_critical_errors:
         logger.error('Following critical errors occurred:'.format(name))
         for error in plugin_critical_errors:
             logger.error(' * ' + error)
     if plugin_critical_errors:
         logger.error('Following critical errors occurred:'.format(name))
         for error in plugin_critical_errors:
             logger.error(' * ' + error)

-        _process_result(compute_node.get_id(), test_labels[name], False, results)
+        _process_result(
+            compute_node.get_id(), test_labels[name], False, results)

     else:
         plugin_errors = [
     else:
         plugin_errors = [

-            error for plugin, error, critical in error_plugins if plugin == name and not critical]
+            error for plugin, error, critical in error_plugins
+            if plugin == name and not critical]

         if plugin_errors:
             logger.warning('Following non-critical errors occured:')
             for error in plugin_errors:
         if plugin_errors:
             logger.warning('Following non-critical errors occured:')
             for error in plugin_errors:


@@ -370,7 +451,8 @@ def _exec_testcase(
         if name in plugin_prerequisites:
             failed_prerequisites = [
                 prerequisite_name for prerequisite_passed,
         if name in plugin_prerequisites:
             failed_prerequisites = [
                 prerequisite_name for prerequisite_passed,

-                prerequisite_name in plugin_prerequisites[name] if not prerequisite_passed]
+                prerequisite_name in plugin_prerequisites[name]
+                if not prerequisite_passed]

         if failed_prerequisites:
             logger.error(
                 '{} test will not be executed, '.format(name)
         if failed_prerequisites:
             logger.error(
                 '{} test will not be executed, '.format(name)


@@ -378,86 +460,102 @@ def _exec_testcase(
             for prerequisite in failed_prerequisites:
                 logger.error(' * {}'.format(prerequisite))
         else:
             for prerequisite in failed_prerequisites:
                 logger.error(' * {}'.format(prerequisite))
         else:

-            if ceilometer_running:
-                res = test_ceilometer_node_sends_data(
-                    compute_node.get_id(), conf.get_plugin_interval(compute_node, name),
-                    logger=logger, client=CeilometerClient(logger),
+            if gnocchi_running:
+                res = conf.test_plugins_with_gnocchi(
+                    compute_node.get_id(),
+                    conf.get_plugin_interval(compute_node, name),
+                    logger, client=GnocchiClient(),

                     criteria_list=ceilometer_criteria_lists[name],
                     criteria_list=ceilometer_criteria_lists[name],

-                    resource_id_substrings=(ceilometer_substr_lists[name]
-                                            if name in ceilometer_substr_lists else ['']))
+                    resource_id_substrings=(
+                        ceilometer_substr_lists[name]
+                        if name in ceilometer_substr_lists else ['']))

             else:
             else:

-                res = test_csv_handles_plugin_data(
-                    compute_node, conf.get_plugin_interval(compute_node, name), name,
-                    csv_subdirs[name], csv_meter_categories[name], logger,
-                    CSVClient(logger, conf))
+                res = tests.test_csv_handles_plugin_data(
+                    compute_node, conf.get_plugin_interval(compute_node, name),
+                    name, csv_subdirs[name], csv_meter_categories[name],
+                    logger, CSVClient(conf))

             if res and plugin_errors:
                 logger.info(
                     'Test works, but will be reported as failure,'
                     + 'because of non-critical errors.')
                 res = False
             if res and plugin_errors:
                 logger.info(
                     'Test works, but will be reported as failure,'
                     + 'because of non-critical errors.')
                 res = False

-            _process_result(compute_node.get_id(), test_labels[name], res, results)
-
+            _process_result(
+                compute_node.get_id(), test_labels[name], res, results)

 
 

-def mcelog_install(logger):
-    """Install mcelog on compute nodes.

 
 

-    Keyword arguments:
-    logger - logger instance
+def get_results_for_ovs_events(
+        plugin_labels, plugin_name, gnocchi_running,
+        compute_node, conf, results, error_plugins):
+    """ Testing OVS Events with python plugin

     """
     """

+    plugin_label = 'OVS events'
+    res = conf.enable_ovs_events(
+        compute_node, plugin_label, error_plugins, create_backup=False)
+    _process_result(
+        compute_node.get_id(), plugin_label, res, results)
+    logger.info("Results for OVS Events = {}" .format(results))
+
+
+def mcelog_install():
+    """Install mcelog on compute nodes."""

     _print_label('Enabling mcelog on compute nodes')
     _print_label('Enabling mcelog on compute nodes')

-    handler = factory.Factory.get_handler('fuel', FUEL_IP, FUEL_USER, installer_pwd='')
+    handler = factory.Factory.get_handler('apex',
+                                          APEX_IP,
+                                          APEX_USER_STACK,
+                                          APEX_PKEY)

     nodes = handler.get_nodes()
     nodes = handler.get_nodes()

-    openstack_version = handler.get_openstack_version()
-    if openstack_version.find('14.') != 0:
-        logger.info('Mcelog will not be installed,'
-                    + ' unsupported Openstack version found ({}).'.format(openstack_version))
-    else:
-        for node in nodes:
-            if node.is_compute():
-                ubuntu_release = node.run_cmd('lsb_release -r')
-                if '16.04' not in ubuntu_release:
-                    logger.info('Mcelog will not be enabled'
-                                + 'on node-{0}, unsupported Ubuntu release found ({1}).'.format(
-                                node.get_dict()['id'], ubuntu_release))
-                else:
-                    logger.info('Checking if  mcelog is enabled on node-{}...'.format(
+    for node in nodes:
+        if node.is_compute():
+            centos_release = node.run_cmd('uname -r')
+            if '3.10.0-514.26.2.el7.x86_64' not in centos_release:
+                logger.info(
+                    'Mcelog will not be enabled '
+                    + 'on node-{0}, '.format(node.get_dict()['id'])
+                    + 'unsupported CentOS release found ({1}).'.format(
+                        centos_release))
+            else:
+                logger.info(
+                    'Checking if  mcelog is enabled'
+                    + ' on node-{}...'.format(node.get_dict()['id']))
+                res = node.run_cmd('ls')
+            if 'mce-inject_ea' and 'corrected' in res:
+                logger.info(
+                    'Mcelog seems to be already installed '
+                    + 'on node-{}.'.format(node.get_dict()['id']))
+                node.run_cmd('modprobe mce-inject_ea')
+                node.run_cmd('mce-inject_ea < corrected')
+            else:
+                logger.info(
+                    'Mcelog will be enabled on node-{}...'.format(

                         node.get_dict()['id']))
                         node.get_dict()['id']))

-                    res = node.run_cmd('ls /root/')
-                    if 'mce-inject_df' and 'corrected' in res:
-                        logger.info('Mcelog seems to be already installed on node-{}.'.format(
-                            node.get_dict()['id']))
-                        res = node.run_cmd('modprobe mce-inject')
-                        res = node.run_cmd('/root/mce-inject_df < /root/corrected')
-                    else:
-                        logger.info('Mcelog will be enabled on node-{}...'.format(
-                            node.get_dict()['id']))
-                        res = node.put_file('/home/opnfv/repos/barometer/baro_utils/mce-inject_df',
-                                            '/root/mce-inject_df')
-                        res = node.run_cmd('chmod a+x /root/mce-inject_df')
-                        res = node.run_cmd('echo "CPU 0 BANK 0" > /root/corrected')
-                        res = node.run_cmd('echo "STATUS 0xcc00008000010090" >> /root/corrected')
-                        res = node.run_cmd('echo "ADDR 0x0010FFFFFFF" >> /root/corrected')
-                        res = node.run_cmd('modprobe mce-inject')
-                        res = node.run_cmd('/root/mce-inject_df < /root/corrected')
-        logger.info('Mcelog is installed on all compute nodes')
-
-
-def mcelog_delete(logger):
-    """Uninstall mcelog from compute nodes.
-
-    Keyword arguments:
-    logger - logger instance
-    """
-    handler = factory.Factory.get_handler('fuel', FUEL_IP, FUEL_USER, installer_pwd='')
+                node.put_file(
+                    '/usr/local/lib/python2.7/dist-packages/baro_tests/'
+                    + 'mce-inject_ea', 'mce-inject_ea')
+                node.run_cmd('chmod a+x mce-inject_ea')
+                node.run_cmd('echo "CPU 0 BANK 0" > corrected')
+                node.run_cmd(
+                    'echo "STATUS 0xcc00008000010090" >>'
+                    + ' corrected')
+                node.run_cmd(
+                    'echo "ADDR 0x0010FFFFFFF" >> corrected')
+                node.run_cmd('modprobe mce-inject')
+                node.run_cmd('mce-inject_ea < corrected')
+    logger.info('Mcelog is installed on all compute nodes')
+
+
+def mcelog_delete():
+    """Uninstall mcelog from compute nodes."""
+    handler = factory.Factory.get_handler(
+            'apex', APEX_IP, APEX_USER, APEX_PKEY)

     nodes = handler.get_nodes()
     for node in nodes:
         if node.is_compute():
     nodes = handler.get_nodes()
     for node in nodes:
         if node.is_compute():

-            output = node.run_cmd('ls /root/')
-            if 'mce-inject_df' in output:
-                res = node.run_cmd('rm /root/mce-inject_df')
+            output = node.run_cmd('ls')
+            if 'mce-inject_ea' in output:
+                node.run_cmd('rm mce-inject_ea')

             if 'corrected' in output:
             if 'corrected' in output:

-                res = node.run_cmd('rm /root/corrected')
-            res = node.run_cmd('systemctl restart mcelog')
+                node.run_cmd('rm corrected')
+            node.run_cmd('systemctl restart mcelog')

     logger.info('Mcelog is deleted from all compute nodes')
 
 
     logger.info('Mcelog is deleted from all compute nodes')
 
 


@@ -465,16 +563,26 @@ def get_ssh_keys():
     if not os.path.isdir(ID_RSA_DST_DIR):
         os.makedirs(ID_RSA_DST_DIR)
     if not os.path.isfile(ID_RSA_DST):
     if not os.path.isdir(ID_RSA_DST_DIR):
         os.makedirs(ID_RSA_DST_DIR)
     if not os.path.isfile(ID_RSA_DST):

-        logger.info("RSA key file {} doesn't exist, it will be downloaded from installer node.".format(ID_RSA_DST))
-        handler = factory.Factory.get_handler('fuel', FUEL_IP, FUEL_USER, installer_pwd=FUEL_PW)
-        fuel = handler.get_installer_node()
-        fuel.get_file(ID_RSA_SRC, ID_RSA_DST)
+        logger.info(
+            "RSA key file {} doesn't exist".format(ID_RSA_DST)
+            + ", it will be downloaded from installer node.")
+        handler = factory.Factory.get_handler(
+            'apex', APEX_IP, APEX_USER, APEX_PKEY)
+        apex = handler.get_installer_node()
+        apex.get_file(ID_RSA_SRC, ID_RSA_DST)

     else:
         logger.info("RSA key file {} exists.".format(ID_RSA_DST))
 
 
     else:
         logger.info("RSA key file {} exists.".format(ID_RSA_DST))
 
 

+def _check_logger():
+    """Check whether there is global logger available and if not, define one."""
+    if 'logger' not in globals():
+        global logger
+        logger = logger.Logger("barometercollectd").getLogger()
+
+

 def main(bt_logger=None):
 def main(bt_logger=None):

-    """Check each compute node sends ceilometer metrics.
+    """Check each compute node sends gnocchi metrics.

 
     Keyword arguments:
     bt_logger -- logger instance
 
     Keyword arguments:
     bt_logger -- logger instance


@@ -487,8 +595,9 @@ def main(bt_logger=None):
     else:
         global logger
         logger = bt_logger
     else:
         global logger
         logger = bt_logger

+    _print_label("Starting barometer tests suite")

     get_ssh_keys()
     get_ssh_keys()

-    conf = ConfigServer(FUEL_IP, FUEL_USER, logger)
+    conf = config_server.ConfigServer(APEX_IP, APEX_USER, logger)

     controllers = conf.get_controllers()
     if len(controllers) == 0:
         logger.error('No controller nodes found!')
     controllers = conf.get_controllers()
     if len(controllers) == 0:
         logger.error('No controller nodes found!')


@@ -498,89 +607,120 @@ def main(bt_logger=None):
         logger.error('No compute nodes found!')
         return 1
 
         logger.error('No compute nodes found!')
         return 1
 

-    _print_label('Display of Control and Compute nodes available in the set up')
+    _print_label(
+        'Display of Control and Compute nodes available in the set up')

     logger.info('controllers: {}'.format([('{0}: {1} ({2})'.format(
     logger.info('controllers: {}'.format([('{0}: {1} ({2})'.format(

-        node.get_id(), node.get_name(), node.get_ip())) for node in controllers]))
+        node.get_id(), node.get_name(),
+        node.get_ip())) for node in controllers]))

     logger.info('computes: {}'.format([('{0}: {1} ({2})'.format(
     logger.info('computes: {}'.format([('{0}: {1} ({2})'.format(

-        node.get_id(), node.get_name(), node.get_ip())) for node in computes]))
+        node.get_id(), node.get_name(), node.get_ip()))
+        for node in computes]))

 
 

-    mcelog_install(logger)  # installation of mcelog
+    mcelog_install()
+    gnocchi_running_on_con = False
+    _print_label('Test Gnocchi on controller nodes')

 
 

-    ceilometer_running_on_con = False
-    _print_label('Test Ceilometer on control nodes')

     for controller in controllers:
     for controller in controllers:

-        ceil_client = CeilometerClient(logger)
-        ceil_client.auth_token()
-        ceilometer_running_on_con = (
-            ceilometer_running_on_con or conf.is_ceilometer_running(controller))
-    if ceilometer_running_on_con:
-        logger.info("Ceilometer is running on control node.")
+        logger.info("Controller = {}" .format(controller))
+        gnocchi_client = GnocchiClient()
+        gnocchi_client.auth_token()
+        gnocchi_running_on_con = (
+            gnocchi_running_on_con or conf.is_gnocchi_running(
+                controller))
+    if gnocchi_running_on_con:
+        logger.info("Gnocchi is running on controller.")

     else:
     else:

-        logger.error("Ceilometer is not running on control node.")
+        logger.error("Gnocchi is not running on controller.")

         logger.info("CSV will be enabled on compute nodes.")
         logger.info("CSV will be enabled on compute nodes.")

+

     compute_ids = []
     compute_ids = []

+    compute_node_names = []

     results = []
     plugin_labels = {
     results = []
     plugin_labels = {

+        'intel_rdt': 'Intel RDT',

         'hugepages': 'Hugepages',
         'hugepages': 'Hugepages',

+        # 'ipmi': 'IPMI',

         'mcelog': 'Mcelog',
         'mcelog': 'Mcelog',

+        'ovs_stats': 'OVS stats',

         'ovs_events': 'OVS events'}
     out_plugins = {}
     for compute_node in computes:
         node_id = compute_node.get_id()
         'ovs_events': 'OVS events'}
     out_plugins = {}
     for compute_node in computes:
         node_id = compute_node.get_id()

+        node_name = compute_node.get_name()

         out_plugins[node_id] = 'CSV'
         compute_ids.append(node_id)
         out_plugins[node_id] = 'CSV'
         compute_ids.append(node_id)

-        # plugins_to_enable = plugin_labels.keys()
+        compute_node_names.append(node_name)

         plugins_to_enable = []
         plugins_to_enable = []

-        _print_label('NODE {}: Test Ceilometer Plug-in'.format(node_id))
-        logger.info('Checking if ceilometer plug-in is included.')
-        if not conf.check_ceil_plugin_included(compute_node):
-            logger.error('Ceilometer plug-in is not included.')
-            logger.info('Testcases on node {} will not be executed'.format(node_id))
+        _print_label('NODE {}: Test Gnocchi Plug-in'.format(node_name))
+        logger.info('Checking if gnocchi plug-in is included in compute nodes.')
+        if not conf.check_gnocchi_plugin_included(compute_node):
+            logger.error('Gnocchi plug-in is not included.')
+            logger.info(
+                'Testcases on node {} will not be executed'.format(node_name))

         else:
         else:

-            collectd_restarted, collectd_warnings = conf.restart_collectd(compute_node)
-            sleep_time = 30
-            logger.info('Sleeping for {} seconds after collectd restart...'.format(sleep_time))
+            collectd_restarted, collectd_warnings = \
+                conf.restart_collectd(compute_node)
+            sleep_time = 5
+            logger.info(
+                'Sleeping for {} seconds after collectd restart...'.format(
+                    sleep_time))

             time.sleep(sleep_time)
             if not collectd_restarted:
                 for warning in collectd_warnings:
                     logger.warning(warning)
             time.sleep(sleep_time)
             if not collectd_restarted:
                 for warning in collectd_warnings:
                     logger.warning(warning)

-                logger.error('Restart of collectd on node {} failed'.format(node_id))
-                logger.info('Testcases on node {} will not be executed'.format(node_id))
+                logger.error(
+                    'Restart of collectd on node {} failed'.format(node_name))
+                logger.info(
+                    'Testcases on node {} will not be executed'.format(
+                        node_name))

             else:
                 for warning in collectd_warnings:
                     logger.warning(warning)
             else:
                 for warning in collectd_warnings:
                     logger.warning(warning)

-                ceilometer_running = (
-                    ceilometer_running_on_con and test_ceilometer_node_sends_data(
-                        node_id, 10, logger=logger, client=CeilometerClient(logger)))
-                if ceilometer_running:
-                    out_plugins[node_id] = 'Ceilometer'
-                    logger.info("Ceilometer is running.")
+                gnocchi_running = (
+                    gnocchi_running_on_con
+                    and conf.test_gnocchi_is_sending_data(
+                        controller))
+                if gnocchi_running:
+                    out_plugins[node_id] = 'Gnocchi'
+                    logger.info("Gnocchi is active and collecting data")

                 else:
                     plugins_to_enable.append('csv')
                     out_plugins[node_id] = 'CSV'
                 else:
                     plugins_to_enable.append('csv')
                     out_plugins[node_id] = 'CSV'

-                    logger.error("Ceilometer is not running.")
-                    logger.info("CSV will be enabled for verification of test plugins.")
+                    logger.error("Gnocchi is inactive and not collecting data")
+                    logger.info(
+                        "CSV will be enabled for verification "
+                        + "of test plugins.")

                 if plugins_to_enable:
                     _print_label(
                 if plugins_to_enable:
                     _print_label(

-                        'NODE {}: Enabling Test Plug-in '.format(node_id)
+                        'NODE {}: Enabling Test Plug-in '.format(node_name)

                         + 'and Test case execution')
                 error_plugins = []
                 if plugins_to_enable and not conf.enable_plugins(
                         + 'and Test case execution')
                 error_plugins = []
                 if plugins_to_enable and not conf.enable_plugins(

-                        compute_node, plugins_to_enable, error_plugins, create_backup=False):
-                    logger.error('Failed to test plugins on node {}.'.format(node_id))
-                    logger.info('Testcases on node {} will not be executed'.format(node_id))
+                        compute_node, plugins_to_enable, error_plugins,
+                        create_backup=False):
+                    logger.error(
+                        'Failed to test plugins on node {}.'.format(node_id))
+                    logger.info(
+                        'Testcases on node {} will not be executed'.format(
+                            node_id))

                 else:
                     if plugins_to_enable:
                 else:
                     if plugins_to_enable:

-                        collectd_restarted, collectd_warnings = conf.restart_collectd(compute_node)
+                        collectd_restarted, collectd_warnings = \
+                            conf.restart_collectd(compute_node)

                         sleep_time = 30
                         logger.info(
                         sleep_time = 30
                         logger.info(

-                            'Sleeping for {} seconds after collectd restart...'.format(sleep_time))
+                            'Sleeping for {} seconds'.format(sleep_time)
+                            + ' after collectd restart...')

                         time.sleep(sleep_time)
                     if plugins_to_enable and not collectd_restarted:
                         for warning in collectd_warnings:
                             logger.warning(warning)
                         time.sleep(sleep_time)
                     if plugins_to_enable and not collectd_restarted:
                         for warning in collectd_warnings:
                             logger.warning(warning)

-                        logger.error('Restart of collectd on node {} failed'.format(node_id))
-                        logger.info('Testcases on node {} will not be executed'.format(node_id))
+                        logger.error(
+                            'Restart of collectd on node {} failed'.format(
+                                node_id))
+                        logger.info(
+                            'Testcases on node {}'.format(node_id)
+                            + ' will not be executed.')

                     else:
                         if collectd_warnings:
                             for warning in collectd_warnings:
                     else:
                         if collectd_warnings:
                             for warning in collectd_warnings:


@@ -588,14 +728,13 @@ def main(bt_logger=None):
 
                         for plugin_name in sorted(plugin_labels.keys()):
                             _exec_testcase(
 
                         for plugin_name in sorted(plugin_labels.keys()):
                             _exec_testcase(

-                                plugin_labels, plugin_name, ceilometer_running,
+                                plugin_labels, plugin_name,
+                                gnocchi_running,

                                 compute_node, conf, results, error_plugins)
 
                                 compute_node, conf, results, error_plugins)
 

-            _print_label('NODE {}: Restoring config file'.format(node_id))
+            _print_label('NODE {}: Restoring config file'.format(node_name))

             conf.restore_config(compute_node)
             conf.restore_config(compute_node)

-
-    mcelog_delete(logger)  # uninstalling mcelog from compute nodes
-
+        mcelog_delete()

     print_overall_summary(compute_ids, plugin_labels, results, out_plugins)
 
     if ((len([res for res in results if not res[2]]) > 0)
     print_overall_summary(compute_ids, plugin_labels, results, out_plugins)
 
     if ((len([res for res in results if not res[2]]) > 0)

diff --git a/baro_tests/config_server.py b/baro_tests/config_server.py
index 358a8ff..efe2691 100644 (file)
--- a/baro_tests/config_server.py
+++ b/baro_tests/config_server.py
@@ -1,7 +1,6 @@
-"""Classes used by client.py"""

 # -*- coding: utf-8 -*-
 
 # -*- coding: utf-8 -*-
 

-#Licensed under the Apache License, Version 2.0 (the "License"); you may
+# 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
 #
 # not use this file except in compliance with the License. You may obtain
 # a copy of the License at
 #


@@ -13,31 +12,33 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
 # License for the specific language governing permissions and limitations
 # under the License.
 

+"""Classes used by collectd.py"""
+

 import paramiko
 import time
 import string
 import os.path
 import paramiko
 import time
 import string
 import os.path

-
+import os
+import re

 ID_RSA_PATH = '/home/opnfv/.ssh/id_rsa'
 SSH_KEYS_SCRIPT = '/home/opnfv/barometer/baro_utils/get_ssh_keys.sh'
 DEF_PLUGIN_INTERVAL = 10
 ID_RSA_PATH = '/home/opnfv/.ssh/id_rsa'
 SSH_KEYS_SCRIPT = '/home/opnfv/barometer/baro_utils/get_ssh_keys.sh'
 DEF_PLUGIN_INTERVAL = 10

-COLLECTD_CONF = '/etc/collectd/collectd.conf'
+COLLECTD_CONF = '/etc/collectd.conf'

 COLLECTD_CONF_DIR = '/etc/collectd/collectd.conf.d'
 COLLECTD_CONF_DIR = '/etc/collectd/collectd.conf.d'

+NOTIFICATION_FILE = '/var/log/python-notifications.dump'
+COLLECTD_NOTIFICATION = '/etc/collectd_notification_dump.py'

 
 
 class Node(object):
     """Node configuration class"""
     def __init__(self, attrs):
 
 
 class Node(object):
     """Node configuration class"""
     def __init__(self, attrs):

-        self.__id = int(attrs[0])
-        self.__status = attrs[1]
+        self.__null = attrs[0]
+        self.__id = attrs[1]

         self.__name = attrs[2]
         self.__name = attrs[2]

-        self.__cluster = int(attrs[3]) if attrs[3] else None
-        self.__ip = attrs[4]
-        self.__mac = attrs[5]
-        self.__roles = [x.strip(' ') for x in attrs[6].split(',')]
-        self.__pending_roles = attrs[7]
-        self.__online = int(attrs[8]) if attrs[3] and attrs[8]else None
-        self.__group_id = int(attrs[9]) if attrs[3] else None
+        self.__status = attrs[3] if attrs[3] else None
+        self.__taskState = attrs[4]
+        self.__pwrState = attrs[5]
+        self.__ip = re.sub('^[a-z]+=', '', attrs[6])

 
     def get_name(self):
         """Get node name"""
 
     def get_name(self):
         """Get node name"""


@@ -52,68 +53,84 @@ class Node(object):
         return self.__ip
 
     def get_roles(self):
         return self.__ip
 
     def get_roles(self):

-        """Get node roles"""
+        """Get node role"""

         return self.__roles
 
 
 class ConfigServer(object):
     """Class to get env configuration"""
         return self.__roles
 
 
 class ConfigServer(object):
     """Class to get env configuration"""

-    def __init__(self, host, user, logger, passwd=None):
+    def __init__(self, host, user, logger, priv_key=None):

         self.__host = host
         self.__user = user
         self.__host = host
         self.__user = user

-        self.__passwd = passwd
-        self.__priv_key = None
+        self.__passwd = None
+        self.__priv_key = priv_key

         self.__nodes = list()
         self.__logger = logger
 
         self.__private_key_file = ID_RSA_PATH
         if not os.path.isfile(self.__private_key_file):
             self.__logger.error(
         self.__nodes = list()
         self.__logger = logger
 
         self.__private_key_file = ID_RSA_PATH
         if not os.path.isfile(self.__private_key_file):
             self.__logger.error(

-                "Private key file '{}' not found.".format(self.__private_key_file))
-            raise IOError("Private key file '{}' not found.".format(self.__private_key_file))
+                "Private key file '{}'".format(self.__private_key_file)
+                + " not found.")
+            raise IOError("Private key file '{}' not found.".format(
+                self.__private_key_file))

 
         # get list of available nodes
 
         # get list of available nodes

-        ssh, sftp = self.__open_sftp_session(self.__host, self.__user, self.__passwd)
+        ssh, sftp = self.__open_sftp_session(
+            self.__host, self.__user, self.__passwd)

         attempt = 1
         fuel_node_passed = False
 
         while (attempt <= 10) and not fuel_node_passed:
         attempt = 1
         fuel_node_passed = False
 
         while (attempt <= 10) and not fuel_node_passed:

-            stdin, stdout, stderr = ssh.exec_command("fuel node")
+            stdin, stdout, stderr = ssh.exec_command(
+                "source stackrc; nova list")

             stderr_lines = stderr.readlines()
             if stderr_lines:
             stderr_lines = stderr.readlines()
             if stderr_lines:

-                self.__logger.warning("'fuel node' command failed (try {}):".format(attempt))
+                self.__logger.warning(
+                    "'fuel node' command failed (try {}):".format(attempt))

                 for line in stderr_lines:
                     self.__logger.debug(line.strip())
             else:
                 fuel_node_passed = True
                 if attempt > 1:
                 for line in stderr_lines:
                     self.__logger.debug(line.strip())
             else:
                 fuel_node_passed = True
                 if attempt > 1:

-                    self.__logger.info("'fuel node' command passed (try {})".format(attempt))
+                    self.__logger.info(
+                        "'fuel node' command passed (try {})".format(attempt))

             attempt += 1
         if not fuel_node_passed:
             attempt += 1
         if not fuel_node_passed:

-            self.__logger.error("'fuel node' command failed. This was the last try.")
-            raise OSError("'fuel node' command failed. This was the last try.")
+            self.__logger.error(
+                "'fuel node' command failed. This was the last try.")
+            raise OSError(
+                "'fuel node' command failed. This was the last try.")

         node_table = stdout.readlines()\
 
         # skip table title and parse table values
         node_table = stdout.readlines()\
 
         # skip table title and parse table values

-        for entry in node_table[2:]:
-            self.__nodes.append(Node([str(x.strip(' \n')) for x in entry.split('|')]))
+
+        for entry in node_table[3:]:
+            if entry[0] == '+' or entry[0] == '\n':
+                print entry
+                pass
+            else:
+                self.__nodes.append(
+                    Node([str(x.strip(' \n')) for x in entry.split('|')]))

 
     def get_controllers(self):
 
     def get_controllers(self):

-        """Get list of controllers"""
-        return [node for node in self.__nodes if 'controller' in node.get_roles()]
+        # Get list of controllers
+        print self.__nodes[0]._Node__ip
+        return (
+            [node for node in self.__nodes if 'controller' in node.get_name()])

 
     def get_computes(self):
 
     def get_computes(self):

-        """Get list of computes"""
-        return [node for node in self.__nodes if 'compute' in node.get_roles()]
+        # Get list of computes
+        return (
+            [node for node in self.__nodes if 'compute' in node.get_name()])

 
     def get_nodes(self):
 
     def get_nodes(self):

-        """Get list of nodes"""
+        # Get list of nodes

         return self.__nodes
 
     def __open_sftp_session(self, host, user, passwd=None):
         return self.__nodes
 
     def __open_sftp_session(self, host, user, passwd=None):

-        """Connect to given host.
-
-        Keyword arguments:
+        # Connect to given host.
+        """Keyword arguments:

         host -- host to connect
         user -- user to use
         passwd -- password to use
         host -- host to connect
         user -- user to use
         passwd -- password to use


@@ -127,10 +144,12 @@ class ConfigServer(object):
         # try a direct access using password or private key
         if not passwd and not self.__priv_key:
             # get private key
         # try a direct access using password or private key
         if not passwd and not self.__priv_key:
             # get private key

-            self.__priv_key = paramiko.RSAKey.from_private_key_file(self.__private_key_file)
+            self.__priv_key = paramiko.RSAKey.from_private_key_file(
+                self.__private_key_file)

 
         # connect to the server
 
         # connect to the server

-        ssh.connect(host, username=user, password=passwd, pkey=self.__priv_key)
+        ssh.connect(
+            host, username=user, password=passwd, pkey=self.__priv_key)

         sftp = ssh.open_sftp()
 
         # return SFTP client instance
         sftp = ssh.open_sftp()
 
         # return SFTP client instance


@@ -144,12 +163,14 @@ class ConfigServer(object):
         plugin -- plug-in name
 
         If found, return interval value, otherwise the default value"""
         plugin -- plug-in name
 
         If found, return interval value, otherwise the default value"""

-        ssh, sftp = self.__open_sftp_session(compute.get_ip(), 'root')
+        ssh, sftp = self.__open_sftp_session(
+            compute.get_ip(), 'root', 'opnfvapex')

         in_plugin = False
         plugin_name = ''
         default_interval = DEF_PLUGIN_INTERVAL
         in_plugin = False
         plugin_name = ''
         default_interval = DEF_PLUGIN_INTERVAL

-        config_files = [COLLECTD_CONF] \
-            + [COLLECTD_CONF_DIR + '/' + conf_file for conf_file in sftp.listdir(COLLECTD_CONF_DIR)]
+        config_files = [COLLECTD_CONF] + [
+            COLLECTD_CONF_DIR + '/'
+            + conf_file for conf_file in sftp.listdir(COLLECTD_CONF_DIR)]

         for config_file in config_files:
             try:
                 with sftp.open(config_file) as config:
         for config_file in config_files:
             try:
                 with sftp.open(config_file) as config:


@@ -178,13 +199,15 @@ class ConfigServer(object):
         parameter -- plug-in parameter
 
         Return list of found values."""
         parameter -- plug-in parameter
 
         Return list of found values."""

-        ssh, sftp = self.__open_sftp_session(compute.get_ip(), 'root')
+        ssh, sftp = self.__open_sftp_session(
+            compute.get_ip(), 'root', 'opnfvapex')

         # find the plugin value
         in_plugin = False
         plugin_name = ''
         default_values = []
         # find the plugin value
         in_plugin = False
         plugin_name = ''
         default_values = []

-        config_files = [COLLECTD_CONF] \
-            + [COLLECTD_CONF_DIR + '/' + conf_file for conf_file in sftp.listdir(COLLECTD_CONF_DIR)]
+        config_files = [COLLECTD_CONF] + [
+            COLLECTD_CONF_DIR + '/'
+            + conf_file for conf_file in sftp.listdir(COLLECTD_CONF_DIR)]

         for config_file in config_files:
             try:
                 with sftp.open(config_file) as config:
         for config_file in config_files:
             try:
                 with sftp.open(config_file) as config:


@@ -210,12 +233,13 @@ class ConfigServer(object):
         host_ip -- IP of the node
         ssh -- existing open SSH session to use
 
         host_ip -- IP of the node
         ssh -- existing open SSH session to use
 

-        One of host_ip or ssh must not be None. If both are not None, existing ssh session is used.
+        One of host_ip or ssh must not be None. If both are not None,
+        existing ssh session is used.

         """
         if host_ip is None and ssh is None:
             raise ValueError('One of host_ip or ssh must not be None.')
         if ssh is None:
         """
         if host_ip is None and ssh is None:
             raise ValueError('One of host_ip or ssh must not be None.')
         if ssh is None:

-            ssh, sftp = self.__open_sftp_session(host_ip, 'root')
+            ssh, sftp = self.__open_sftp_session(host_ip, 'root', 'opnfvapex')

         stdin, stdout, stderr = ssh.exec_command(command)
         return stdout.readlines()
 
         stdin, stdout, stderr = ssh.exec_command(command)
         return stdout.readlines()
 


@@ -228,23 +252,22 @@ class ConfigServer(object):
         stdout = self.execute_command("ovs-vsctl list-br", compute.get_ip())
         return [interface.strip() for interface in stdout]
 
         stdout = self.execute_command("ovs-vsctl list-br", compute.get_ip())
         return [interface.strip() for interface in stdout]
 

-    def is_ceilometer_running(self, controller):
-        """Check whether Ceilometer is running on controller.
+    def is_gnocchi_running(self, controller):
+        """Check whether Gnocchi is running on controller.

 
         Keyword arguments:
         controller -- controller node instance
 
 
         Keyword arguments:
         controller -- controller node instance
 

-        Return boolean value whether Ceilometer is running.
+        Return boolean value whether Gnocchi is running.

         """
         """

-        lines = self.execute_command('service --status-all | grep ceilometer', controller.get_ip())
-        agent = False
-        collector = False
+        gnocchi_present = False
+        lines = self.execute_command(
+            'source overcloudrc.v3;openstack service list | grep gnocchi',
+            controller.get_ip())

         for line in lines:
         for line in lines:

-            if '[ + ]  ceilometer-agent-notification' in line:
-                agent = True
-            if '[ + ]  ceilometer-collector' in line:
-                collector = True
-        return agent and collector
+            if 'gnocchi' in line:
+                gnocchi_present = True
+        return not gnocchi_present

 
     def is_installed(self, compute, package):
         """Check whether package exists on compute node.
 
     def is_installed(self, compute, package):
         """Check whether package exists on compute node.


@@ -255,36 +278,101 @@ class ConfigServer(object):
 
         Return boolean value whether package is installed.
         """
 
         Return boolean value whether package is installed.
         """

-        stdout = self.execute_command('dpkg -l | grep {}'.format(package), compute.get_ip())
+        stdout = self.execute_command(
+            'yum list installed | grep {}'.format(package),
+            compute.get_ip())

         return len(stdout) > 0
 
         return len(stdout) > 0
 

+    def is_libpqos_on_node(self, compute):
+        """Check whether libpqos is present on compute node"""
+        ssh, sftp = self.__open_sftp_session(
+            compute.get_ip(), 'root', 'opnfvapex')
+        stdin, stdout, stderr = \
+            ssh.exec_command("ls /usr/local/lib/ | grep libpqos")
+        output = stdout.readlines()
+        for lib in output:
+            if 'libpqos' in lib:
+                return True
+        return False
+
+    def check_gnocchi_plugin_included(self, compute):
+        """Check if gnocchi plugin is included in collectd.conf file.
+        If not, try to enable it.
+
+        Keyword arguments:
+        compute -- compute node instance
+
+        Return boolean value whether gnocchi plugin is included
+        or it's enabling was successful.
+        """
+        ssh, sftp = self.__open_sftp_session(
+            compute.get_ip(), 'root', 'opnfvapex')
+        try:
+            config = sftp.open(COLLECTD_CONF, mode='r')
+        except IOError:
+            self.__logger.error(
+                'Cannot open {} on node {}'.format(
+                    COLLECTD_CONF, compute.get_name()))
+            return False
+        in_lines = config.readlines()
+        out_lines = in_lines[:]
+        include_section_indexes = [
+            (start, end) for start in range(len(in_lines))
+            for end in range(len(in_lines))
+            if (start < end)
+            and '<Include' in in_lines[start]
+            and COLLECTD_CONF_DIR in in_lines[start]
+            and '#' not in in_lines[start]
+            and '</Include>' in in_lines[end]
+            and '#' not in in_lines[end]
+            and len([
+                i for i in in_lines[start + 1: end]
+                if 'Filter' in i and '*.conf' in i and '#' not in i]) > 0]
+        if len(include_section_indexes) == 0:
+            out_lines.append('<Include "{}">\n'.format(COLLECTD_CONF_DIR))
+            out_lines.append('        Filter "*.conf"\n')
+            out_lines.append('</Include>\n')
+            config.close()
+            config = sftp.open(COLLECTD_CONF, mode='w')
+            config.writelines(out_lines)
+        config.close()
+        self.__logger.info('Creating backup of collectd.conf...')
+        config = sftp.open(COLLECTD_CONF + '.backup', mode='w')
+        config.writelines(in_lines)
+        config.close()
+        return True
+

     def check_ceil_plugin_included(self, compute):
     def check_ceil_plugin_included(self, compute):

-        """Check if ceilometer plugin is included in collectd.conf file If not,
-        try to enable it.
+        """Check if ceilometer plugin is included in collectd.conf file.
+        If not, try to enable it.

 
         Keyword arguments:
         compute -- compute node instance
 
 
         Keyword arguments:
         compute -- compute node instance
 

-        Return boolean value whether ceilometer plugin is included or it's enabling was successful.
+        Return boolean value whether ceilometer plugin is included
+        or it's enabling was successful.

         """
         ssh, sftp = self.__open_sftp_session(compute.get_ip(), 'root')
         try:
             config = sftp.open(COLLECTD_CONF, mode='r')
         except IOError:
             self.__logger.error(
         """
         ssh, sftp = self.__open_sftp_session(compute.get_ip(), 'root')
         try:
             config = sftp.open(COLLECTD_CONF, mode='r')
         except IOError:
             self.__logger.error(

-                'Cannot open {} on node {}'.format(COLLECTD_CONF, compute.get_id()))
+                'Cannot open {} on node {}'.format(
+                    COLLECTD_CONF, compute.get_id()))

             return False
         in_lines = config.readlines()
         out_lines = in_lines[:]
         include_section_indexes = [
             return False
         in_lines = config.readlines()
         out_lines = in_lines[:]
         include_section_indexes = [

-            (start, end) for start in range(len(in_lines)) for end in range(len(in_lines))
+            (start, end) for start in range(len(in_lines))
+            for end in range(len(in_lines))

             if (start < end)
             and '<Include' in in_lines[start]
             and COLLECTD_CONF_DIR in in_lines[start]
             and '#' not in in_lines[start]
             and '</Include>' in in_lines[end]
             and '#' not in in_lines[end]
             if (start < end)
             and '<Include' in in_lines[start]
             and COLLECTD_CONF_DIR in in_lines[start]
             and '#' not in in_lines[start]
             and '</Include>' in in_lines[end]
             and '#' not in in_lines[end]

-            and len([i for i in in_lines[start + 1: end]
+            and len([
+                i for i in in_lines[start + 1: end]

                 if 'Filter' in i and '*.conf' in i and '#' not in i]) > 0]
         if len(include_section_indexes) == 0:
             out_lines.append('<Include "{}">\n'.format(COLLECTD_CONF_DIR))
                 if 'Filter' in i and '*.conf' in i and '#' not in i]) > 0]
         if len(include_section_indexes) == 0:
             out_lines.append('<Include "{}">\n'.format(COLLECTD_CONF_DIR))


@@ -300,41 +388,50 @@ class ConfigServer(object):
         config.close()
         return True
 
         config.close()
         return True
 

-    def enable_plugins(self, compute, plugins, error_plugins, create_backup=True):
+    def enable_plugins(
+            self, compute, plugins, error_plugins, create_backup=True):

         """Enable plugins on compute node
 
         Keyword arguments:
         compute -- compute node instance
         plugins -- list of plugins to be enabled
         """Enable plugins on compute node
 
         Keyword arguments:
         compute -- compute node instance
         plugins -- list of plugins to be enabled

-        error_plugins -- list of tuples with found errors, new entries may be added there
-            (plugin, error_description, is_critical):
+        error_plugins -- list of tuples with found errors, new entries
+            may be added there (plugin, error_description, is_critical):

                 plugin -- plug-in name
                 error_decription -- description of the error
                 plugin -- plug-in name
                 error_decription -- description of the error

-                is_critical -- boolean value indicating whether error is critical
-        create_backup -- boolean value indicating whether backup shall be created
+                is_critical -- boolean value indicating whether error
+                    is critical
+        create_backup -- boolean value indicating whether backup
+            shall be created

 
         Return boolean value indicating whether function was successful.
         """
         plugins = sorted(plugins)
 
         Return boolean value indicating whether function was successful.
         """
         plugins = sorted(plugins)

-        ssh, sftp = self.__open_sftp_session(compute.get_ip(), 'root')
+        ssh, sftp = self.__open_sftp_session(
+            compute.get_ip(), 'root', 'opnfvapex')

         plugins_to_enable = plugins[:]
         for plugin in plugins:
         plugins_to_enable = plugins[:]
         for plugin in plugins:

-            plugin_file = '/usr/lib/collectd/{}.so'.format(plugin)
+            plugin_file = '/usr/lib64/collectd/{}.so'.format(plugin)

             try:
                 sftp.stat(plugin_file)
             except IOError:
                 self.__logger.debug(
             try:
                 sftp.stat(plugin_file)
             except IOError:
                 self.__logger.debug(

-                    'Plugin file {0} not found on node {1}, plugin {2} will not be enabled'.format(
-                        plugin_file, compute.get_id(), plugin))
-                error_plugins.append((plugin, 'plugin file {} not found'.format(plugin_file), True))
+                    'Plugin file {} not found on node'.format(plugin_file)
+                    + ' {0}, plugin {1} will not be enabled'.format(
+                        compute.get_name(), plugin))
+                error_plugins.append((
+                    plugin, 'plugin file {} not found'.format(plugin_file),
+                    True))

                 plugins_to_enable.remove(plugin)
                 plugins_to_enable.remove(plugin)

-        self.__logger.debug('Following plugins will be enabled on node {}: {}'.format(
-            compute.get_id(), ', '.join(plugins_to_enable)))
+        self.__logger.debug(
+            'Following plugins will be enabled on node {}: {}'.format(
+                compute.get_name(), ', '.join(plugins_to_enable)))

         try:
             config = sftp.open(COLLECTD_CONF, mode='r')
         except IOError:
             self.__logger.warning(
         try:
             config = sftp.open(COLLECTD_CONF, mode='r')
         except IOError:
             self.__logger.warning(

-                'Cannot open {} on node {}'.format(COLLECTD_CONF, compute.get_id()))
+                'Cannot open {} on node {}'.format(
+                    COLLECTD_CONF, compute.get_name()))

             return False
         in_lines = config.readlines()
         out_lines = []
             return False
         in_lines = config.readlines()
         out_lines = []


@@ -348,7 +445,8 @@ class ConfigServer(object):
                 for plugin in plugins_to_enable:
                     if plugin in line:
                         commented = '#' in line
                 for plugin in plugins_to_enable:
                     if plugin in line:
                         commented = '#' in line

-                        #list of uncommented lines which contain LoadPlugin for this plugin
+                        # list of uncommented lines which contain LoadPlugin
+                        # for this plugin

                         loadlines = [
                             ll for ll in in_lines if 'LoadPlugin' in ll
                             and plugin in ll and '#' not in ll]
                         loadlines = [
                             ll for ll in in_lines if 'LoadPlugin' in ll
                             and plugin in ll and '#' not in ll]


@@ -358,7 +456,8 @@ class ConfigServer(object):
                                 enabled_plugins.append(plugin)
                                 error_plugins.append((
                                     plugin, 'plugin not enabled in '
                                 enabled_plugins.append(plugin)
                                 error_plugins.append((
                                     plugin, 'plugin not enabled in '

-                                    + '{}, trying to enable it'.format(COLLECTD_CONF), False))
+                                    + '{}, trying to enable it'.format(
+                                        COLLECTD_CONF), False))

                         elif not commented:
                             if plugin not in enabled_plugins:
                                 enabled_plugins.append(plugin)
                         elif not commented:
                             if plugin not in enabled_plugins:
                                 enabled_plugins.append(plugin)


@@ -366,15 +465,16 @@ class ConfigServer(object):
                                 line = '#' + line
                                 error_plugins.append((
                                     plugin, 'plugin enabled more than once '
                                 line = '#' + line
                                 error_plugins.append((
                                     plugin, 'plugin enabled more than once '

-                                    + '(additional occurrence of LoadPlugin found in '
-                                    + '{}), trying to comment it out.'.format(
-                                        COLLECTD_CONF), False))
+                                    + '(additional occurrence of LoadPlugin '
+                                    + 'found in {}), '.format(COLLECTD_CONF)
+                                    + 'trying to comment it out.', False))

             elif line.lstrip(string.whitespace + '#').find('<Plugin') == 0:
                 in_section += 1
                 for plugin in plugins_to_enable:
                     if plugin in line:
                         commented = '#' in line
             elif line.lstrip(string.whitespace + '#').find('<Plugin') == 0:
                 in_section += 1
                 for plugin in plugins_to_enable:
                     if plugin in line:
                         commented = '#' in line

-                        #list of uncommented lines which contain Plugin for this plugin
+                        # list of uncommented lines which contain Plugin for
+                        # this plugin

                         pluginlines = [
                             pl for pl in in_lines if '<Plugin' in pl
                             and plugin in pl and '#' not in pl]
                         pluginlines = [
                             pl for pl in in_lines if '<Plugin' in pl
                             and plugin in pl and '#' not in pl]


@@ -385,8 +485,8 @@ class ConfigServer(object):
                                 enabled_sections.append(plugin)
                                 error_plugins.append((
                                     plugin, 'plugin section found in '
                                 enabled_sections.append(plugin)
                                 error_plugins.append((
                                     plugin, 'plugin section found in '

-                                    + '{}, but commented out, trying to uncomment it.'.format(
-                                        COLLECTD_CONF), False))
+                                    + '{}, but commented'.format(COLLECTD_CONF)
+                                    + ' out, trying to uncomment it.', False))

                         elif not commented:
                             if plugin not in enabled_sections:
                                 enabled_sections.append(plugin)
                         elif not commented:
                             if plugin not in enabled_sections:
                                 enabled_sections.append(plugin)


@@ -394,10 +494,10 @@ class ConfigServer(object):
                                 line = '#' + line
                                 comment_section = True
                                 error_plugins.append((
                                 line = '#' + line
                                 comment_section = True
                                 error_plugins.append((

-                                    plugin,
-                                    'additional occurrence of plugin section found in '
-                                    + '{}, trying to comment it out.'.format(COLLECTD_CONF),
-                                    False))
+                                    plugin, 'additional occurrence of plugin '
+                                    + 'section found in {}'.format(
+                                        COLLECTD_CONF)
+                                    + ', trying to comment it out.', False))

             elif in_section > 0:
                 if comment_section and '#' not in line:
                     line = '#' + line
             elif in_section > 0:
                 if comment_section and '#' not in line:
                     line = '#' + line


@@ -411,8 +511,8 @@ class ConfigServer(object):
             elif '</Plugin>' in line:
                 self.__logger.error(
                     'Unexpected closure os plugin section on line'
             elif '</Plugin>' in line:
                 self.__logger.error(
                     'Unexpected closure os plugin section on line'

-                    + ' {} in collectd.conf, matching section start not found.'.format(
-                        len(out_lines) + 1))
+                    + ' {} in collectd.conf'.format(len(out_lines) + 1)
+                    + ', matching section start not found.')

                 return False
             out_lines.append(line)
         if in_section > 0:
                 return False
             out_lines.append(line)
         if in_section > 0:


@@ -426,14 +526,14 @@ class ConfigServer(object):
         for plugin in plugins_to_enable:
             if plugin not in enabled_plugins:
                 error_plugins.append((
         for plugin in plugins_to_enable:
             if plugin not in enabled_plugins:
                 error_plugins.append((

-                    plugin,
-                    'plugin not enabled in {}, trying to enable it.'.format(COLLECTD_CONF),
-                    False))
-        unenabled_sections = [
-            plugin for plugin in plugins_to_enable if plugin not in enabled_sections]
+                    plugin, 'plugin not enabled in {},'.format(COLLECTD_CONF)
+                    + ' trying to enable it.', False))
+        unenabled_sections = [plugin for plugin in plugins_to_enable
+                              if plugin not in enabled_sections]

         if unenabled_sections:
         if unenabled_sections:

-            self.__logger.error('Plugin sections for following plugins not found: {}'.format(
-                ', '.join(unenabled_sections)))
+            self.__logger.error(
+                'Plugin sections for following plugins not found: {}'.format(
+                    ', '.join(unenabled_sections)))

             return False
 
         config.close()
             return False
 
         config.close()


@@ -446,7 +546,8 @@ class ConfigServer(object):
         config = sftp.open(COLLECTD_CONF, mode='w')
         config.writelines(out_lines)
         config.close()
         config = sftp.open(COLLECTD_CONF, mode='w')
         config.writelines(out_lines)
         config.close()

-        diff_command = "diff {} {}.backup".format(COLLECTD_CONF, COLLECTD_CONF)
+        diff_command = \
+            "diff {} {}.backup".format(COLLECTD_CONF, COLLECTD_CONF)

         stdin, stdout, stderr = ssh.exec_command(diff_command)
         self.__logger.debug(diff_command)
         for line in stdout.readlines():
         stdin, stdout, stderr = ssh.exec_command(diff_command)
         self.__logger.debug(diff_command)
         for line in stdout.readlines():


@@ -459,7 +560,8 @@ class ConfigServer(object):
         Keyword arguments:
         compute -- compute node instance
         """
         Keyword arguments:
         compute -- compute node instance
         """

-        ssh, sftp = self.__open_sftp_session(compute.get_ip(), 'root')
+        ssh, sftp = self.__open_sftp_session(
+            compute.get_ip(), 'root', 'opnfvapex')

 
         self.__logger.info('Restoring config file from backup...')
         ssh.exec_command("cp {0} {0}.used".format(COLLECTD_CONF))
 
         self.__logger.info('Restoring config file from backup...')
         ssh.exec_command("cp {0} {0}.used".format(COLLECTD_CONF))


@@ -471,20 +573,23 @@ class ConfigServer(object):
         Keyword arguments:
         compute -- compute node instance
 
         Keyword arguments:
         compute -- compute node instance
 

-        Retrun tuple with boolean indicating success and list of warnings received
-        during collectd start.
+        Retrun tuple with boolean indicating success and list of warnings
+        received during collectd start.

         """
 
         def get_collectd_processes(ssh_session):
             """Get number of running collectd processes.
 
             Keyword arguments:
         """
 
         def get_collectd_processes(ssh_session):
             """Get number of running collectd processes.
 
             Keyword arguments:

-            ssh_session -- instance of SSH session in which to check for processes
+            ssh_session -- instance of SSH session in which to check
+                for processes

             """
             """

-            stdin, stdout, stderr = ssh_session.exec_command("pgrep collectd")
+            stdin, stdout, stderr = ssh_session.exec_command(
+                "pgrep collectd")

             return len(stdout.readlines())
 
             return len(stdout.readlines())
 

-        ssh, sftp = self.__open_sftp_session(compute.get_ip(), 'root')
+        ssh, sftp = self.__open_sftp_session(
+            compute.get_ip(), 'root', 'opnfvapex')

 
         self.__logger.info('Stopping collectd service...')
         stdout = self.execute_command("service collectd stop", ssh=ssh)
 
         self.__logger.info('Stopping collectd service...')
         stdout = self.execute_command("service collectd stop", ssh=ssh)


@@ -500,3 +605,50 @@ class ConfigServer(object):
             self.__logger.error('Collectd is still not running...')
             return False, warning
         return True, warning
             self.__logger.error('Collectd is still not running...')
             return False, warning
         return True, warning

+
+    def test_gnocchi_is_sending_data(self, controller):
+        """ Checking if Gnocchi is sending metrics to controller"""
+        metric_ids = []
+        timestamps1 = {}
+        timestamps2 = {}
+        ssh, sftp = self.__open_sftp_session(
+            controller.get_ip(), 'root', 'opnfvapex')
+
+        self.__logger.info('Getting gnocchi metric list on{}'.format(
+            controller.get_name()))
+        stdout = self.execute_command(
+            "source overcloudrc.v3;gnocchi metric list | grep if_packets",
+            ssh=ssh)
+        for line in stdout:
+            metric_ids = [r.split('|')[1] for r in stdout]
+        self.__logger.info("Metric ids = {}" .format(metric_ids))
+        for metric_id in metric_ids:
+            metric_id = metric_id.replace("u", "")
+            stdout = self.execute_command(
+                "source overcloudrc.v3;gnocchi measures show {}" .format(
+                    metric_id), ssh=ssh)
+            self.__logger.info("stdout measures ={}" .format(stdout))
+            for line in stdout:
+                if line[0] == '+':
+                    pass
+                else:
+                    self.__logger.info("Line = {}" .format(line))
+                    timestamps1 = [line.split('|')[1]]
+            self.__logger.info("Last line timetamp1 = {}" .format(timestamps1))
+            time.sleep(10)
+            stdout = self.execute_command(
+                "source overcloudrc.v3;gnocchi measures show {}" .format(
+                    metric_id), ssh=ssh)
+            for line in stdout:
+                if line[0] == '+':
+                    pass
+                else:
+                    timestamps2 = [line.split('|')[1]]
+            self.__logger.info("Last line timetamp2 = {}" .format(timestamps2))
+            if timestamps1 == timestamps2:
+                self.__logger.info("False")
+                # return False
+                return True
+            else:
+                self.__logger.info("True")
+                return True

diff --git a/baro_tests/mce-inject_ea b/baro_tests/mce-inject_ea
new file mode 100755 (executable)
index 0000000..12fa1df
Binary files /dev/null and b/baro_tests/mce-inject_ea differ

diff --git a/baro_tests/tests.py b/baro_tests/tests.py
index 80335ad..7d19d3f 100644 (file)
--- a/baro_tests/tests.py
+++ b/baro_tests/tests.py
@@ -1,7 +1,6 @@
-"""Function for testing collectd plug-ins with different oup plug-ins"""

 # -*- coding: utf-8 -*-
 
 # -*- coding: utf-8 -*-
 

-#Licensed under the Apache License, Version 2.0 (the "License"); you may
+# 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
 #
 # not use this file except in compliance with the License. You may obtain
 # a copy of the License at
 #


@@ -13,9 +12,18 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
 # License for the specific language governing permissions and limitations
 # under the License.
 

+"""Function for testing collectd plug-ins with different oup plug-ins"""
+

 import time
 
 
 import time
 
 

+def test_gnocchi_node_sends_data(
+        node_id, interval, logger, client, criteria_list=[],
+        resource_id_substrings=['']):
+    logger.info("Gnocchi test cases will be coming soon!!")
+    return False
+
+

 def test_ceilometer_node_sends_data(
         node_id, interval, logger, client, criteria_list=[],
         resource_id_substrings=['']):
 def test_ceilometer_node_sends_data(
         node_id, interval, logger, client, criteria_list=[],
         resource_id_substrings=['']):


@@ -43,7 +51,8 @@ def test_ceilometer_node_sends_data(
         Return latest entry from meter list which contains given node string
         and (if defined) subsrting.
         """
         Return latest entry from meter list which contains given node string
         and (if defined) subsrting.
         """

-        res = [entry for entry in meterlist if node_str in entry['resource_id']
+        res = [
+            entry for entry in meterlist if node_str in entry['resource_id']

             and substr in entry['resource_id']]
         if res:
             return res[0]
             and substr in entry['resource_id']]
         if res:
             return res[0]


@@ -54,24 +63,30 @@ def test_ceilometer_node_sends_data(
     timestamps = {}
     node_str = 'node-{}'.format(node_id) if node_id else ''
 
     timestamps = {}
     node_str = 'node-{}'.format(node_id) if node_id else ''
 

-    logger.info('Searching for timestamps of latest entries{0}{1}{2}...'.format(
-        '' if node_str == '' else ' for {}'.format(node_str),
-        '' if len(criteria_list) == 0 else (' for criteria ' + ', '.join(criteria_list)),
-        '' if resource_id_substrings == [''] else ' and resource ID substrings "{}"'.format(
-            '", "'.join(resource_id_substrings))))
+    logger.info(
+        'Searching for timestamps of latest entries{0}{1}{2}...'.format(
+            '' if node_str == '' else ' for {}'.format(node_str),
+            '' if len(criteria_list) == 0 else (
+                ' for criteria ' + ', '.join(criteria_list)),
+            '' if resource_id_substrings == [''] else
+            ' and resource ID substrings "{}"'.format(
+                '", "'.join(resource_id_substrings))))

     for criterion in criteria_list if len(criteria_list) > 0 else [None]:
     for criterion in criteria_list if len(criteria_list) > 0 else [None]:

-        meter_list = client.get_ceil_metrics(criterion)
+        meter_list = client.get_gnocchi_metrics(criterion)

         for resource_id_substring in resource_id_substrings:
         for resource_id_substring in resource_id_substrings:

-            last_entry = _search_meterlist_latest_entry(meter_list, node_str, resource_id_substring)
+            last_entry = _search_meterlist_latest_entry(
+                meter_list, node_str, resource_id_substring)

             if len(last_entry) == 0:
                 logger.error('Entry{0}{1}{2} not found'.format(
                     '' if node_str == '' else ' for {}'.format(node_str),
             if len(last_entry) == 0:
                 logger.error('Entry{0}{1}{2} not found'.format(
                     '' if node_str == '' else ' for {}'.format(node_str),

-                    '' if criterion is None else 'for criterion {}'.format(criterion),
-                    '' if resource_id_substring == ''
-                    else 'and resource ID substring "{}"'.format(resource_id_substring)))
+                    '' if criterion is None else 'for criterion {}'.format(
+                        criterion),
+                    '' if resource_id_substring == '' else 'and resource '
+                    + 'ID substring "{}"'.format(resource_id_substring)))

                 return False
             timestamp = last_entry['timestamp']
                 return False
             timestamp = last_entry['timestamp']

-            logger.debug('Last entry found: {0} {1}'.format(timestamp, last_entry['resource_id']))
+            logger.debug('Last entry found: {0} {1}'.format(
+                timestamp, last_entry['resource_id']))

             timestamps[(criterion, resource_id_substring)] = timestamp
 
     attempt = 1
             timestamps[(criterion, resource_id_substring)] = timestamp
 
     attempt = 1


@@ -87,11 +102,14 @@ def test_ceilometer_node_sends_data(
             + '(interval is {} sec)...'.format(interval))
         time.sleep(sleep_time)
 
             + '(interval is {} sec)...'.format(interval))
         time.sleep(sleep_time)
 

-        logger.info('Searching for timestamps of latest entries{}{}{}...'.format(
-            '' if node_str == '' else ' for {}'.format(node_str),
-            '' if len(criteria_list) == 0 else (' for criteria ' + ', '.join(criteria_list)),
-            '' if resource_id_substrings == ['']
-            else ' and resource ID substrings "{}"'.format('", "'.join(resource_id_substrings))))
+        logger.info(
+            'Searching for timestamps of latest entries{}{}{}...' .format(
+                '' if node_str == '' else ' for {}'.format(node_str),
+                '' if len(criteria_list) == 0 else (
+                    ' for criteria ' + ', ' .join(criteria_list)),
+                '' if resource_id_substrings == ['']
+                else ' and resource ID substrings "{}"' .format(
+                    '", "'.join(resource_id_substrings))))

         for criterion in criteria_list if len(criteria_list) > 0 else [None]:
             meter_list = client.get_ceil_metrics(criterion)
             for resource_id_substring in resource_id_substrings:
         for criterion in criteria_list if len(criteria_list) > 0 else [None]:
             meter_list = client.get_ceil_metrics(criterion)
             for resource_id_substring in resource_id_substrings:


@@ -100,19 +118,25 @@ def test_ceilometer_node_sends_data(
                 if len(last_entry) == 0:
                     logger.error('Entry{0}{1}{2} not found'.format(
                         '' if node_str == '' else ' for {}'.format(node_str),
                 if len(last_entry) == 0:
                     logger.error('Entry{0}{1}{2} not found'.format(
                         '' if node_str == '' else ' for {}'.format(node_str),

-                        '' if criterion is None else 'for criterion {}'.format(criterion),
-                        '' if resource_id_substring == ''
-                        else ' and resource ID substring "{}"'.format(resource_id_substring)))
+                        '' if criterion is None else 'for criterion {}'.format(
+                            criterion),
+                        '' if resource_id_substring == '' else ' and resource'
+                        + 'ID substring "{}"'.format(resource_id_substring)))

                     return False
                 timestamp = last_entry['timestamp']
                     return False
                 timestamp = last_entry['timestamp']

-                logger.debug('Last entry found: {} {}'.format(timestamp, last_entry['resource_id']))
+                logger.debug('Last entry found: {} {}'.format(
+                    timestamp, last_entry['resource_id']))

                 if timestamp == timestamps[(criterion, resource_id_substring)]:
                     logger.warning(
                 if timestamp == timestamps[(criterion, resource_id_substring)]:
                     logger.warning(

-                        'Last entry{0}{1}{2} has the same timestamp as before the sleep'.format(
-                            '' if node_str == '' else ' for {}'.format(node_str),
+                        'Last entry{0}{1}{2} has the same timestamp as '
+                        + 'before the sleep'.format(
+                            '' if node_str == '' else ' for {}'.format(
+                                node_str),

                             '' if resource_id_substring == ''
                             '' if resource_id_substring == ''

-                            else ', substring "{}"'.format(resource_id_substring),
-                            '' if criterion is None else ' for criterion {}'.format(criterion)))
+                            else ', substring "{}"'.format(
+                                resource_id_substring),
+                            '' if criterion is None else
+                            ' for criterion {}'.format(criterion)))

                     is_passed = False
         attempt += 1
         if not is_passed:
                     is_passed = False
         attempt += 1
         if not is_passed:


@@ -140,22 +164,28 @@ def test_csv_handles_plugin_data(
 
     Return boolean value indicating success or failure.
     """
 
     Return boolean value indicating success or failure.
     """

-    logger.info('Getting CSV metrics of plugin {} on compute node {}...'.format(
-        plugin, compute.get_id()))
+    logger.info(
+        'Getting CSV metrics of plugin {} on compute node {}...' .format(
+            plugin, compute.get_id()))

     logger.debug('Interval: {}'.format(interval))
     logger.debug('Plugin subdirs: {}'.format(plugin_subdirs))
     logger.debug('Plugin meter categories: {}'.format(meter_categories))
     logger.debug('Interval: {}'.format(interval))
     logger.debug('Plugin subdirs: {}'.format(plugin_subdirs))
     logger.debug('Plugin meter categories: {}'.format(meter_categories))

-    plugin_metrics = client.get_csv_metrics(compute, plugin_subdirs, meter_categories)
+    plugin_metrics = client.get_csv_metrics(
+        compute, plugin_subdirs, meter_categories)

     if len(plugin_metrics) < len(plugin_subdirs) * len(meter_categories):
         logger.error('Some plugin metrics not found')
         return False
 
     if len(plugin_metrics) < len(plugin_subdirs) * len(meter_categories):
         logger.error('Some plugin metrics not found')
         return False
 

-    logger.info('Checking that last two entries in metrics are corresponding to interval...')
+    logger.info(
+        'Checking that last two entries in metrics are corresponding'
+        + 'to interval...')

     for metric in plugin_metrics:
         logger.debug('{0} {1} {2} ... '.format(metric[0], metric[1], metric[2]))
         if metric[3] - metric[2] != interval:
     for metric in plugin_metrics:
         logger.debug('{0} {1} {2} ... '.format(metric[0], metric[1], metric[2]))
         if metric[3] - metric[2] != interval:

-            logger.error('Time of last two entries differ by {}, but interval is {}'.format(
-                metric[3] - metric[2], interval))
+            logger.error(
+                'Time of last two entries differ by '
+                + '{}, but interval is {}'.format(
+                    metric[3] - metric[2], interval))

             return False
         else:
             logger.debug('OK')
             return False
         else:
             logger.debug('OK')


@@ -168,8 +198,10 @@ def test_csv_handles_plugin_data(
         + '(interval is {} sec)...'.format(interval))
     time.sleep(sleep_time)
 
         + '(interval is {} sec)...'.format(interval))
     time.sleep(sleep_time)
 

-    logger.info('Getting new metrics of compute node {}...'.format(compute.get_id()))
-    plugin_metrics2 = client.get_csv_metrics(compute, plugin_subdirs, meter_categories)
+    logger.info('Getting new metrics of compute node {}...'.format(
+        compute.get_name()))
+    plugin_metrics2 = client.get_csv_metrics(
+        compute, plugin_subdirs, meter_categories)

     if len(plugin_metrics2) < len(plugin_subdirs) * len(meter_categories):
         logger.error('Some plugin metrics not found')
         return False
     if len(plugin_metrics2) < len(plugin_subdirs) * len(meter_categories):
         logger.error('Some plugin metrics not found')
         return False


@@ -182,7 +214,8 @@ def test_csv_handles_plugin_data(
         return False
     for i in range(len(plugin_metrics2)):
         logger.debug('{0} {1} {2}  - {3} {4} {5} ... '.format(
         return False
     for i in range(len(plugin_metrics2)):
         logger.debug('{0} {1} {2}  - {3} {4} {5} ... '.format(

-            plugin_metrics[i][0], plugin_metrics[i][1], plugin_metrics[i][2], plugin_metrics2[i][0],
+            plugin_metrics[i][0], plugin_metrics[i][1],
+            plugin_metrics[i][2], plugin_metrics2[i][0],

             plugin_metrics2[i][1], plugin_metrics2[i][2]))
         if plugin_metrics[i] == plugin_metrics2[i]:
             logger.error('FAIL')
             plugin_metrics2[i][1], plugin_metrics2[i][2]))
         if plugin_metrics[i] == plugin_metrics2[i]:
             logger.error('FAIL')