Switch to snaps in orchestra testcases

It also stops using the floating ip in userdata to avoid a race
condition (all-in-one).

The DNS server is now configured by Neutron instead of the testcases.

Change-Id: I6efed71339d98403f7fd137ff50f1941b5b5a03c
Signed-off-by: Cédric Ollivier <cedric.ollivier@orange.com>

1 files changed, 50 insertions, 145 deletions

diff --git a/functest/opnfv_tests/vnf/ims/orchestra_clearwaterims.py b/functest/opnfv_tests/vnf/ims/orchestra_clearwaterims.py
index 7cfdf7b0..2d248b2e 100644
--- a/functest/opnfv_tests/vnf/ims/orchestra_clearwaterims.py
+++ b/functest/opnfv_tests/vnf/ims/orchestra_clearwaterims.py
@@ -14,11 +14,11 @@ import logging
 import os
 import socket
 import time
+
 import pkg_resources
 import yaml
 
-import functest.core.vnf as vnf
-import functest.utils.openstack_utils as os_utils
+from functest.core import vnf
 from functest.opnfv_tests.openstack.snaps import snaps_utils
 from functest.utils import config
 
@@ -30,6 +30,7 @@ from snaps.config.network import NetworkConfig, PortConfig, SubnetConfig
 from snaps.config.router import RouterConfig
 from snaps.config.security_group import (
     Direction, Protocol, SecurityGroupConfig, SecurityGroupRuleConfig)
+from snaps.config.vm_inst import FloatingIpConfig
 from snaps.config.vm_inst import VmInstanceConfig
 from snaps.openstack.utils import keystone_utils
 from snaps.openstack.create_flavor import OpenStackFlavor
@@ -71,7 +72,7 @@ def get_config(parameter, file_path):
 def servertest(host, port):
     """Method to test that a server is reachable at IP:port"""
     args = socket.getaddrinfo(host, port, socket.AF_INET, socket.SOCK_STREAM)
-    for family, socktype, proto, canonname, sockaddr in args:
+    for family, socktype, proto, _, sockaddr in args:
         sock = socket.socket(family, socktype, proto)
         try:
             sock.connect(sockaddr)
@@ -88,8 +89,6 @@ def get_userdata(orchestrator=dict):
     userdata += "echo \"Executing userdata...\"\n"
     userdata += "set -x\n"
     userdata += "set -e\n"
-    userdata += "echo \"Set nameserver to '8.8.8.8'...\"\n"
-    userdata += "echo \"nameserver   8.8.8.8\" >> /etc/resolv.conf\n"
     userdata += "echo \"Install curl...\"\n"
     userdata += "apt-get install curl\n"
     userdata += "echo \"Inject public key...\"\n"
@@ -109,10 +108,6 @@ def get_userdata(orchestrator=dict):
                  orchestrator['bootstrap']['config']['url'])
     userdata += ("echo \"Disable usage of mysql...\"\n")
     userdata += "sed -i s/mysql=.*/mysql=no/g /config_file\n"
-    userdata += ("echo \"Setting 'rabbitmq_broker_ip' to '%s'\"\n"
-                 % orchestrator['details']['fip'].ip)
-    userdata += ("sed -i s/rabbitmq_broker_ip=localhost/rabbitmq_broker_ip"
-                 "=%s/g /config_file\n" % orchestrator['details']['fip'].ip)
     userdata += "echo \"Set autostart of components to 'false'\"\n"
     userdata += "export OPENBATON_COMPONENT_AUTOSTART=false\n"
     userdata += "echo \"Execute bootstrap...\"\n"
@@ -199,7 +194,8 @@ class ClearwaterImsVnf(vnf.VnfOnBoarding):
                 "tenant_images.%s" %
                 self.case_name,
                 config_file))
-        self.snaps_creds = None
+        self.creds = None
+        self.orchestra_router = None
 
     def prepare(self):
         """Prepare testscase (Additional pre-configuration steps)."""
@@ -209,18 +205,15 @@ class ClearwaterImsVnf(vnf.VnfOnBoarding):
 
         public_auth_url = keystone_utils.get_endpoint(
             self.snaps_creds, 'identity')
-
         self.creds = {
-                "tenant": self.snaps_creds.project_name,
-                "username": self.snaps_creds.username,
-                "password": self.snaps_creds.password,
-                "auth_url": public_auth_url
-                }
+            "tenant": self.snaps_creds.project_name,
+            "username": self.snaps_creds.username,
+            "password": self.snaps_creds.password,
+            "auth_url": public_auth_url}
         self.prepare_images()
         self.prepare_flavor()
         self.prepare_security_groups()
         self.prepare_network()
