functest/opnfv_tests/vnf/ims/orchestra_clearwaterims.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 """Orchestra Clearwater IMS testcase implementation."""
  11
  12 import json
  13 import logging
  14 import os
  15 import socket
  16 import time
  17 import pkg_resources
  18 import yaml
  19
  20 from snaps.openstack.create_image import OpenStackImage, ImageSettings
  21 from snaps.openstack.create_flavor import OpenStackFlavor, FlavorSettings
  22 from snaps.openstack.create_security_group import (
  23     OpenStackSecurityGroup,
  24     SecurityGroupSettings,
  25     SecurityGroupRuleSettings,
  26     Direction,
  27     Protocol)
  28 from snaps.openstack.create_network import (
  29     OpenStackNetwork,
  30     NetworkSettings,
  31     SubnetSettings,
  32     PortSettings)
  33 from snaps.openstack.create_router import OpenStackRouter, RouterSettings
  34 from snaps.openstack.create_instance import (
  35     VmInstanceSettings,
  36     OpenStackVmInstance)
  37 from functest.opnfv_tests.openstack.snaps import snaps_utils
  38
  39 import functest.core.vnf as vnf
  40 import functest.utils.openstack_utils as os_utils
  41 from functest.utils.constants import CONST
  42
  43 from org.openbaton.cli.errors.errors import NfvoException
  44 from org.openbaton.cli.agents.agents import MainAgent
  45
  46
  47 __author__ = "Pauls, Michael <michael.pauls@fokus.fraunhofer.de>"
  48 # ----------------------------------------------------------
  49 #
  50 #               UTILS
  51 #
  52 # -----------------------------------------------------------
  53
  54
  55 def get_config(parameter, file_path):
  56     """
  57     Get config parameter.
  58
  59     Returns the value of a given parameter in file.yaml
  60     parameter must be given in string format with dots
  61     Example: general.openstack.image_name
  62     """
  63     with open(file_path) as config_file:
  64         file_yaml = yaml.safe_load(config_file)
  65     config_file.close()
  66     value = file_yaml
  67     for element in parameter.split("."):
  68         value = value.get(element)
  69         if value is None:
  70             raise ValueError("The parameter %s is not defined in"
  71                              " reporting.yaml", parameter)
  72     return value
  73
  74
  75 def servertest(host, port):
  76     """Method to test that a server is reachable at IP:port"""
  77     args = socket.getaddrinfo(host, port, socket.AF_INET, socket.SOCK_STREAM)
  78     for family, socktype, proto, canonname, sockaddr in args:
  79         sock = socket.socket(family, socktype, proto)
  80         try:
  81             sock.connect(sockaddr)
  82         except socket.error:
  83             return False
  84         else:
  85             sock.close()
  86             return True
  87
  88
  89 def get_userdata(orchestrator=dict):
  90     """Build userdata for Open Baton machine"""
  91     userdata = "#!/bin/bash\n"
  92     userdata += "echo \"Executing userdata...\"\n"
  93     userdata += "set -x\n"
  94     userdata += "set -e\n"
  95     userdata += "echo \"Set nameserver to '8.8.8.8'...\"\n"
  96     userdata += "echo \"nameserver   8.8.8.8\" >> /etc/resolv.conf\n"
  97     userdata += "echo \"Install curl...\"\n"
  98     userdata += "apt-get install curl\n"
  99     userdata += "echo \"Inject public key...\"\n"
 100     userdata += ("echo \"ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCuPXrV3"
 101                  "geeHc6QUdyUr/1Z+yQiqLcOskiEGBiXr4z76MK4abiFmDZ18OMQlc"
 102                  "fl0p3kS0WynVgyaOHwZkgy/DIoIplONVr2CKBKHtPK+Qcme2PVnCtv"
 103                  "EqItl/FcD+1h5XSQGoa+A1TSGgCod/DPo+pes0piLVXP8Ph6QS1k7S"
 104                  "ic7JDeRQ4oT1bXYpJ2eWBDMfxIWKZqcZRiGPgMIbJ1iEkxbpeaAd9O"
 105                  "4MiM9nGCPESmed+p54uYFjwEDlAJZShcAZziiZYAvMZhvAhe6USljc"
 106                  "7YAdalAnyD/jwCHuwIrUw/lxo7UdNCmaUxeobEYyyFA1YVXzpNFZya"
 107                  "XPGAAYIJwEq/ openbaton@opnfv\" >> /home/ubuntu/.ssh/aut"
 108                  "horized_keys\n")
 109     userdata += "echo \"Download bootstrap...\"\n"
 110     userdata += ("curl -s %s "
 111                  "> ./bootstrap\n" % orchestrator['bootstrap']['url'])
 112     userdata += ("curl -s %s" "> ./config_file\n" %
 113                  orchestrator['bootstrap']['config']['url'])
 114     userdata += ("echo \"Disable usage of mysql...\"\n")
 115     userdata += "sed -i s/mysql=.*/mysql=no/g /config_file\n"
 116     userdata += ("echo \"Setting 'rabbitmq_broker_ip' to '%s'\"\n"
 117                  % orchestrator['details']['fip'].ip)
 118     userdata += ("sed -i s/rabbitmq_broker_ip=localhost/rabbitmq_broker_ip"
 119                  "=%s/g /config_file\n" % orchestrator['details']['fip'].ip)
 120     userdata += "echo \"Set autostart of components to 'false'\"\n"
 121     userdata += "export OPENBATON_COMPONENT_AUTOSTART=false\n"
 122     userdata += "echo \"Execute bootstrap...\"\n"
 123     bootstrap = "sh ./bootstrap release -configFile=./config_file"
 124     userdata += bootstrap + "\n"
 125     userdata += "echo \"Setting 'nfvo.plugin.timeout' to '300000'\"\n"
 126     userdata += ("echo \"nfvo.plugin.timeout=600000\" >> "
 127                  "/etc/openbaton/openbaton-nfvo.properties\n")
 128     userdata += (
 129         "wget %s -O /etc/openbaton/openbaton-vnfm-generic-user-data.sh\n" %
 130         orchestrator['gvnfm']['userdata']['url'])
 131     userdata += "sed -i '113i"'\ \ \ \ '"sleep 60' " \
 132                 "/etc/openbaton/openbaton-vnfm-generic-user-data.sh\n"
 133     userdata += ("sed -i s/nfvo.marketplace.port=8082/nfvo.marketplace."
 134                  "port=8080/g /etc/openbaton/openbaton-nfvo.properties\n")
 135     userdata += "echo \"Starting NFVO\"\n"
 136     userdata += "service openbaton-nfvo restart\n"
 137     userdata += "echo \"Starting Generic VNFM\"\n"
 138     userdata += "service openbaton-vnfm-generic restart\n"
 139     userdata += "echo \"...end of userdata...\"\n"
 140     return userdata
 141
 142
 143 class ClearwaterImsVnf(vnf.VnfOnBoarding):
 144     """Clearwater IMS VNF deployed with openBaton orchestrator"""
 145
 146     # logger = logging.getLogger(__name__)
 147
 148     def __init__(self, **kwargs):
 149         if "case_name" not in kwargs:
 150             kwargs["case_name"] = "orchestra_clearwaterims"
 151         super(ClearwaterImsVnf, self).__init__(**kwargs)
 152         self.logger = logging.getLogger("functest.ci.run_tests.orchestra")
 153         self.logger.info("kwargs %s", (kwargs))
 154
 155         self.case_dir = pkg_resources.resource_filename(
 156             'functest', 'opnfv_tests/vnf/ims/')
 157         self.data_dir = CONST.__getattribute__('dir_ims_data')
 158         self.test_dir = CONST.__getattribute__('dir_repo_vims_test')
 159         self.created_resources = []
 160         self.logger.info("%s VNF onboarding test starting", self.case_name)
 161
 162         try:
 163             self.config = CONST.__getattribute__(
 164                 'vnf_{}_config'.format(self.case_name))
 165         except BaseException:
 166             raise Exception("Orchestra VNF config file not found")
 167         config_file = self.case_dir + self.config
 168
 169         self.mano = dict(
 170             get_config("mano", config_file),
 171             details={}
 172         )
 173         self.logger.debug("Orchestrator configuration %s", self.mano)
 174
 175         self.details['orchestrator'] = dict(
 176             name=self.mano['name'],
 177             version=self.mano['version'],
 178             status='ERROR',
 179             result=''
 180         )
 181
 182         self.vnf = dict(
 183             get_config(self.case_name, config_file),
 184         )
 185         self.logger.debug("VNF configuration: %s", self.vnf)
 186
 187         self.details['vnf'] = dict(
 188             name=self.vnf['name'],
 189         )
 190
 191         self.details['test_vnf'] = dict(
 192             name=self.case_name,
 193         )
 194
 195         # Orchestra base Data directory creation
 196         if not os.path.exists(self.data_dir):
 197             os.makedirs(self.data_dir)
 198
 199         self.images = get_config("tenant_images.orchestrator", config_file)
 200         self.images.update(
 201             get_config(
 202                 "tenant_images.%s" %
 203                 self.case_name,
 204                 config_file))
 205         self.snaps_creds = None
 206
 207     def prepare(self):
 208         """Prepare testscase (Additional pre-configuration steps)."""
 209         super(ClearwaterImsVnf, self).prepare()
 210
 211         self.logger.info("Additional pre-configuration steps")
 212
 213         self.creds = {
 214                 "tenant": self.tenant_name,
 215                 "username": self.tenant_name,
 216                 "password": self.tenant_name,
 217                 "auth_url": os_utils.get_credentials()['auth_url']
 218                 }
 219         self.prepare_images()
 220         self.prepare_flavor()
 221         self.prepare_security_groups()
 222         self.prepare_network()
 223         self.prepare_floating_ip()
 224
 225     def prepare_images(self):
 226         """Upload images if they doen't exist yet"""
 227         self.logger.info("Upload images if they doen't exist yet")
 228         for image_name, image_file in self.images.iteritems():
 229             self.logger.info("image: %s, file: %s", image_name, image_file)
 230             if image_file and image_name:
 231                 image = OpenStackImage(
 232                     self.snaps_creds,
 233                     ImageSettings(name=image_name,
 234                                   image_user='cloud',
 235                                   img_format='qcow2',
 236                                   image_file=image_file,
 237                                   public=True))
 238                 image.create()
 239                 # self.created_resources.append(image);
 240
 241     def prepare_security_groups(self):
 242         """Create Open Baton security group if it doesn't exist yet"""
 243         self.logger.info(
 244             "Creating security group for Open Baton if not yet existing...")
 245         sg_rules = list()
 246         sg_rules.append(
 247             SecurityGroupRuleSettings(
 248                 sec_grp_name="orchestra-sec-group-allowall",
 249                 direction=Direction.ingress,
 250                 protocol=Protocol.tcp,
 251                 port_range_min=1,
 252                 port_range_max=65535))
 253         sg_rules.append(
 254             SecurityGroupRuleSettings(
 255                 sec_grp_name="orchestra-sec-group-allowall",
 256                 direction=Direction.egress,
 257                 protocol=Protocol.tcp,
 258                 port_range_min=1,
 259                 port_range_max=65535))
 260         sg_rules.append(
 261             SecurityGroupRuleSettings(
 262                 sec_grp_name="orchestra-sec-group-allowall",
 263                 direction=Direction.ingress,
 264                 protocol=Protocol.udp,
 265                 port_range_min=1,
 266                 port_range_max=65535))
 267         sg_rules.append(
 268             SecurityGroupRuleSettings(
 269                 sec_grp_name="orchestra-sec-group-allowall",
 270                 direction=Direction.egress,
 271                 protocol=Protocol.udp,
 272                 port_range_min=1,
 273                 port_range_max=65535))
 274         security_group = OpenStackSecurityGroup(
 275             self.snaps_creds,
 276             SecurityGroupSettings(
 277                 name="orchestra-sec-group-allowall",
 278                 rule_settings=sg_rules))
 279
 280         security_group_info = security_group.create()
 281         self.created_resources.append(security_group)
 282         self.mano['details']['sec_group'] = security_group_info.name
 283         self.logger.info(
 284             "Security group orchestra-sec-group-allowall prepared")
 285
 286     def prepare_flavor(self):
 287         """Create Open Baton flavor if it doesn't exist yet"""
 288         self.logger.info(
 289             "Create Flavor for Open Baton NFVO if not yet existing")
 290
 291         flavor_settings = FlavorSettings(
 292             name=self.mano['requirements']['flavor']['name'],
 293             ram=self.mano['requirements']['flavor']['ram_min'],
 294             disk=self.mano['requirements']['flavor']['disk'],
 295             vcpus=self.mano['requirements']['flavor']['vcpus'])
 296         flavor = OpenStackFlavor(self.snaps_creds, flavor_settings)
 297         flavor_info = flavor.create()
 298         self.created_resources.append(flavor)
 299         self.mano['details']['flavor'] = {}
 300         self.mano['details']['flavor']['name'] = flavor_settings.name
 301         self.mano['details']['flavor']['id'] = flavor_info.id
 302
 303     def prepare_network(self):
 304         """Create network/subnet/router if they doen't exist yet"""
 305         self.logger.info(
 306             "Creating network/subnet/router if they doen't exist yet...")
 307         subnet_settings = SubnetSettings(
 308             name='%s_subnet' %
 309             self.case_name,
 310             cidr="192.168.100.0/24")
 311         network_settings = NetworkSettings(
 312             name='%s_net' %
 313             self.case_name,
 314             subnet_settings=[subnet_settings])
 315         orchestra_network = OpenStackNetwork(
 316             self.snaps_creds, network_settings)
 317         orchestra_network_info = orchestra_network.create()
 318         self.mano['details']['network'] = {}
 319         self.mano['details']['network']['id'] = orchestra_network_info.id
 320         self.mano['details']['network']['name'] = orchestra_network_info.name
 321         self.mano['details']['external_net_name'] = snaps_utils.\
 322             get_ext_net_name(self.snaps_creds)
 323         self.created_resources.append(orchestra_network)
 324         orchestra_router = OpenStackRouter(
 325             self.snaps_creds,
 326             RouterSettings(
 327                 name='%s_router' %
 328                 self.case_name,
 329                 external_gateway=self.mano['details']['external_net_name'],
 330                 internal_subnets=[
 331                     subnet_settings.name]))
 332         orchestra_router.create()
 333         self.created_resources.append(orchestra_router)
 334         self.logger.info("Created network and router for Open Baton NFVO...")
 335
 336     def prepare_floating_ip(self):
 337         """Select/Create Floating IP if it doesn't exist yet"""
 338         self.logger.info("Retrieving floating IP for Open Baton NFVO")
 339         neutron_client = snaps_utils.neutron_utils.neutron_client(
 340             self.snaps_creds)
 341         # Finding Tenant ID to check to which tenant the Floating IP belongs
 342         tenant_id = os_utils.get_tenant_id(
 343             os_utils.get_keystone_client(self.creds),
 344             self.tenant_name)
 345         # Use os_utils to retrieve complete information of Floating IPs
 346         floating_ips = os_utils.get_floating_ips(neutron_client)
 347         my_floating_ips = []
 348         # Filter Floating IPs with tenant id
 349         for floating_ip in floating_ips:
 350             # self.logger.info("Floating IP: %s", floating_ip)
 351             if floating_ip.get('tenant_id') == tenant_id:
 352                 my_floating_ips.append(floating_ip.get('floating_ip_address'))
 353         # Select if Floating IP exist else create new one
 354         if len(my_floating_ips) >= 1:
 355             # Get Floating IP object from snaps for clean up
 356             snaps_floating_ips = snaps_utils.neutron_utils.get_floating_ips(
 357                 neutron_client)
 358             for my_floating_ip in my_floating_ips:
 359                 for snaps_floating_ip in snaps_floating_ips:
 360                     if snaps_floating_ip.ip == my_floating_ip:
 361                         self.mano['details']['fip'] = snaps_floating_ip
 362                         self.logger.info(
 363                             "Selected floating IP for Open Baton NFVO %s",
 364                             (self.mano['details']['fip'].ip))
 365                         break
 366                 if self.mano['details']['fip'] is not None:
 367                     break
 368         else:
 369             self.logger.info("Creating floating IP for Open Baton NFVO")
 370             self.mano['details']['fip'] = snaps_utils.neutron_utils.\
 371                 create_floating_ip(
 372                     neutron_client,
 373                     self.mano['details']['external_net_name'])
 374             self.logger.info(
 375                 "Created floating IP for Open Baton NFVO %s",
 376                 (self.mano['details']['fip'].ip))
 377
 378     def get_vim_descriptor(self):
 379         """"Create VIM descriptor to be used for onboarding"""
 380         self.logger.info(
 381             "Building VIM descriptor with PoP creds: %s",
 382             self.creds)
 383         # Depending on API version either tenant ID or project name must be
 384         # used
 385         if os_utils.is_keystone_v3():
 386             self.logger.info(
 387                 "Using v3 API of OpenStack... -> Using OS_PROJECT_ID")
 388             project_id = os_utils.get_tenant_id(
 389                 os_utils.get_keystone_client(),
 390                 self.creds.get("project_name"))
 391         else:
 392             self.logger.info(
 393                 "Using v2 API of OpenStack... -> Using OS_TENANT_NAME")
 394             project_id = self.creds.get("tenant_name")
 395         self.logger.debug("VIM project/tenant id: %s", project_id)
 396         vim_json = {
 397             "name": "vim-instance",
 398             "authUrl": self.creds.get("auth_url"),
 399             "tenant": project_id,
 400             "username": self.creds.get("username"),
 401             "password": self.creds.get("password"),
 402             "securityGroups": [
 403                 self.mano['details']['sec_group']
 404             ],
 405             "type": "openstack",
 406             "location": {
 407                 "name": "opnfv",
 408                 "latitude": "52.525876",
 409                 "longitude": "13.314400"
 410             }
 411         }
 412         self.logger.info("Built VIM descriptor: %s", vim_json)
 413         return vim_json
 414
 415     def deploy_orchestrator(self):
 416         self.logger.info("Deploying Open Baton...")
 417         self.logger.info("Details: %s", self.mano['details'])
 418         start_time = time.time()
 419
 420         self.logger.info("Creating orchestra instance...")
 421         userdata = get_userdata(self.mano)
 422         self.logger.info("flavor: %s\n"
 423                          "image: %s\n"
 424                          "network_id: %s\n",
 425                          self.mano['details']['flavor']['name'],
 426                          self.mano['requirements']['image'],
 427                          self.mano['details']['network']['id'])
 428         self.logger.debug("userdata: %s\n", userdata)
 429         # setting up image
 430         image_settings = ImageSettings(
 431             name=self.mano['requirements']['image'],
 432             image_user='ubuntu',
 433             exists=True)
 434         # setting up port
 435         port_settings = PortSettings(
 436             name='%s_port' % self.case_name,
 437             network_name=self.mano['details']['network']['name'])
 438         # build configuration of vm
 439         orchestra_settings = VmInstanceSettings(
 440             name=self.case_name,
 441             flavor=self.mano['details']['flavor']['name'],
 442             port_settings=[port_settings],
 443             security_group_names=[self.mano['details']['sec_group']],
 444             userdata=str(userdata))
 445         orchestra_vm = OpenStackVmInstance(self.snaps_creds,
 446                                            orchestra_settings,
 447                                            image_settings)
 448
 449         orchestra_vm.create()
 450         self.created_resources.append(orchestra_vm)
 451         self.mano['details']['id'] = orchestra_vm.get_vm_info()['id']
 452         self.logger.info(
 453             "Created orchestra instance: %s",
 454             self.mano['details']['id'])
 455
 456         self.logger.info("Associating floating ip: '%s' to VM '%s' ",
 457                          self.mano['details']['fip'].ip,
 458                          self.case_name)
 459         nova_client = os_utils.get_nova_client()
 460         if not os_utils.add_floating_ip(
 461                 nova_client,
 462                 self.mano['details']['id'],
 463                 self.mano['details']['fip'].ip):
 464             duration = time.time() - start_time
 465             self.details["orchestrator"].update(
 466                 status='FAIL', duration=duration)
 467             self.logger.error("Cannot associate floating IP to VM.")
 468             return False
 469
 470         self.logger.info("Waiting for Open Baton NFVO to be up and running...")
 471         timeout = 0
 472         while timeout < 45:
 473             if servertest(
 474                     self.mano['details']['fip'].ip,
 475                     "8080"):
 476                 break
 477             else:
 478                 self.logger.info(
 479                     "Open Baton NFVO is not started yet (%ss)",
 480                     (timeout * 60))
 481                 time.sleep(60)
 482                 timeout += 1
 483
 484         if timeout >= 45:
 485             duration = time.time() - start_time
 486             self.details["orchestrator"].update(
 487                 status='FAIL', duration=duration)
 488             self.logger.error("Open Baton is not started correctly")
 489             return False
 490
 491         self.logger.info("Waiting for all components to be up and running...")
 492         time.sleep(60)
 493         duration = time.time() - start_time
 494         self.details["orchestrator"].update(status='PASS', duration=duration)
 495         self.logger.info("Deploy Open Baton NFVO: OK")
 496         return True
 497
 498     def deploy_vnf(self):
 499         start_time = time.time()
 500         self.logger.info("Deploying %s...", self.vnf['name'])
 501
 502         main_agent = MainAgent(
 503             nfvo_ip=self.mano['details']['fip'].ip,
 504             nfvo_port=8080,
 505             https=False,
 506             version=1,
 507             username=self.mano['credentials']['username'],
 508             password=self.mano['credentials']['password'])
 509
 510         self.logger.info(
 511             "Create %s Flavor if not existing", self.vnf['name'])
 512         flavor_settings = FlavorSettings(
 513             name=self.vnf['requirements']['flavor']['name'],
 514             ram=self.vnf['requirements']['flavor']['ram_min'],
 515             disk=self.vnf['requirements']['flavor']['disk'],
 516             vcpus=self.vnf['requirements']['flavor']['vcpus'])
 517         flavor = OpenStackFlavor(self.snaps_creds, flavor_settings)
 518         flavor_info = flavor.create()
 519         self.logger.debug("Flavor id: %s", flavor_info.id)
 520
 521         self.logger.info("Getting project 'default'...")
 522         project_agent = main_agent.get_agent("project", "")
 523         for project in json.loads(project_agent.find()):
 524             if project.get("name") == "default":
 525                 self.mano['details']['project_id'] = project.get("id")
 526                 self.logger.info("Found project 'default': %s", project)
 527                 break
 528
 529         vim_json = self.get_vim_descriptor()
 530         self.logger.info("Registering VIM: %s", vim_json)
 531
 532         main_agent.get_agent(
 533             "vim", project_id=self.mano['details']['project_id']).create(
 534                 entity=json.dumps(vim_json))
 535
 536         market_agent = main_agent.get_agent(
 537             "market", project_id=self.mano['details']['project_id'])
 538
 539         try:
 540             self.logger.info("sending: %s", self.vnf['descriptor']['url'])
 541             nsd = market_agent.create(entity=self.vnf['descriptor']['url'])
 542             if nsd.get('id') is None:
 543                 self.logger.error("NSD not onboarded correctly")
 544                 duration = time.time() - start_time
 545                 self.details["vnf"].update(status='FAIL', duration=duration)
 546                 return False
 547             self.mano['details']['nsd_id'] = nsd.get('id')
 548             self.logger.info("Onboarded NSD: " + nsd.get("name"))
 549
 550             nsr_agent = main_agent.get_agent(
 551                 "nsr", project_id=self.mano['details']['project_id'])
 552
 553             self.mano['details']['nsr'] = nsr_agent.create(
 554                 self.mano['details']['nsd_id'])
 555         except NfvoException as exc:
 556             self.logger.error(exc.message)
 557             duration = time.time() - start_time
 558             self.details["vnf"].update(status='FAIL', duration=duration)
 559             return False
 560
 561         if self.mano['details']['nsr'].get('code') is not None:
 562             self.logger.error(
 563                 "%s cannot be deployed: %s -> %s",
 564                 self.vnf['name'],
 565                 self.mano['details']['nsr'].get('code'),
 566                 self.mano['details']['nsr'].get('message'))
 567             self.logger.error("%s cannot be deployed", self.vnf['name'])
 568             duration = time.time() - start_time
 569             self.details["vnf"].update(status='FAIL', duration=duration)
 570             return False
 571
 572         timeout = 0
 573         self.logger.info("Waiting for NSR to go to ACTIVE...")
 574         while self.mano['details']['nsr'].get("status") != 'ACTIVE' \
 575                 and self.mano['details']['nsr'].get("status") != 'ERROR':
 576             timeout += 1
 577             self.logger.info("NSR is not yet ACTIVE... (%ss)", 60 * timeout)
 578             if timeout == 30:
 579                 self.logger.error("INACTIVE NSR after %s sec..", 60 * timeout)
 580                 duration = time.time() - start_time
 581                 self.details["vnf"].update(status='FAIL', duration=duration)
 582                 return False
 583             time.sleep(60)
 584             self.mano['details']['nsr'] = json.loads(
 585                 nsr_agent.find(self.mano['details']['nsr'].get('id')))
 586
 587         duration = time.time() - start_time
 588         if self.mano['details']['nsr'].get("status") == 'ACTIVE':
 589             self.details["vnf"].update(status='PASS', duration=duration)
 590             self.logger.info("Sleep for 60s to ensure that all "
 591                              "services are up and running...")
 592             time.sleep(60)
 593             result = True
 594         else:
 595             self.details["vnf"].update(status='FAIL', duration=duration)
 596             self.logger.error("NSR: %s", self.mano['details'].get('nsr'))
 597             result = False
 598         return result
 599
 600     def test_vnf(self):
 601         self.logger.info(
 602             "Testing VNF Clearwater IMS is not yet implemented...")
 603         start_time = time.time()
 604
 605         duration = time.time() - start_time
 606         self.details["test_vnf"].update(status='PASS', duration=duration)
 607         self.logger.info("Test VNF: OK")
 608         return True
 609
 610     def clean(self):
 611         self.logger.info("Cleaning %s...", self.case_name)
 612         try:
 613             main_agent = MainAgent(
 614                 nfvo_ip=self.mano['details']['fip'].ip,
 615                 nfvo_port=8080,
 616                 https=False,
 617                 version=1,
 618                 username=self.mano['credentials']['username'],
 619                 password=self.mano['credentials']['password'])
 620             self.logger.info("Terminating %s...", self.vnf['name'])
 621             if (self.mano['details'].get('nsr')):
 622                 main_agent.get_agent(
 623                     "nsr",
 624                     project_id=self.mano['details']['project_id']).delete(
 625                         self.mano['details']['nsr'].get('id'))
 626                 self.logger.info("Sleeping 60 seconds...")
 627                 time.sleep(60)
 628             else:
 629                 self.logger.info("No need to terminate the VNF...")
 630             # os_utils.delete_instance(nova_client=os_utils.get_nova_client(),
 631             #                          instance_id=self.mano_instance_id)
 632         except (NfvoException, KeyError) as exc:
 633             self.logger.error('Unexpected error cleaning - %s', exc)
 634
 635         try:
 636             neutron_client = os_utils.get_neutron_client(self.creds)
 637             self.logger.info("Deleting Open Baton Port...")
 638             port = snaps_utils.neutron_utils.get_port(
 639                 neutron_client,
 640                 port_name='%s_port' % self.case_name)
 641             snaps_utils.neutron_utils.delete_port(neutron_client, port)
 642             time.sleep(10)
 643         except Exception as exc:
 644             self.logger.error('Unexpected error cleaning - %s', exc)
 645         try:
 646             self.logger.info("Deleting Open Baton Floating IP...")
 647             snaps_utils.neutron_utils.delete_floating_ip(
 648                 neutron_client, self.mano['details']['fip'])
 649         except Exception as exc:
 650             self.logger.error('Unexpected error cleaning - %s', exc)
 651
 652         for resource in reversed(self.created_resources):
 653             try:
 654                 self.logger.info("Cleaning %s", str(resource))
 655                 resource.clean()
 656             except Exception as exc:
 657                 self.logger.error('Unexpected error cleaning - %s', exc)
 658         super(ClearwaterImsVnf, self).clean()