summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--requirements.txt6
-rw-r--r--sdnvpn/lib/openstack_utils.py1486
-rw-r--r--sdnvpn/lib/utils.py2
-rw-r--r--sdnvpn/test/functest/run_sdnvpn_tests.py2
-rw-r--r--sdnvpn/test/functest/testcase_1.py2
-rw-r--r--sdnvpn/test/functest/testcase_10.py2
-rw-r--r--sdnvpn/test/functest/testcase_11.py2
-rw-r--r--sdnvpn/test/functest/testcase_12.py4
-rw-r--r--sdnvpn/test/functest/testcase_13.py2
-rw-r--r--sdnvpn/test/functest/testcase_2.py2
-rw-r--r--sdnvpn/test/functest/testcase_3.py2
-rw-r--r--sdnvpn/test/functest/testcase_4.py2
-rw-r--r--sdnvpn/test/functest/testcase_7.py2
-rw-r--r--sdnvpn/test/functest/testcase_8.py2
14 files changed, 1505 insertions, 13 deletions
diff --git a/requirements.txt b/requirements.txt
index 63f4ae2..2fce79e 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -6,3 +6,9 @@ requests>=2.14.2 # Apache-2.0
opnfv
PyYAML>=3.10.0 # MIT
networking-bgpvpn==6.0.0 # Apache-2.0
+python-cinderclient>=3.1.0 # Apache-2.0
+python-glanceclient>=2.8.0 # Apache-2.0
+python-heatclient>=1.6.1 # Apache-2.0
+python-keystoneclient>=3.8.0 # Apache-2.0
+python-neutronclient>=6.3.0 # Apache-2.0
+python-novaclient>=9.0.0 # Apache-2.0
diff --git a/sdnvpn/lib/openstack_utils.py b/sdnvpn/lib/openstack_utils.py
new file mode 100644
index 0000000..98da48b
--- /dev/null
+++ b/sdnvpn/lib/openstack_utils.py
@@ -0,0 +1,1486 @@
+#!/usr/bin/env python
+#
+# jose.lausuch@ericsson.com
+# valentin.boucher@orange.com
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+
+import logging
+import os.path
+import sys
+import time
+
+from keystoneauth1 import loading
+from keystoneauth1 import session
+from cinderclient import client as cinderclient
+from glanceclient import client as glanceclient
+from heatclient import client as heatclient
+from novaclient import client as novaclient
+from keystoneclient import client as keystoneclient
+from neutronclient.neutron import client as neutronclient
+
+from functest.utils import env
+import functest.utils.functest_utils as ft_utils
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_API_VERSION = '2'
+DEFAULT_HEAT_API_VERSION = '1'
+
+
+# *********************************************
+# CREDENTIALS
+# *********************************************
+class MissingEnvVar(Exception):
+
+ def __init__(self, var):
+ self.var = var
+
+ def __str__(self):
+ return str.format("Please set the mandatory env var: {}", self.var)
+
+
+def is_keystone_v3():
+ keystone_api_version = os.getenv('OS_IDENTITY_API_VERSION')
+ if (keystone_api_version is None or
+ keystone_api_version == '2'):
+ return False
+ else:
+ return True
+
+
+def get_rc_env_vars():
+ env_vars = ['OS_AUTH_URL', 'OS_USERNAME', 'OS_PASSWORD']
+ if is_keystone_v3():
+ env_vars.extend(['OS_PROJECT_NAME',
+ 'OS_USER_DOMAIN_NAME',
+ 'OS_PROJECT_DOMAIN_NAME'])
+ else:
+ env_vars.extend(['OS_TENANT_NAME'])
+ return env_vars
+
+
+def check_credentials():
+ """
+ Check if the OpenStack credentials (openrc) are sourced
+ """
+ env_vars = get_rc_env_vars()
+ return all(map(lambda v: v in os.environ and os.environ[v], env_vars))
+
+
+def get_env_cred_dict():
+ env_cred_dict = {
+ 'OS_USERNAME': 'username',
+ 'OS_PASSWORD': 'password',
+ 'OS_AUTH_URL': 'auth_url',
+ 'OS_TENANT_NAME': 'tenant_name',
+ 'OS_USER_DOMAIN_NAME': 'user_domain_name',
+ 'OS_PROJECT_DOMAIN_NAME': 'project_domain_name',
+ 'OS_PROJECT_NAME': 'project_name',
+ 'OS_ENDPOINT_TYPE': 'endpoint_type',
+ 'OS_REGION_NAME': 'region_name',
+ 'OS_CACERT': 'https_cacert',
+ 'OS_INSECURE': 'https_insecure'
+ }
+ return env_cred_dict
+
+
+def get_credentials(other_creds={}):
+ """Returns a creds dictionary filled with parsed from env
+ """
+ creds = {}
+ env_vars = get_rc_env_vars()
+ env_cred_dict = get_env_cred_dict()
+
+ for envvar in env_vars:
+ if os.getenv(envvar) is None:
+ raise MissingEnvVar(envvar)
+ else:
+ creds_key = env_cred_dict.get(envvar)
+ creds.update({creds_key: os.getenv(envvar)})
+
+ if 'tenant' in other_creds.keys():
+ if is_keystone_v3():
+ tenant = 'project_name'
+ else:
+ tenant = 'tenant_name'
+ other_creds[tenant] = other_creds.pop('tenant')
+
+ creds.update(other_creds)
+
+ return creds
+
+
+def get_session_auth(other_creds={}):
+ loader = loading.get_plugin_loader('password')
+ creds = get_credentials(other_creds)
+ auth = loader.load_from_options(**creds)
+ return auth
+
+
+def get_endpoint(service_type, interface='public'):
+ auth = get_session_auth()
+ return get_session().get_endpoint(auth=auth,
+ service_type=service_type,
+ interface=interface)
+
+
+def get_session(other_creds={}):
+ auth = get_session_auth(other_creds)
+ https_cacert = os.getenv('OS_CACERT', '')
+ https_insecure = os.getenv('OS_INSECURE', '').lower() == 'true'
+ return session.Session(auth=auth,
+ verify=(https_cacert or not https_insecure))
+
+
+# *********************************************
+# CLIENTS
+# *********************************************
+def get_keystone_client_version():
+ api_version = os.getenv('OS_IDENTITY_API_VERSION')
+ if api_version is not None:
+ logger.info("OS_IDENTITY_API_VERSION is set in env as '%s'",
+ api_version)
+ return api_version
+ return DEFAULT_API_VERSION
+
+
+def get_keystone_client(other_creds={}):
+ sess = get_session(other_creds)
+ return keystoneclient.Client(get_keystone_client_version(),
+ session=sess,
+ interface=os.getenv('OS_INTERFACE', 'admin'))
+
+
+def get_nova_client_version():
+ api_version = os.getenv('OS_COMPUTE_API_VERSION')
+ if api_version is not None:
+ logger.info("OS_COMPUTE_API_VERSION is set in env as '%s'",
+ api_version)
+ return api_version
+ return DEFAULT_API_VERSION
+
+
+def get_nova_client(other_creds={}):
+ sess = get_session(other_creds)
+ return novaclient.Client(get_nova_client_version(), session=sess)
+
+
+def get_cinder_client_version():
+ api_version = os.getenv('OS_VOLUME_API_VERSION')
+ if api_version is not None:
+ logger.info("OS_VOLUME_API_VERSION is set in env as '%s'",
+ api_version)
+ return api_version
+ return DEFAULT_API_VERSION
+
+
+def get_cinder_client(other_creds={}):
+ sess = get_session(other_creds)
+ return cinderclient.Client(get_cinder_client_version(), session=sess)
+
+
+def get_neutron_client_version():
+ api_version = os.getenv('OS_NETWORK_API_VERSION')
+ if api_version is not None:
+ logger.info("OS_NETWORK_API_VERSION is set in env as '%s'",
+ api_version)
+ return api_version
+ return DEFAULT_API_VERSION
+
+
+def get_neutron_client(other_creds={}):
+ sess = get_session(other_creds)
+ return neutronclient.Client(get_neutron_client_version(), session=sess)
+
+
+def get_glance_client_version():
+ api_version = os.getenv('OS_IMAGE_API_VERSION')
+ if api_version is not None:
+ logger.info("OS_IMAGE_API_VERSION is set in env as '%s'", api_version)
+ return api_version
+ return DEFAULT_API_VERSION
+
+
+def get_glance_client(other_creds={}):
+ sess = get_session(other_creds)
+ return glanceclient.Client(get_glance_client_version(), session=sess)
+
+
+def get_heat_client_version():
+ api_version = os.getenv('OS_ORCHESTRATION_API_VERSION')
+ if api_version is not None:
+ logger.info("OS_ORCHESTRATION_API_VERSION is set in env as '%s'",
+ api_version)
+ return api_version
+ return DEFAULT_HEAT_API_VERSION
+
+
+def get_heat_client(other_creds={}):
+ sess = get_session(other_creds)
+ return heatclient.Client(get_heat_client_version(), session=sess)
+
+
+def download_and_add_image_on_glance(glance, image_name, image_url, data_dir):
+ try:
+ dest_path = data_dir
+ if not os.path.exists(dest_path):
+ os.makedirs(dest_path)
+ file_name = image_url.rsplit('/')[-1]
+ if not ft_utils.download_url(image_url, dest_path):
+ return False
+ except Exception:
+ raise Exception("Impossible to download image from {}".format(
+ image_url))
+
+ try:
+ image = create_glance_image(
+ glance, image_name, dest_path + file_name)
+ if not image:
+ return False
+ else:
+ return image
+ except Exception:
+ raise Exception("Impossible to put image {} in glance".format(
+ image_name))
+
+
+# *********************************************
+# NOVA
+# *********************************************
+def get_instances(nova_client):
+ try:
+ instances = nova_client.servers.list(search_opts={'all_tenants': 1})
+ return instances
+ except Exception as e:
+ logger.error("Error [get_instances(nova_client)]: %s" % e)
+ return None
+
+
+def get_instance_status(nova_client, instance):
+ try:
+ instance = nova_client.servers.get(instance.id)
+ return instance.status
+ except Exception as e:
+ logger.error("Error [get_instance_status(nova_client)]: %s" % e)
+ return None
+
+
+def get_instance_by_name(nova_client, instance_name):
+ try:
+ instance = nova_client.servers.find(name=instance_name)
+ return instance
+ except Exception as e:
+ logger.error("Error [get_instance_by_name(nova_client, '%s')]: %s"
+ % (instance_name, e))
+ return None
+
+
+def get_flavor_id(nova_client, flavor_name):
+ flavors = nova_client.flavors.list(detailed=True)
+ id = ''
+ for f in flavors:
+ if f.name == flavor_name:
+ id = f.id
+ break
+ return id
+
+
+def get_flavor_id_by_ram_range(nova_client, min_ram, max_ram):
+ flavors = nova_client.flavors.list(detailed=True)
+ id = ''
+ for f in flavors:
+ if min_ram <= f.ram and f.ram <= max_ram:
+ id = f.id
+ break
+ return id
+
+
+def get_aggregates(nova_client):
+ try:
+ aggregates = nova_client.aggregates.list()
+ return aggregates
+ except Exception as e:
+ logger.error("Error [get_aggregates(nova_client)]: %s" % e)
+ return None
+
+
+def get_aggregate_id(nova_client, aggregate_name):
+ try:
+ aggregates = get_aggregates(nova_client)
+ _id = [ag.id for ag in aggregates if ag.name == aggregate_name][0]
+ return _id
+ except Exception as e:
+ logger.error("Error [get_aggregate_id(nova_client, %s)]:"
+ " %s" % (aggregate_name, e))
+ return None
+
+
+def get_availability_zones(nova_client):
+ try:
+ availability_zones = nova_client.availability_zones.list()
+ return availability_zones
+ except Exception as e:
+ logger.error("Error [get_availability_zones(nova_client)]: %s" % e)
+ return None
+
+
+def get_availability_zone_names(nova_client):
+ try:
+ az_names = [az.zoneName for az in get_availability_zones(nova_client)]
+ return az_names
+ except Exception as e:
+ logger.error("Error [get_availability_zone_names(nova_client)]:"
+ " %s" % e)
+ return None
+
+
+def create_flavor(nova_client, flavor_name, ram, disk, vcpus, public=True):
+ try:
+ flavor = nova_client.flavors.create(
+ flavor_name, ram, vcpus, disk, is_public=public)
+ try:
+ extra_specs = ft_utils.get_functest_config(
+ 'general.flavor_extra_specs')
+ flavor.set_keys(extra_specs)
+ except ValueError:
+ # flavor extra specs are not configured, therefore skip the update
+ pass
+
+ except Exception as e:
+ logger.error("Error [create_flavor(nova_client, '%s', '%s', '%s', "
+ "'%s')]: %s" % (flavor_name, ram, disk, vcpus, e))
+ return None
+ return flavor.id
+
+
+def get_or_create_flavor(flavor_name, ram, disk, vcpus, public=True):
+ flavor_exists = False
+ nova_client = get_nova_client()
+
+ flavor_id = get_flavor_id(nova_client, flavor_name)
+ if flavor_id != '':
+ logger.info("Using existing flavor '%s'..." % flavor_name)
+ flavor_exists = True
+ else:
+ logger.info("Creating flavor '%s' with '%s' RAM, '%s' disk size, "
+ "'%s' vcpus..." % (flavor_name, ram, disk, vcpus))
+ flavor_id = create_flavor(
+ nova_client, flavor_name, ram, disk, vcpus, public=public)
+ if not flavor_id:
+ raise Exception("Failed to create flavor '%s'..." % (flavor_name))
+ else:
+ logger.debug("Flavor '%s' with ID=%s created successfully."
+ % (flavor_name, flavor_id))
+
+ return flavor_exists, flavor_id
+
+
+def get_floating_ips(neutron_client):
+ try:
+ floating_ips = neutron_client.list_floatingips()
+ return floating_ips['floatingips']
+ except Exception as e:
+ logger.error("Error [get_floating_ips(neutron_client)]: %s" % e)
+ return None
+
+
+def get_hypervisors(nova_client):
+ try:
+ nodes = []
+ hypervisors = nova_client.hypervisors.list()
+ for hypervisor in hypervisors:
+ if hypervisor.state == "up":
+ nodes.append(hypervisor.hypervisor_hostname)
+ return nodes
+ except Exception as e:
+ logger.error("Error [get_hypervisors(nova_client)]: %s" % e)
+ return None
+
+
+def create_aggregate(nova_client, aggregate_name, av_zone):
+ try:
+ nova_client.aggregates.create(aggregate_name, av_zone)
+ return True
+ except Exception as e:
+ logger.error("Error [create_aggregate(nova_client, %s, %s)]: %s"
+ % (aggregate_name, av_zone, e))
+ return None
+
+
+def add_host_to_aggregate(nova_client, aggregate_name, compute_host):
+ try:
+ aggregate_id = get_aggregate_id(nova_client, aggregate_name)
+ nova_client.aggregates.add_host(aggregate_id, compute_host)
+ return True
+ except Exception as e:
+ logger.error("Error [add_host_to_aggregate(nova_client, %s, %s)]: %s"
+ % (aggregate_name, compute_host, e))
+ return None
+
+
+def create_aggregate_with_host(
+ nova_client, aggregate_name, av_zone, compute_host):
+ try:
+ create_aggregate(nova_client, aggregate_name, av_zone)
+ add_host_to_aggregate(nova_client, aggregate_name, compute_host)
+ return True
+ except Exception as e:
+ logger.error("Error [create_aggregate_with_host("
+ "nova_client, %s, %s, %s)]: %s"
+ % (aggregate_name, av_zone, compute_host, e))
+ return None
+
+
+def create_instance(flavor_name,
+ image_id,
+ network_id,
+ instance_name="functest-vm",
+ confdrive=True,
+ userdata=None,
+ av_zone='',
+ fixed_ip=None,
+ files=None):
+ nova_client = get_nova_client()
+ try:
+ flavor = nova_client.flavors.find(name=flavor_name)
+ except:
+ flavors = nova_client.flavors.list()
+ logger.error("Error: Flavor '%s' not found. Available flavors are: "
+ "\n%s" % (flavor_name, flavors))
+ return None
+ if fixed_ip is not None:
+ nics = {"net-id": network_id, "v4-fixed-ip": fixed_ip}
+ else:
+ nics = {"net-id": network_id}
+ if userdata is None:
+ instance = nova_client.servers.create(
+ name=instance_name,
+ flavor=flavor,
+ image=image_id,
+ nics=[nics],
+ availability_zone=av_zone,
+ files=files
+ )
+ else:
+ instance = nova_client.servers.create(
+ name=instance_name,
+ flavor=flavor,
+ image=image_id,
+ nics=[nics],
+ config_drive=confdrive,
+ userdata=userdata,
+ availability_zone=av_zone,
+ files=files
+ )
+ return instance
+
+
+def create_instance_and_wait_for_active(flavor_name,
+ image_id,
+ network_id,
+ instance_name="",
+ config_drive=False,
+ userdata="",
+ av_zone='',
+ fixed_ip=None,
+ files=None):
+ SLEEP = 3
+ VM_BOOT_TIMEOUT = 180
+ nova_client = get_nova_client()
+ instance = create_instance(flavor_name,
+ image_id,
+ network_id,
+ instance_name,
+ config_drive,
+ userdata,
+ av_zone=av_zone,
+ fixed_ip=fixed_ip,
+ files=files)
+ count = VM_BOOT_TIMEOUT / SLEEP
+ for n in range(count, -1, -1):
+ status = get_instance_status(nova_client, instance)
+ if status is None:
+ time.sleep(SLEEP)
+ continue
+ elif status.lower() == "active":
+ return instance
+ elif status.lower() == "error":
+ logger.error("The instance %s went to ERROR status."
+ % instance_name)
+ return None
+ time.sleep(SLEEP)
+ logger.error("Timeout booting the instance %s." % instance_name)
+ return None
+
+
+def create_floating_ip(neutron_client):
+ extnet_id = get_external_net_id(neutron_client)
+ props = {'floating_network_id': extnet_id}
+ try:
+ ip_json = neutron_client.create_floatingip({'floatingip': props})
+ fip_addr = ip_json['floatingip']['floating_ip_address']
+ fip_id = ip_json['floatingip']['id']
+ except Exception as e:
+ logger.error("Error [create_floating_ip(neutron_client)]: %s" % e)
+ return None
+ return {'fip_addr': fip_addr, 'fip_id': fip_id}
+
+
+def add_floating_ip(nova_client, server_id, floatingip_addr):
+ try:
+ nova_client.servers.add_floating_ip(server_id, floatingip_addr)
+ return True
+ except Exception as e:
+ logger.error("Error [add_floating_ip(nova_client, '%s', '%s')]: %s"
+ % (server_id, floatingip_addr, e))
+ return False
+
+
+def delete_instance(nova_client, instance_id):
+ try:
+ nova_client.servers.force_delete(instance_id)
+ return True
+ except Exception as e:
+ logger.error("Error [delete_instance(nova_client, '%s')]: %s"
+ % (instance_id, e))
+ return False
+
+
+def delete_floating_ip(neutron_client, floatingip_id):
+ try:
+ neutron_client.delete_floatingip(floatingip_id)
+ return True
+ except Exception as e:
+ logger.error("Error [delete_floating_ip(neutron_client, '%s')]: %s"
+ % (floatingip_id, e))
+ return False
+
+
+def remove_host_from_aggregate(nova_client, aggregate_name, compute_host):
+ try:
+ aggregate_id = get_aggregate_id(nova_client, aggregate_name)
+ nova_client.aggregates.remove_host(aggregate_id, compute_host)
+ return True
+ except Exception as e:
+ logger.error("Error [remove_host_from_aggregate(nova_client, %s, %s)]:"
+ " %s" % (aggregate_name, compute_host, e))
+ return False
+
+
+def remove_hosts_from_aggregate(nova_client, aggregate_name):
+ aggregate_id = get_aggregate_id(nova_client, aggregate_name)
+ hosts = nova_client.aggregates.get(aggregate_id).hosts
+ assert(
+ all(remove_host_from_aggregate(nova_client, aggregate_name, host)
+ for host in hosts))
+
+
+def delete_aggregate(nova_client, aggregate_name):
+ try:
+ remove_hosts_from_aggregate(nova_client, aggregate_name)
+ nova_client.aggregates.delete(aggregate_name)
+ return True
+ except Exception as e:
+ logger.error("Error [delete_aggregate(nova_client, %s)]: %s"
+ % (aggregate_name, e))
+ return False
+
+
+# *********************************************
+# NEUTRON
+# *********************************************
+def get_network_list(neutron_client):
+ network_list = neutron_client.list_networks()['networks']
+ if len(network_list) == 0:
+ return None
+ else:
+ return network_list
+
+
+def get_router_list(neutron_client):
+ router_list = neutron_client.list_routers()['routers']
+ if len(router_list) == 0:
+ return None
+ else:
+ return router_list
+
+
+def get_port_list(neutron_client):
+ port_list = neutron_client.list_ports()['ports']
+ if len(port_list) == 0:
+ return None
+ else:
+ return port_list
+
+
+def get_network_id(neutron_client, network_name):
+ networks = neutron_client.list_networks()['networks']
+ id = ''
+ for n in networks:
+ if n['name'] == network_name:
+ id = n['id']
+ break
+ return id
+
+
+def get_subnet_id(neutron_client, subnet_name):
+ subnets = neutron_client.list_subnets()['subnets']
+ id = ''
+ for s in subnets:
+ if s['name'] == subnet_name:
+ id = s['id']
+ break
+ return id
+
+
+def get_router_id(neutron_client, router_name):
+ routers = neutron_client.list_routers()['routers']
+ id = ''
+ for r in routers:
+ if r['name'] == router_name:
+ id = r['id']
+ break
+ return id
+
+
+def get_private_net(neutron_client):
+ # Checks if there is an existing shared private network
+ networks = neutron_client.list_networks()['networks']
+ if len(networks) == 0:
+ return None
+ for net in networks:
+ if (net['router:external'] is False) and (net['shared'] is True):
+ return net
+ return None
+
+
+def get_external_net(neutron_client):
+ if (env.get('EXTERNAL_NETWORK')):
+ return env.get('EXTERNAL_NETWORK')
+ for network in neutron_client.list_networks()['networks']:
+ if network['router:external']:
+ return network['name']
+ return None
+
+
+def get_external_net_id(neutron_client):
+ if (env.get('EXTERNAL_NETWORK')):
+ networks = neutron_client.list_networks(
+ name=env.get('EXTERNAL_NETWORK'))
+ net_id = networks['networks'][0]['id']
+ return net_id
+ for network in neutron_client.list_networks()['networks']:
+ if network['router:external']:
+ return network['id']
+ return None
+
+
+def check_neutron_net(neutron_client, net_name):
+ for network in neutron_client.list_networks()['networks']:
+ if network['name'] == net_name:
+ for subnet in network['subnets']:
+ return True
+ return False
+
+
+def create_neutron_net(neutron_client, name):
+ json_body = {'network': {'name': name,
+ 'admin_state_up': True}}
+ try:
+ network = neutron_client.create_network(body=json_body)
+ network_dict = network['network']
+ return network_dict['id']
+ except Exception as e:
+ logger.error("Error [create_neutron_net(neutron_client, '%s')]: %s"
+ % (name, e))
+ return None
+
+
+def create_neutron_subnet(neutron_client, name, cidr, net_id,
+ dns=['8.8.8.8', '8.8.4.4']):
+ json_body = {'subnets': [{'name': name, 'cidr': cidr,
+ 'ip_version': 4, 'network_id': net_id,
+ 'dns_nameservers': dns}]}
+
+ try:
+ subnet = neutron_client.create_subnet(body=json_body)
+ return subnet['subnets'][0]['id']
+ except Exception as e:
+ logger.error("Error [create_neutron_subnet(neutron_client, '%s', "
+ "'%s', '%s')]: %s" % (name, cidr, net_id, e))
+ return None
+
+
+def create_neutron_router(neutron_client, name):
+ json_body = {'router': {'name': name, 'admin_state_up': True}}
+ try:
+ router = neutron_client.create_router(json_body)
+ return router['router']['id']
+ except Exception as e:
+ logger.error("Error [create_neutron_router(neutron_client, '%s')]: %s"
+ % (name, e))
+ return None
+
+
+def create_neutron_port(neutron_client, name, network_id, ip):
+ json_body = {'port': {
+ 'admin_state_up': True,
+ 'name': name,
+ 'network_id': network_id,
+ 'fixed_ips': [{"ip_address": ip}]
+ }}
+ try:
+ port = neutron_client.create_port(body=json_body)
+ return port['port']['id']
+ except Exception as e:
+ logger.error("Error [create_neutron_port(neutron_client, '%s', '%s', "
+ "'%s')]: %s" % (name, network_id, ip, e))
+ return None
+
+
+def update_neutron_net(neutron_client, network_id, shared=False):
+ json_body = {'network': {'shared': shared}}
+ try:
+ neutron_client.update_network(network_id, body=json_body)
+ return True
+ except Exception as e:
+ logger.error("Error [update_neutron_net(neutron_client, '%s', '%s')]: "
+ "%s" % (network_id, str(shared), e))
+ return False
+
+
+def update_neutron_port(neutron_client, port_id, device_owner):
+ json_body = {'port': {
+ 'device_owner': device_owner,
+ }}
+ try:
+ port = neutron_client.update_port(port=port_id,
+ body=json_body)
+ return port['port']['id']
+ except Exception as e:
+ logger.error("Error [update_neutron_port(neutron_client, '%s', '%s')]:"
+ " %s" % (port_id, device_owner, e))
+ return None
+
+
+def add_interface_router(neutron_client, router_id, subnet_id):
+ json_body = {"subnet_id": subnet_id}
+ try:
+ neutron_client.add_interface_router(router=router_id, body=json_body)
+ return True
+ except Exception as e:
+ logger.error("Error [add_interface_router(neutron_client, '%s', "
+ "'%s')]: %s" % (router_id, subnet_id, e))
+ return False
+
+
+def add_gateway_router(neutron_client, router_id):
+ ext_net_id = get_external_net_id(neutron_client)
+ router_dict = {'network_id': ext_net_id}
+ try:
+ neutron_client.add_gateway_router(router_id, router_dict)
+ return True
+ except Exception as e:
+ logger.error("Error [add_gateway_router(neutron_client, '%s')]: %s"
+ % (router_id, e))
+ return False
+
+
+def delete_neutron_net(neutron_client, network_id):
+ try:
+ neutron_client.delete_network(network_id)
+ return True
+ except Exception as e:
+ logger.error("Error [delete_neutron_net(neutron_client, '%s')]: %s"
+ % (network_id, e))
+ return False
+
+
+def delete_neutron_subnet(neutron_client, subnet_id):
+ try:
+ neutron_client.delete_subnet(subnet_id)
+ return True
+ except Exception as e:
+ logger.error("Error [delete_neutron_subnet(neutron_client, '%s')]: %s"
+ % (subnet_id, e))
+ return False
+
+
+def delete_neutron_router(neutron_client, router_id):
+ try:
+ neutron_client.delete_router(router=router_id)
+ return True
+ except Exception as e:
+ logger.error("Error [delete_neutron_router(neutron_client, '%s')]: %s"
+ % (router_id, e))
+ return False
+
+
+def delete_neutron_port(neutron_client, port_id):
+ try:
+ neutron_client.delete_port(port_id)
+ return True
+ except Exception as e:
+ logger.error("Error [delete_neutron_port(neutron_client, '%s')]: %s"
+ % (port_id, e))
+ return False
+
+
+def remove_interface_router(neutron_client, router_id, subnet_id):
+ json_body = {"subnet_id": subnet_id}
+ try:
+ neutron_client.remove_interface_router(router=router_id,
+ body=json_body)
+ return True
+ except Exception as e:
+ logger.error("Error [remove_interface_router(neutron_client, '%s', "
+ "'%s')]: %s" % (router_id, subnet_id, e))
+ return False
+
+
+def remove_gateway_router(neutron_client, router_id):
+ try:
+ neutron_client.remove_gateway_router(router_id)
+ return True
+ except Exception as e:
+ logger.error("Error [remove_gateway_router(neutron_client, '%s')]: %s"
+ % (router_id, e))
+ return False
+
+
+def create_network_full(neutron_client,
+ net_name,
+ subnet_name,
+ router_name,
+ cidr,
+ dns=['8.8.8.8', '8.8.4.4']):
+
+ # Check if the network already exists
+ network_id = get_network_id(neutron_client, net_name)
+ subnet_id = get_subnet_id(neutron_client, subnet_name)
+ router_id = get_router_id(neutron_client, router_name)
+
+ if network_id != '' and subnet_id != '' and router_id != '':
+ logger.info("A network with name '%s' already exists..." % net_name)
+ else:
+ neutron_client.format = 'json'
+ logger.info('Creating neutron network %s...' % net_name)
+ network_id = create_neutron_net(neutron_client, net_name)
+
+ if not network_id:
+ return False
+
+ logger.debug("Network '%s' created successfully" % network_id)
+ logger.debug('Creating Subnet....')
+ subnet_id = create_neutron_subnet(neutron_client, subnet_name,
+ cidr, network_id, dns)
+ if not subnet_id:
+ return None
+
+ logger.debug("Subnet '%s' created successfully" % subnet_id)
+ logger.debug('Creating Router...')
+ router_id = create_neutron_router(neutron_client, router_name)
+
+ if not router_id:
+ return None
+
+ logger.debug("Router '%s' created successfully" % router_id)
+ logger.debug('Adding router to subnet...')
+
+ if not add_interface_router(neutron_client, router_id, subnet_id):
+ return None
+
+ logger.debug("Interface added successfully.")
+
+ logger.debug('Adding gateway to router...')
+ if not add_gateway_router(neutron_client, router_id):
+ return None
+
+ logger.debug("Gateway added successfully.")
+
+ network_dic = {'net_id': network_id,
+ 'subnet_id': subnet_id,
+ 'router_id': router_id}
+ return network_dic
+
+
+def create_shared_network_full(net_name, subnt_name, router_name, subnet_cidr):
+ neutron_client = get_neutron_client()
+
+ network_dic = create_network_full(neutron_client,
+ net_name,
+ subnt_name,
+ router_name,
+ subnet_cidr)
+ if network_dic:
+ if not update_neutron_net(neutron_client,
+ network_dic['net_id'],
+ shared=True):
+ logger.error("Failed to update network %s..." % net_name)
+ return None
+ else:
+ logger.debug("Network '%s' is available..." % net_name)
+ else:
+ logger.error("Network %s creation failed" % net_name)
+ return None
+ return network_dic
+
+
+# *********************************************
+# SEC GROUPS
+# *********************************************
+
+
+def get_security_groups(neutron_client):
+ try:
+ security_groups = neutron_client.list_security_groups()[
+ 'security_groups']
+ return security_groups
+ except Exception as e:
+ logger.error("Error [get_security_groups(neutron_client)]: %s" % e)
+ return None
+
+
+def get_security_group_id(neutron_client, sg_name):
+ security_groups = get_security_groups(neutron_client)
+ id = ''
+ for sg in security_groups:
+ if sg['name'] == sg_name:
+ id = sg['id']
+ break
+ return id
+
+
+def create_security_group(neutron_client, sg_name, sg_description):
+ json_body = {'security_group': {'name': sg_name,
+ 'description': sg_description}}
+ try:
+ secgroup = neutron_client.create_security_group(json_body)
+ return secgroup['security_group']
+ except Exception as e:
+ logger.error("Error [create_security_group(neutron_client, '%s', "
+ "'%s')]: %s" % (sg_name, sg_description, e))
+ return None
+
+
+def create_secgroup_rule(neutron_client, sg_id, direction, protocol,
+ port_range_min=None, port_range_max=None):
+ # We create a security group in 2 steps
+ # 1 - we check the format and set the json body accordingly
+ # 2 - we call neturon client to create the security group
+
+ # Format check
+ json_body = {'security_group_rule': {'direction': direction,
+ 'security_group_id': sg_id,
+ 'protocol': protocol}}
+ # parameters may be
+ # - both None => we do nothing
+ # - both Not None => we add them to the json description
+ # but one cannot be None is the other is not None
+ if (port_range_min is not None and port_range_max is not None):
+ # add port_range in json description
+ json_body['security_group_rule']['port_range_min'] = port_range_min
+ json_body['security_group_rule']['port_range_max'] = port_range_max
+ logger.debug("Security_group format set (port range included)")
+ else:
+ # either both port range are set to None => do nothing
+ # or one is set but not the other => log it and return False
+ if port_range_min is None and port_range_max is None:
+ logger.debug("Security_group format set (no port range mentioned)")
+ else:
+ logger.error("Bad security group format."
+ "One of the port range is not properly set:"
+ "range min: {},"
+ "range max: {}".format(port_range_min,
+ port_range_max))
+ return False
+
+ # Create security group using neutron client
+ try:
+ neutron_client.create_security_group_rule(json_body)
+ return True
+ except:
+ logger.exception("Impossible to create_security_group_rule,"
+ "security group rule probably already exists")
+ return False
+
+
+def get_security_group_rules(neutron_client, sg_id):
+ try:
+ security_rules = neutron_client.list_security_group_rules()[
+ 'security_group_rules']
+ security_rules = [rule for rule in security_rules
+ if rule["security_group_id"] == sg_id]
+ return security_rules
+ except Exception as e:
+ logger.error("Error [get_security_group_rules(neutron_client, sg_id)]:"
+ " %s" % e)
+ return None
+
+
+def check_security_group_rules(neutron_client, sg_id, direction, protocol,
+ port_min=None, port_max=None):
+ try:
+ security_rules = get_security_group_rules(neutron_client, sg_id)
+ security_rules = [rule for rule in security_rules
+ if (rule["direction"].lower() == direction and
+ rule["protocol"].lower() == protocol and
+ rule["port_range_min"] == port_min and
+ rule["port_range_max"] == port_max)]
+ if len(security_rules) == 0:
+ return True
+ else:
+ return False
+ except Exception as e:
+ logger.error("Error [check_security_group_rules("
+ " neutron_client, sg_id, direction,"
+ " protocol, port_min=None, port_max=None)]: "
+ "%s" % e)
+ return None
+
+
+def create_security_group_full(neutron_client,
+ sg_name, sg_description):
+ sg_id = get_security_group_id(neutron_client, sg_name)
+ if sg_id != '':
+ logger.info("Using existing security group '%s'..." % sg_name)
+ else:
+ logger.info("Creating security group '%s'..." % sg_name)
+ SECGROUP = create_security_group(neutron_client,
+ sg_name,
+ sg_description)
+ if not SECGROUP:
+ logger.error("Failed to create the security group...")
+ return None
+
+ sg_id = SECGROUP['id']
+
+ logger.debug("Security group '%s' with ID=%s created successfully."
+ % (SECGROUP['name'], sg_id))
+
+ logger.debug("Adding ICMP rules in security group '%s'..."
+ % sg_name)
+ if not create_secgroup_rule(neutron_client, sg_id,
+ 'ingress', 'icmp'):
+ logger.error("Failed to create the security group rule...")
+ return None
+
+ logger.debug("Adding SSH rules in security group '%s'..."
+ % sg_name)
+ if not create_secgroup_rule(
+ neutron_client, sg_id, 'ingress', 'tcp', '22', '22'):
+ logger.error("Failed to create the security group rule...")
+ return None
+
+ if not create_secgroup_rule(
+ neutron_client, sg_id, 'egress', 'tcp', '22', '22'):
+ logger.error("Failed to create the security group rule...")
+ return None
+ return sg_id
+
+
+def add_secgroup_to_instance(nova_client, instance_id, secgroup_id):
+ try:
+ nova_client.servers.add_security_group(instance_id, secgroup_id)
+ return True
+ except Exception as e:
+ logger.error("Error [add_secgroup_to_instance(nova_client, '%s', "
+ "'%s')]: %s" % (instance_id, secgroup_id, e))
+ return False
+
+
+def update_sg_quota(neutron_client, tenant_id, sg_quota, sg_rule_quota):
+ json_body = {"quota": {
+ "security_group": sg_quota,
+ "security_group_rule": sg_rule_quota
+ }}
+
+ try:
+ neutron_client.update_quota(tenant_id=tenant_id,
+ body=json_body)
+ return True
+ except Exception as e:
+ logger.error("Error [update_sg_quota(neutron_client, '%s', '%s', "
+ "'%s')]: %s" % (tenant_id, sg_quota, sg_rule_quota, e))
+ return False
+
+
+def delete_security_group(neutron_client, secgroup_id):
+ try:
+ neutron_client.delete_security_group(secgroup_id)
+ return True
+ except Exception as e:
+ logger.error("Error [delete_security_group(neutron_client, '%s')]: %s"
+ % (secgroup_id, e))
+ return False
+
+
+# *********************************************
+# GLANCE
+# *********************************************
+def get_images(glance_client):
+ try:
+ images = glance_client.images.list()
+ return images
+ except Exception as e:
+ logger.error("Error [get_images]: %s" % e)
+ return None
+
+
+def get_image_id(glance_client, image_name):
+ images = glance_client.images.list()
+ id = ''
+ for i in images:
+ if i.name == image_name:
+ id = i.id
+ break
+ return id
+
+
+def create_glance_image(glance_client,
+ image_name,
+ file_path,
+ disk="qcow2",
+ extra_properties={},
+ container="bare",
+ public="public"):
+ if not os.path.isfile(file_path):
+ logger.error("Error: file %s does not exist." % file_path)
+ return None
+ try:
+ image_id = get_image_id(glance_client, image_name)
+ if image_id != '':
+ logger.info("Image %s already exists." % image_name)
+ else:
+ logger.info("Creating image '%s' from '%s'..." % (image_name,
+ file_path))
+
+ image = glance_client.images.create(name=image_name,
+ visibility=public,
+ disk_format=disk,
+ container_format=container,
+ **extra_properties)
+ image_id = image.id
+ with open(file_path) as image_data:
+ glance_client.images.upload(image_id, image_data)
+ return image_id
+ except Exception as e:
+ logger.error("Error [create_glance_image(glance_client, '%s', '%s', "
+ "'%s')]: %s" % (image_name, file_path, public, e))
+ return None
+
+
+def get_or_create_image(name, path, format, extra_properties):
+ image_exists = False
+ glance_client = get_glance_client()
+
+ image_id = get_image_id(glance_client, name)
+ if image_id != '':
+ logger.info("Using existing image '%s'..." % name)
+ image_exists = True
+ else:
+ logger.info("Creating image '%s' from '%s'..." % (name, path))
+ image_id = create_glance_image(glance_client,
+ name,
+ path,
+ format,
+ extra_properties)
+ if not image_id:
+ logger.error("Failed to create a Glance image...")
+ else:
+ logger.debug("Image '%s' with ID=%s created successfully."
+ % (name, image_id))
+
+ return image_exists, image_id
+
+
+def delete_glance_image(glance_client, image_id):
+ try:
+ glance_client.images.delete(image_id)
+ return True
+ except Exception as e:
+ logger.error("Error [delete_glance_image(glance_client, '%s')]: %s"
+ % (image_id, e))
+ return False
+
+
+# *********************************************
+# CINDER
+# *********************************************
+def get_volumes(cinder_client):
+ try:
+ volumes = cinder_client.volumes.list(search_opts={'all_tenants': 1})
+ return volumes
+ except Exception as e:
+ logger.error("Error [get_volumes(cinder_client)]: %s" % e)
+ return None
+
+
+def update_cinder_quota(cinder_client, tenant_id, vols_quota,
+ snapshots_quota, gigabytes_quota):
+ quotas_values = {"volumes": vols_quota,
+ "snapshots": snapshots_quota,
+ "gigabytes": gigabytes_quota}
+
+ try:
+ cinder_client.quotas.update(tenant_id, **quotas_values)
+ return True
+ except Exception as e:
+ logger.error("Error [update_cinder_quota(cinder_client, '%s', '%s', "
+ "'%s' '%s')]: %s" % (tenant_id, vols_quota,
+ snapshots_quota, gigabytes_quota, e))
+ return False
+
+
+def delete_volume(cinder_client, volume_id, forced=False):
+ try:
+ if forced:
+ try:
+ cinder_client.volumes.detach(volume_id)
+ except:
+ logger.error(sys.exc_info()[0])
+ cinder_client.volumes.force_delete(volume_id)
+ else:
+ cinder_client.volumes.delete(volume_id)
+ return True
+ except Exception as e:
+ logger.error("Error [delete_volume(cinder_client, '%s', '%s')]: %s"
+ % (volume_id, str(forced), e))
+ return False
+
+
+# *********************************************
+# KEYSTONE
+# *********************************************
+def get_tenants(keystone_client):
+ try:
+ if is_keystone_v3():
+ tenants = keystone_client.projects.list()
+ else:
+ tenants = keystone_client.tenants.list()
+ return tenants
+ except Exception as e:
+ logger.error("Error [get_tenants(keystone_client)]: %s" % e)
+ return None
+
+
+def get_users(keystone_client):
+ try:
+ users = keystone_client.users.list()
+ return users
+ except Exception as e:
+ logger.error("Error [get_users(keystone_client)]: %s" % e)
+ return None
+
+
+def get_tenant_id(keystone_client, tenant_name):
+ tenants = get_tenants(keystone_client)
+ id = ''
+ for t in tenants:
+ if t.name == tenant_name:
+ id = t.id
+ break
+ return id
+
+
+def get_user_id(keystone_client, user_name):
+ users = get_users(keystone_client)
+ id = ''
+ for u in users:
+ if u.name == user_name:
+ id = u.id
+ break
+ return id
+
+
+def get_role_id(keystone_client, role_name):
+ roles = keystone_client.roles.list()
+ id = ''
+ for r in roles:
+ if r.name == role_name:
+ id = r.id
+ break
+ return id
+
+
+def get_domain_id(keystone_client, domain_name):
+ domains = keystone_client.domains.list()
+ id = ''
+ for d in domains:
+ if d.name == domain_name:
+ id = d.id
+ break
+ return id
+
+
+def create_tenant(keystone_client, tenant_name, tenant_description):
+ try:
+ if is_keystone_v3():
+ domain_name = os.environ['OS_PROJECT_DOMAIN_NAME']
+ domain_id = get_domain_id(keystone_client, domain_name)
+ tenant = keystone_client.projects.create(
+ name=tenant_name,
+ description=tenant_description,
+ domain=domain_id,
+ enabled=True)
+ else:
+ tenant = keystone_client.tenants.create(tenant_name,
+ tenant_description,
+ enabled=True)
+ return tenant.id
+ except Exception as e:
+ logger.error("Error [create_tenant(keystone_client, '%s', '%s')]: %s"
+ % (tenant_name, tenant_description, e))
+ return None
+
+
+def get_or_create_tenant(keystone_client, tenant_name, tenant_description):
+ tenant_id = get_tenant_id(keystone_client, tenant_name)
+ if not tenant_id:
+ tenant_id = create_tenant(keystone_client, tenant_name,
+ tenant_description)
+
+ return tenant_id
+
+
+def get_or_create_tenant_for_vnf(keystone_client, tenant_name,
+ tenant_description):
+ """Get or Create a Tenant
+
+ Args:
+ keystone_client: keystone client reference
+ tenant_name: the name of the tenant
+ tenant_description: the description of the tenant
+
+ return False if tenant retrieved though get
+ return True if tenant created
+ raise Exception if error during processing
+ """
+ try:
+ tenant_id = get_tenant_id(keystone_client, tenant_name)
+ if not tenant_id:
+ tenant_id = create_tenant(keystone_client, tenant_name,
+ tenant_description)
+ return True
+ else:
+ return False
+ except:
+ raise Exception("Impossible to create a Tenant for the VNF {}".format(
+ tenant_name))
+
+
+def create_user(keystone_client, user_name, user_password,
+ user_email, tenant_id):
+ try:
+ if is_keystone_v3():
+ user = keystone_client.users.create(name=user_name,
+ password=user_password,
+ email=user_email,
+ project_id=tenant_id,
+ enabled=True)
+ else:
+ user = keystone_client.users.create(user_name,
+ user_password,
+ user_email,
+ tenant_id,
+ enabled=True)
+ return user.id
+ except Exception as e:
+ logger.error("Error [create_user(keystone_client, '%s', '%s', '%s'"
+ "'%s')]: %s" % (user_name, user_password,
+ user_email, tenant_id, e))
+ return None
+
+
+def get_or_create_user(keystone_client, user_name, user_password,
+ tenant_id, user_email=None):
+ user_id = get_user_id(keystone_client, user_name)
+ if not user_id:
+ user_id = create_user(keystone_client, user_name, user_password,
+ user_email, tenant_id)
+ return user_id
+
+
+def get_or_create_user_for_vnf(keystone_client, vnf_ref):
+ """Get or Create user for VNF
+
+ Args:
+ keystone_client: keystone client reference
+ vnf_ref: VNF reference used as user name & password, tenant name
+
+ return False if user retrieved through get
+ return True if user created
+ raise Exception if error during processing
+ """
+ try:
+ user_id = get_user_id(keystone_client, vnf_ref)
+ tenant_id = get_tenant_id(keystone_client, vnf_ref)
+ created = False
+ if not user_id:
+ user_id = create_user(keystone_client, vnf_ref, vnf_ref,
+ "", tenant_id)
+ created = True
+ try:
+ role_id = get_role_id(keystone_client, 'admin')
+ tenant_id = get_tenant_id(keystone_client, vnf_ref)
+ add_role_user(keystone_client, user_id, role_id, tenant_id)
+ except:
+ logger.warn("Cannot associate user to role admin on tenant")
+ return created
+ except:
+ raise Exception("Impossible to create a user for the VNF {}".format(
+ vnf_ref))
+
+
+def add_role_user(keystone_client, user_id, role_id, tenant_id):
+ try:
+ if is_keystone_v3():
+ keystone_client.roles.grant(role=role_id,
+ user=user_id,
+ project=tenant_id)
+ else:
+ keystone_client.roles.add_user_role(user_id, role_id, tenant_id)
+ return True
+ except Exception as e:
+ logger.error("Error [add_role_user(keystone_client, '%s', '%s'"
+ "'%s')]: %s " % (user_id, role_id, tenant_id, e))
+ return False
+
+
+def delete_tenant(keystone_client, tenant_id):
+ try:
+ if is_keystone_v3():
+ keystone_client.projects.delete(tenant_id)
+ else:
+ keystone_client.tenants.delete(tenant_id)
+ return True
+ except Exception as e:
+ logger.error("Error [delete_tenant(keystone_client, '%s')]: %s"
+ % (tenant_id, e))
+ return False
+
+
+def delete_user(keystone_client, user_id):
+ try:
+ keystone_client.users.delete(user_id)
+ return True
+ except Exception as e:
+ logger.error("Error [delete_user(keystone_client, '%s')]: %s"
+ % (user_id, e))
+ return False
+
+
+# *********************************************
+# HEAT
+# *********************************************
+def get_resource(heat_client, stack_id, resource):
+ try:
+ resources = heat_client.resources.get(stack_id, resource)
+ return resources
+ except Exception as e:
+ logger.error("Error [get_resource]: %s" % e)
+ return None
diff --git a/sdnvpn/lib/utils.py b/sdnvpn/lib/utils.py
index 47a0b9e..270e0ff 100644
--- a/sdnvpn/lib/utils.py
+++ b/sdnvpn/lib/utils.py
@@ -16,10 +16,10 @@ import re
import subprocess
from concurrent.futures import ThreadPoolExecutor
-import functest.utils.openstack_utils as os_utils
from opnfv.deployment.factory import Factory as DeploymentFactory
from sdnvpn.lib import config as sdnvpn_config
+import sdnvpn.lib.openstack_utils as os_utils
logger = logging.getLogger('sdnvpn_test_utils')
diff --git a/sdnvpn/test/functest/run_sdnvpn_tests.py b/sdnvpn/test/functest/run_sdnvpn_tests.py
index 1ddc4c6..7da6571 100644
--- a/sdnvpn/test/functest/run_sdnvpn_tests.py
+++ b/sdnvpn/test/functest/run_sdnvpn_tests.py
@@ -16,8 +16,8 @@ import traceback
import yaml
from functest.core import feature as base
-from functest.utils import openstack_utils as os_utils
from sdnvpn.lib import config as sdnvpn_config
+from sdnvpn.lib import openstack_utils as os_utils
from sdnvpn.lib.gather_logs import gather_logs
from sdnvpn.lib import utils as test_utils
diff --git a/sdnvpn/test/functest/testcase_1.py b/sdnvpn/test/functest/testcase_1.py
index b60a3c3..74105de 100644
--- a/sdnvpn/test/functest/testcase_1.py
+++ b/sdnvpn/test/functest/testcase_1.py
@@ -12,9 +12,9 @@ import logging
import sys
import time
-from functest.utils import openstack_utils as os_utils
from random import randint
from sdnvpn.lib import config as sdnvpn_config
+from sdnvpn.lib import openstack_utils as os_utils
from sdnvpn.lib import utils as test_utils
from sdnvpn.lib.results import Results
diff --git a/sdnvpn/test/functest/testcase_10.py b/sdnvpn/test/functest/testcase_10.py
index 02956c4..7a3f563 100644
--- a/sdnvpn/test/functest/testcase_10.py
+++ b/sdnvpn/test/functest/testcase_10.py
@@ -13,9 +13,9 @@ import re
import sys
import time
-from functest.utils import openstack_utils as os_utils
from multiprocessing import Process, Manager, Lock
from sdnvpn.lib import config as sdnvpn_config
+from sdnvpn.lib import openstack_utils as os_utils
from sdnvpn.lib import utils as test_utils
from sdnvpn.lib.results import Results
diff --git a/sdnvpn/test/functest/testcase_11.py b/sdnvpn/test/functest/testcase_11.py
index 40de205..3d9123f 100644
--- a/sdnvpn/test/functest/testcase_11.py
+++ b/sdnvpn/test/functest/testcase_11.py
@@ -11,8 +11,8 @@
import logging
import sys
-from functest.utils import openstack_utils as os_utils
from sdnvpn.lib import config as sdnvpn_config
+from sdnvpn.lib import openstack_utils as os_utils
from sdnvpn.lib import utils as test_utils
from sdnvpn.lib.results import Results
diff --git a/sdnvpn/test/functest/testcase_12.py b/sdnvpn/test/functest/testcase_12.py
index 0916e9f..ebbb67a 100644
--- a/sdnvpn/test/functest/testcase_12.py
+++ b/sdnvpn/test/functest/testcase_12.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+!/usr/bin/python
#
# Copyright (c) 2017 All rights reserved
# This program and the accompanying materials
@@ -11,8 +11,8 @@
import logging
import sys
-from functest.utils import openstack_utils as os_utils
from sdnvpn.lib import config as sdnvpn_config
+from sdnvpn.lib import openstack_utils as os_utils
from sdnvpn.lib import utils as test_utils
from sdnvpn.lib.results import Results
diff --git a/sdnvpn/test/functest/testcase_13.py b/sdnvpn/test/functest/testcase_13.py
index 7211668..9905cf3 100644
--- a/sdnvpn/test/functest/testcase_13.py
+++ b/sdnvpn/test/functest/testcase_13.py
@@ -11,9 +11,9 @@
import logging
import sys
-from functest.utils import openstack_utils as os_utils
from random import randint
from sdnvpn.lib import config as sdnvpn_config
+from sdnvpn.lib import openstack_utils as os_utils
from sdnvpn.lib import utils as test_utils
from sdnvpn.lib.results import Results
diff --git a/sdnvpn/test/functest/testcase_2.py b/sdnvpn/test/functest/testcase_2.py
index d136d8f..1d1ea42 100644
--- a/sdnvpn/test/functest/testcase_2.py
+++ b/sdnvpn/test/functest/testcase_2.py
@@ -11,9 +11,9 @@
import logging
import sys
-from functest.utils import openstack_utils as os_utils
from random import randint
from sdnvpn.lib import config as sdnvpn_config
+from sdnvpn.lib import openstack_utils as os_utils
from sdnvpn.lib import utils as test_utils
from sdnvpn.lib.results import Results
diff --git a/sdnvpn/test/functest/testcase_3.py b/sdnvpn/test/functest/testcase_3.py
index 88fb421..6e7cbae 100644
--- a/sdnvpn/test/functest/testcase_3.py
+++ b/sdnvpn/test/functest/testcase_3.py
@@ -17,8 +17,8 @@ import os
import sys
from functest.utils import functest_utils as ft_utils
-from functest.utils import openstack_utils as os_utils
from sdnvpn.lib import quagga
+from sdnvpn.lib import openstack_utils as os_utils
from sdnvpn.lib import utils as test_utils
from sdnvpn.lib import config as sdnvpn_config
from sdnvpn.lib.results import Results
diff --git a/sdnvpn/test/functest/testcase_4.py b/sdnvpn/test/functest/testcase_4.py
index 042fb59..5d94861 100644
--- a/sdnvpn/test/functest/testcase_4.py
+++ b/sdnvpn/test/functest/testcase_4.py
@@ -12,9 +12,9 @@ import logging
import sys
import time
-from functest.utils import openstack_utils as os_utils
from random import randint
from sdnvpn.lib import config as sdnvpn_config
+from sdnvpn.lib import openstack_utils as os_utils
from sdnvpn.lib import utils as test_utils
from sdnvpn.lib.results import Results
diff --git a/sdnvpn/test/functest/testcase_7.py b/sdnvpn/test/functest/testcase_7.py
index 0e3a8f5..61ac6d0 100644
--- a/sdnvpn/test/functest/testcase_7.py
+++ b/sdnvpn/test/functest/testcase_7.py
@@ -21,8 +21,8 @@ network associated:
import logging
import sys
-from functest.utils import openstack_utils as os_utils
from sdnvpn.lib import config as sdnvpn_config
+from sdnvpn.lib import openstack_utils as os_utils
from sdnvpn.lib import utils as test_utils
from sdnvpn.lib.results import Results
diff --git a/sdnvpn/test/functest/testcase_8.py b/sdnvpn/test/functest/testcase_8.py
index e372fe1..4d57bae 100644
--- a/sdnvpn/test/functest/testcase_8.py
+++ b/sdnvpn/test/functest/testcase_8.py
@@ -21,8 +21,8 @@ Test whether router assoc can coexist with floating IP
import logging
import sys
-from functest.utils import openstack_utils as os_utils
from sdnvpn.lib import config as sdnvpn_config
+from sdnvpn.lib import openstack_utils as os_utils
from sdnvpn.lib import utils as test_utils
from sdnvpn.lib.results import Results