-        self.prepare_floating_ip()
 
     def prepare_images(self):
         """Upload images if they doen't exist yet"""
@@ -236,7 +229,7 @@ class ClearwaterImsVnf(vnf.VnfOnBoarding):
                                 image_file=image_file,
                                 public=True))
                 image.create()
-                # self.created_resources.append(image);
+                self.created_resources.append(image)
 
     def prepare_security_groups(self):
         """Create Open Baton security group if it doesn't exist yet"""
@@ -245,48 +238,54 @@ class ClearwaterImsVnf(vnf.VnfOnBoarding):
         sg_rules = list()
         sg_rules.append(
             SecurityGroupRuleConfig(
-                sec_grp_name="orchestra-sec-group-allowall",
+                sec_grp_name="orchestra-sec-group-allowall-{}".format(
+                    self.uuid),
                 direction=Direction.ingress,
                 protocol=Protocol.tcp,
                 port_range_min=1,
                 port_range_max=65535))
         sg_rules.append(
             SecurityGroupRuleConfig(
-                sec_grp_name="orchestra-sec-group-allowall",
+                sec_grp_name="orchestra-sec-group-allowall-{}".format(
+                    self.uuid),
                 direction=Direction.egress,
                 protocol=Protocol.tcp,
                 port_range_min=1,
                 port_range_max=65535))
         sg_rules.append(
             SecurityGroupRuleConfig(
-                sec_grp_name="orchestra-sec-group-allowall",
+                sec_grp_name="orchestra-sec-group-allowall-{}".format(
+                    self.uuid),
                 direction=Direction.ingress,
                 protocol=Protocol.udp,
                 port_range_min=1,
                 port_range_max=65535))
         sg_rules.append(
             SecurityGroupRuleConfig(
-                sec_grp_name="orchestra-sec-group-allowall",
+                sec_grp_name="orchestra-sec-group-allowall-{}".format(
+                    self.uuid),
                 direction=Direction.egress,
                 protocol=Protocol.udp,
                 port_range_min=1,
                 port_range_max=65535))
         sg_rules.append(
             SecurityGroupRuleConfig(
-                sec_grp_name="orchestra-sec-group-allowall",
+                sec_grp_name="orchestra-sec-group-allowall-{}".format(
+                    self.uuid),
                 direction=Direction.ingress,
                 protocol=Protocol.icmp))
         sg_rules.append(
             SecurityGroupRuleConfig(
-                sec_grp_name="orchestra-sec-group-allowall",
+                sec_grp_name="orchestra-sec-group-allowall-{}".format(
+                    self.uuid),
                 direction=Direction.egress,
                 protocol=Protocol.icmp))
         security_group = OpenStackSecurityGroup(
             self.snaps_creds,
             SecurityGroupConfig(
-                name="orchestra-sec-group-allowall",
+                name="orchestra-sec-group-allowall-{}".format(
+                    self.uuid),
                 rule_settings=sg_rules))
-
         security_group_info = security_group.create()
         self.created_resources.append(security_group)
         self.mano['details']['sec_group'] = security_group_info.name
@@ -315,12 +314,10 @@ class ClearwaterImsVnf(vnf.VnfOnBoarding):
         self.logger.info(
             "Creating network/subnet/router if they doen't exist yet...")
         subnet_settings = SubnetConfig(
-            name='%s_subnet' %
-            self.case_name,
+            name='{}_subnet-{}'.format(self.case_name, self.uuid),
             cidr="192.168.100.0/24")
         network_settings = NetworkConfig(
-            name='%s_net' %
-            self.case_name,
+            name='{}_net-{}'.format(self.case_name, self.uuid),
             subnet_settings=[subnet_settings])
         orchestra_network = OpenStackNetwork(
             self.snaps_creds, network_settings)
@@ -331,78 +328,27 @@ class ClearwaterImsVnf(vnf.VnfOnBoarding):
         self.mano['details']['external_net_name'] = snaps_utils.\
             get_ext_net_name(self.snaps_creds)
         self.created_resources.append(orchestra_network)
