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