functest/opnfv_tests/sdn/odl/odl.py

   1 #!/usr/bin/env python
   2
   3 # Copyright (c) 2016 Orange and others.
   4 #
   5 # All rights reserved. This program and the accompanying materials
   6 # are made available under the terms of the Apache License, Version 2.0
   7 # which accompanies this distribution, and is available at
   8 # http://www.apache.org/licenses/LICENSE-2.0
   9
  10 """Define classes required to run ODL suites.
  11
  12 It has been designed for any context. But helpers are given for
  13 running test suites in OPNFV environment.
  14
  15 Example:
  16         $ python odl.py
  17 """
  18
  19 from __future__ import division
  20
  21 import argparse
  22 import errno
  23 import fileinput
  24 import logging
  25 import os
  26 import re
  27 import sys
  28
  29 import robot.api
  30 from robot.errors import RobotError
  31 import robot.run
  32 from robot.utils.robottime import timestamp_to_secs
  33 from six import StringIO
  34 from six.moves import urllib
  35
  36 from functest.core import testcase
  37 from functest.utils import constants
  38 import functest.utils.openstack_utils as op_utils
  39
  40 __author__ = "Cedric Ollivier <cedric.ollivier@orange.com>"
  41
  42
  43 class ODLResultVisitor(robot.api.ResultVisitor):
  44     """Visitor to get result details."""
  45
  46     def __init__(self):
  47         self._data = []
  48
  49     def visit_test(self, test):
  50         output = {}
  51         output['name'] = test.name
  52         output['parent'] = test.parent.name
  53         output['status'] = test.status
  54         output['starttime'] = test.starttime
  55         output['endtime'] = test.endtime
  56         output['critical'] = test.critical
  57         output['text'] = test.message
  58         output['elapsedtime'] = test.elapsedtime
  59         self._data.append(output)
  60
  61     def get_data(self):
  62         """Get the details of the result."""
  63         return self._data
  64
  65
  66 class ODLTests(testcase.TestCase):
  67     """ODL test runner."""
  68
  69     odl_test_repo = constants.CONST.__getattribute__('dir_repo_odl_test')
  70     neutron_suite_dir = os.path.join(odl_test_repo,
  71                                      "csit/suites/openstack/neutron")
  72     basic_suite_dir = os.path.join(odl_test_repo,
  73                                    "csit/suites/integration/basic")
  74     default_suites = [basic_suite_dir, neutron_suite_dir]
  75     res_dir = os.path.join(
  76         constants.CONST.__getattribute__('dir_results'), 'odl')
  77     __logger = logging.getLogger(__name__)
  78
  79     @classmethod
  80     def set_robotframework_vars(cls, odlusername="admin", odlpassword="admin"):
  81         """Set credentials in csit/variables/Variables.py.
  82
  83         Returns:
  84             True if credentials are set.
  85             False otherwise.
  86         """
  87         odl_variables_files = os.path.join(cls.odl_test_repo,
  88                                            'csit/variables/Variables.py')
  89         try:
  90             for line in fileinput.input(odl_variables_files,
  91                                         inplace=True):
  92                 print(re.sub("AUTH = .*",
  93                              ("AUTH = [u'" + odlusername + "', u'" +
  94                               odlpassword + "']"),
  95                              line.rstrip()))
  96             return True
  97         except Exception as ex:  # pylint: disable=broad-except
  98             cls.__logger.error("Cannot set ODL creds: %s", str(ex))
  99             return False
 100
 101     def parse_results(self):
 102         """Parse output.xml and get the details in it."""
 103         xml_file = os.path.join(self.res_dir, 'output.xml')
 104         result = robot.api.ExecutionResult(xml_file)
 105         visitor = ODLResultVisitor()
 106         result.visit(visitor)
 107         try:
 108             self.result = 100 * (
 109                 result.suite.statistics.critical.passed /
 110                 result.suite.statistics.critical.total)
 111         except ZeroDivisionError:
 112             self.__logger.error("No test has been run")
 113         self.start_time = timestamp_to_secs(result.suite.starttime)
 114         self.stop_time = timestamp_to_secs(result.suite.endtime)
 115         self.details = {}
 116         self.details['description'] = result.suite.name
 117         self.details['tests'] = visitor.get_data()
 118
 119     def run_suites(self, suites=None, **kwargs):
 120         """Run the test suites
 121
 122         It has been designed to be called in any context.
 123         It requires the following keyword arguments:
 124
 125            * odlusername,
 126            * odlpassword,
 127            * osauthurl,
 128            * neutronip,
 129            * osusername,
 130            * ostenantname,
 131            * ospassword,
 132            * odlip,
 133            * odlwebport,
 134            * odlrestconfport.
 135
 136         Here are the steps:
 137            * set all RobotFramework_variables,
 138            * create the output directories if required,
 139            * get the results in output.xml,
 140            * delete temporary files.
 141
 142         Args:
 143             kwargs: Arbitrary keyword arguments.
 144
 145         Returns:
 146             EX_OK if all suites ran well.
 147             EX_RUN_ERROR otherwise.
 148         """
 149         try:
 150             if not suites:
 151                 suites = self.default_suites
 152             odlusername = kwargs['odlusername']
 153             odlpassword = kwargs['odlpassword']
 154             osauthurl = kwargs['osauthurl']
 155             keystoneip = urllib.parse.urlparse(osauthurl).hostname
 156             variables = ['KEYSTONE:' + keystoneip,
 157                          'NEUTRON:' + kwargs['neutronip'],
 158                          'OS_AUTH_URL:"' + osauthurl + '"',
 159                          'OSUSERNAME:"' + kwargs['osusername'] + '"',
 160                          ('OSUSERDOMAINNAME:"' +
 161                           kwargs['osuserdomainname'] + '"'),
 162                          'OSTENANTNAME:"' + kwargs['ostenantname'] + '"',
 163                          ('OSPROJECTDOMAINNAME:"' +
 164                           kwargs['osprojectdomainname'] + '"'),
 165                          'OSPASSWORD:"' + kwargs['ospassword'] + '"',
 166                          'ODL_SYSTEM_IP:' + kwargs['odlip'],
 167                          'PORT:' + kwargs['odlwebport'],
 168                          'RESTCONFPORT:' + kwargs['odlrestconfport']]
 169         except KeyError as ex:
 170             self.__logger.error("Cannot run ODL testcases. Please check "
 171                                 "%s", str(ex))
 172             return self.EX_RUN_ERROR
 173         if self.set_robotframework_vars(odlusername, odlpassword):
 174             try:
 175                 os.makedirs(self.res_dir)
 176             except OSError as ex:
 177                 if ex.errno != errno.EEXIST:
 178                     self.__logger.exception(
 179                         "Cannot create %s", self.res_dir)
 180                     return self.EX_RUN_ERROR
 181             output_dir = os.path.join(self.res_dir, 'output.xml')
 182             stream = StringIO()
 183             robot.run(*suites, variable=variables, output=output_dir,
 184                       log='NONE', report='NONE', stdout=stream)
 185             self.__logger.info("\n" + stream.getvalue())
 186             self.__logger.info("ODL results were successfully generated")
 187             try:
 188                 self.parse_results()
 189                 self.__logger.info("ODL results were successfully parsed")
 190             except RobotError as ex:
 191                 self.__logger.error("Run tests before publishing: %s",
 192                                     ex.message)
 193                 return self.EX_RUN_ERROR
 194             return self.EX_OK
 195         else:
 196             return self.EX_RUN_ERROR
 197
 198     def run(self, **kwargs):
 199         """Run suites in OPNFV environment
 200
 201         It basically check env vars to call main() with the keywords
 202         required.
 203
 204         Args:
 205             kwargs: Arbitrary keyword arguments.
 206
 207         Returns:
 208             EX_OK if all suites ran well.
 209             EX_RUN_ERROR otherwise.
 210         """
 211         try:
 212             suites = self.default_suites
 213             try:
 214                 suites = kwargs["suites"]
 215             except KeyError:
 216                 pass
 217             neutron_url = op_utils.get_endpoint(service_type='network')
 218             kwargs = {'neutronip': urllib.parse.urlparse(neutron_url).hostname}
 219             kwargs['odlip'] = kwargs['neutronip']
 220             kwargs['odlwebport'] = '8080'
 221             kwargs['odlrestconfport'] = '8181'
 222             kwargs['odlusername'] = 'admin'
 223             kwargs['odlpassword'] = 'admin'
 224             installer_type = None
 225             if 'INSTALLER_TYPE' in os.environ:
 226                 installer_type = os.environ['INSTALLER_TYPE']
 227             kwargs['osusername'] = os.environ['OS_USERNAME']
 228             kwargs['osuserdomainname'] = os.environ.get(
 229                 'OS_USER_DOMAIN_NAME', 'Default')
 230             kwargs['ostenantname'] = os.environ['OS_TENANT_NAME']
 231             kwargs['osprojectdomainname'] = os.environ.get(
 232                 'OS_PROJECT_DOMAIN_NAME', 'Default')
 233             kwargs['osauthurl'] = os.environ['OS_AUTH_URL']
 234             kwargs['ospassword'] = os.environ['OS_PASSWORD']
 235             if installer_type == 'fuel':
 236                 kwargs['odlwebport'] = '8181'
 237                 kwargs['odlrestconfport'] = '8282'
 238             elif installer_type == 'apex' or installer_type == 'netvirt':
 239                 kwargs['odlip'] = os.environ['SDN_CONTROLLER_IP']
 240                 kwargs['odlwebport'] = '8081'
 241                 kwargs['odlrestconfport'] = '8081'
 242             elif installer_type == 'joid':
 243                 kwargs['odlip'] = os.environ['SDN_CONTROLLER']
 244             elif installer_type == 'compass':
 245                 kwargs['odlrestconfport'] = '8080'
 246             elif installer_type == 'daisy':
 247                 kwargs['odlip'] = os.environ['SDN_CONTROLLER_IP']
 248                 kwargs['odlwebport'] = '8181'
 249                 kwargs['odlrestconfport'] = '8087'
 250             else:
 251                 kwargs['odlip'] = os.environ['SDN_CONTROLLER_IP']
 252         except KeyError as ex:
 253             self.__logger.error("Cannot run ODL testcases. "
 254                                 "Please check env var: "
 255                                 "%s", str(ex))
 256             return self.EX_RUN_ERROR
 257         except Exception:  # pylint: disable=broad-except
 258             self.__logger.exception("Cannot run ODL testcases.")
 259             return self.EX_RUN_ERROR
 260
 261         return self.run_suites(suites, **kwargs)
 262
 263
 264 class ODLParser(object):  # pylint: disable=too-few-public-methods
 265     """Parser to run ODL test suites."""
 266
 267     def __init__(self):
 268         self.parser = argparse.ArgumentParser()
 269         self.parser.add_argument(
 270             '-n', '--neutronip', help='Neutron IP',
 271             default='127.0.0.1')
 272         self.parser.add_argument(
 273             '-k', '--osauthurl', help='OS_AUTH_URL as defined by OpenStack',
 274             default='http://127.0.0.1:5000/v3')
 275         self.parser.add_argument(
 276             '-a', '--osusername', help='Username for OpenStack',
 277             default='admin')
 278         self.parser.add_argument(
 279             '-f', '--osuserdomainname', help='User domain name for OpenStack',
 280             default='Default')
 281         self.parser.add_argument(
 282             '-b', '--ostenantname', help='Tenantname for OpenStack',
 283             default='admin')
 284         self.parser.add_argument(
 285             '-g', '--osprojectdomainname',
 286             help='Project domain name for OpenStack',
 287             default='Default')
 288         self.parser.add_argument(
 289             '-c', '--ospassword', help='Password for OpenStack',
 290             default='admin')
 291         self.parser.add_argument(
 292             '-o', '--odlip', help='OpenDaylight IP',
 293             default='127.0.0.1')
 294         self.parser.add_argument(
 295             '-w', '--odlwebport', help='OpenDaylight Web Portal Port',
 296             default='8080')
 297         self.parser.add_argument(
 298             '-r', '--odlrestconfport', help='OpenDaylight RESTConf Port',
 299             default='8181')
 300         self.parser.add_argument(
 301             '-d', '--odlusername', help='Username for ODL',
 302             default='admin')
 303         self.parser.add_argument(
 304             '-e', '--odlpassword', help='Password for ODL',
 305             default='admin')
 306         self.parser.add_argument(
 307             '-p', '--pushtodb', help='Push results to DB',
 308             action='store_true')
 309
 310     def parse_args(self, argv=None):
 311         """Parse arguments.
 312
 313         It can call sys.exit if arguments are incorrect.
 314
 315         Returns:
 316             the arguments from cmdline
 317         """
 318         if not argv:
 319             argv = []
 320         return vars(self.parser.parse_args(argv))
 321
 322
 323 def main():
 324     """Entry point"""
 325     logging.basicConfig()
 326     odl = ODLTests()
 327     parser = ODLParser()
 328     args = parser.parse_args(sys.argv[1:])
 329     try:
 330         result = odl.run_suites(ODLTests.default_suites, **args)
 331         if result != testcase.TestCase.EX_OK:
 332             return result
 333         if args['pushtodb']:
 334             return odl.push_to_db()
 335         else:
 336             return result
 337     except Exception:  # pylint: disable=broad-except
 338         return testcase.TestCase.EX_RUN_ERROR