-        orchestra_router = OpenStackRouter(
+        self.orchestra_router = OpenStackRouter(
             self.snaps_creds,
             RouterConfig(
-                name='%s_router' %
-                self.case_name,
+                name='{}_router-{}'.format(self.case_name, self.uuid),
                 external_gateway=self.mano['details']['external_net_name'],
                 internal_subnets=[
                     subnet_settings.name]))
-        orchestra_router.create()
-        self.created_resources.append(orchestra_router)
+        self.orchestra_router.create()
+        self.created_resources.append(self.orchestra_router)
         self.logger.info("Created network and router for Open Baton NFVO...")
 
-    def prepare_floating_ip(self):
-        """Select/Create Floating IP if it doesn't exist yet"""
-        self.logger.info("Retrieving floating IP for Open Baton NFVO")
-        neutron_client = snaps_utils.neutron_utils.neutron_client(
-            self.snaps_creds)
-        # Finding Tenant ID to check to which tenant the Floating IP belongs
-        tenant_id = os_utils.get_tenant_id(
-            os_utils.get_keystone_client(self.creds),
-            self.tenant_name)
-        # Use os_utils to retrieve complete information of Floating IPs
-        floating_ips = os_utils.get_floating_ips(neutron_client)
-        my_floating_ips = []
-        # Filter Floating IPs with tenant id
-        for floating_ip in floating_ips:
-            if floating_ip.get('tenant_id') == tenant_id:
-                my_floating_ips.append(floating_ip.get('floating_ip_address'))
-        # Select if Floating IP exist else create new one
-        if len(my_floating_ips) >= 1:
-            # Get Floating IP object from snaps for clean up
-            snaps_floating_ips = snaps_utils.neutron_utils.get_floating_ips(
-                neutron_client)
-            for my_floating_ip in my_floating_ips:
-                for snaps_floating_ip in snaps_floating_ips:
-                    if snaps_floating_ip.ip == my_floating_ip:
-                        self.mano['details']['fip'] = snaps_floating_ip
-                        self.logger.info(
-                            "Selected floating IP for Open Baton NFVO %s",
-                            (self.mano['details']['fip'].ip))
-                        break
-                if self.mano['details']['fip'] is not None:
-                    break
-        else:
-            self.logger.info("Creating floating IP for Open Baton NFVO")
-            keystone_client = os_utils.get_keystone_client(self.creds)
-            self.mano['details']['fip'] = snaps_utils.neutron_utils.\
-                create_floating_ip(
-                    neutron_client, keystone_client,
-                    self.mano['details']['external_net_name'])
-            self.logger.info(
-                "Created floating IP for Open Baton NFVO %s",
-                (self.mano['details']['fip'].ip))
-
     def get_vim_descriptor(self):
         """"Create VIM descriptor to be used for onboarding"""
         self.logger.info(
             "Building VIM descriptor with PoP creds: %s",
             self.creds)
-        # Depending on API version either tenant ID or project name must be
-        # used
-        if os_utils.is_keystone_v3():
-            self.logger.info(
-                "Using v3 API of OpenStack... -> Using OS_PROJECT_ID")
-            project_id = os_utils.get_tenant_id(
-                os_utils.get_keystone_client(),
-                self.creds.get("project_name"))
-        else:
-            self.logger.info(
-                "Using v2 API of OpenStack... -> Using OS_TENANT_NAME")
-            project_id = self.creds.get("tenant_name")
-        self.logger.debug("VIM project/tenant id: %s", project_id)
+        self.logger.debug("VIM project/tenant id: %s",
+                          self.snaps_creds.project_name)
+        keystone = keystone_utils.keystone_client(self.snaps_creds)
+        project_id = keystone_utils.get_project(
+            keystone=keystone, project_name=self.snaps_creds.project_name).id
         vim_json = {
             "name": "vim-instance",
             "authUrl": self.creds.get("auth_url"),
@@ -443,40 +389,28 @@ class ClearwaterImsVnf(vnf.VnfOnBoarding):
             exists=True)
         # setting up port
         port_settings = PortConfig(
-            name='%s_port' % self.case_name,
+            name='{}_port-{}'.format(self.case_name, self.uuid),
             network_name=self.mano['details']['network']['name'])
+
         # build configuration of vm
         orchestra_settings = VmInstanceConfig(
             name=self.case_name,
             flavor=self.mano['details']['flavor']['name'],
             port_settings=[port_settings],
             security_group_names=[self.mano['details']['sec_group']],
+            floating_ip_settings=[FloatingIpConfig(
+                name='orchestra_fip-{}'.format(self.uuid),
+                port_name=port_settings.name,
+                router_name=self.orchestra_router.router_settings.name)],
             userdata=str(userdata))
-        orchestra_vm = OpenStackVmInstance(self.snaps_creds,
-                                           orchestra_settings,
-                                           image_settings)
-
+        orchestra_vm = OpenStackVmInstance(
+            self.snaps_creds, orchestra_settings, image_settings)
         orchestra_vm.create()
+        self.mano['details']['fip'] = orchestra_vm.get_floating_ip()
         self.created_resources.append(orchestra_vm)
         self.mano['details']['id'] = orchestra_vm.get_vm_info()['id']
         self.logger.info(
-            "Created orchestra instance: %s",
-            self.mano['details']['id'])
-
-        self.logger.info("Associating floating ip: '%s' to VM '%s' ",
-                         self.mano['details']['fip'].ip,
-                         self.case_name)
-        nova_client = os_utils.get_nova_client()
-        if not os_utils.add_floating_ip(
-                nova_client,
-                self.mano['details']['id'],
-                self.mano['details']['fip'].ip):
-            duration = time.time() - start_time
-            self.details["orchestrator"].update(
-                status='FAIL', duration=duration)
-            self.logger.error("Cannot associate floating IP to VM.")
-            return False
-
+            "Created orchestra instance: %s", self.mano['details']['id'])
         self.logger.info("Waiting for Open Baton NFVO to be up and running...")
         timeout = 0
         while timeout < 20:
@@ -562,8 +496,8 @@ class ClearwaterImsVnf(vnf.VnfOnBoarding):
 
             self.mano['details']['nsr'] = nsr_agent.create(
                 self.mano['details']['nsd_id'])
-        except NfvoException as exc:
-            self.logger.error(exc.message)
+        except NfvoException:
+            self.logger.exception("failed")
             duration = time.time() - start_time
             self.details["vnf"].update(status='FAIL', duration=duration)
             return False
@@ -622,13 +556,11 @@ class ClearwaterImsVnf(vnf.VnfOnBoarding):
         try:
             main_agent = MainAgent(
                 nfvo_ip=self.mano['details']['fip'].ip,
-                nfvo_port=8080,
-                https=False,
-                version=1,
+                nfvo_port=8080, https=False, version=1,
                 username=self.mano['credentials']['username'],
                 password=self.mano['credentials']['password'])
             self.logger.info("Terminating %s...", self.vnf['name'])
-            if (self.mano['details'].get('nsr')):
+            if self.mano['details'].get('nsr'):
                 main_agent.get_agent(
                     "nsr",
                     project_id=self.mano['details']['project_id']).delete(
@@ -637,33 +569,6 @@ class ClearwaterImsVnf(vnf.VnfOnBoarding):
                 time.sleep(60)
             else:
                 self.logger.info("No need to terminate the VNF...")
-            # os_utils.delete_instance(nova_client=os_utils.get_nova_client(),
-            #                          instance_id=self.mano_instance_id)
         except (NfvoException, KeyError) as exc:
             self.logger.error('Unexpected error cleaning - %s', exc)
-
-        try:
-            neutron_client = os_utils.get_neutron_client(self.creds)
-            keystone_client = os_utils.get_keystone_client(self.creds)
-            self.logger.info("Deleting Open Baton Port...")
-            port = snaps_utils.neutron_utils.get_port(
-                neutron_client, keystone_client,
-                port_name='%s_port' % self.case_name)
-            snaps_utils.neutron_utils.delete_port(neutron_client, port)
-            time.sleep(10)
-        except Exception as exc:  # pylint: disable=broad-except
-            self.logger.error('Unexpected error cleaning - %s', exc)
-        try:
-            self.logger.info("Deleting Open Baton Floating IP...")
-            snaps_utils.neutron_utils.delete_floating_ip(
-                neutron_client, self.mano['details']['fip'])
-        except Exception as exc:  # pylint: disable=broad-except
-            self.logger.error('Unexpected error cleaning - %s', exc)
-
-        for resource in reversed(self.created_resources):
-            try:
-                self.logger.info("Cleaning %s", str(resource))
-                resource.clean()
-            except Exception as exc:  # pylint: disable=broad-except
-                self.logger.error('Unexpected error cleaning - %s', exc)
         super(ClearwaterImsVnf, self).clean()