diff options
Diffstat (limited to 'testcases')
| -rw-r--r-- | testcases/functest_utils.py | 32 | ||||
| -rw-r--r-- | testcases/vPing/CI/libraries/ping.sh | 13 | ||||
| -rw-r--r-- | testcases/vPing/CI/libraries/vPing2.py | 528 |
3 files changed, 573 insertions, 0 deletions
diff --git a/testcases/functest_utils.py b/testcases/functest_utils.py index baab415d9..d9f43a79e 100644 --- a/testcases/functest_utils.py +++ b/testcases/functest_utils.py @@ -116,6 +116,15 @@ def delete_instance(nova_client, instance_id): print "Error:", sys.exc_info()[0] return False +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}) + floating_ip = ip_json['floatingip']['floating_ip_address'] + except: + return None + return floating_ip def get_floating_ips(nova_client): try: @@ -124,6 +133,13 @@ def get_floating_ips(nova_client): except: return None +def add_floating_ip(nova_client, server_id, floatingip_id): + try: + nova_client.servers.add_floating_ip(server_id,floatingip_id) + return True + except: + print "Error:", sys.exc_info()[0] + return None def delete_floating_ip(nova_client, floatingip_id): try: @@ -226,6 +242,15 @@ def remove_interface_router(neutron_client, router_id, subnet_id): print "Error:", sys.exc_info()[0] 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: + print "Error:", sys.exc_info()[0] + return False def remove_gateway_router(neutron_client, router_id): try: @@ -322,6 +347,13 @@ def get_external_net(neutron_client): return False +def get_external_net_id(neutron_client): + for network in neutron_client.list_networks()['networks']: + if network['router:external']: + return network['id'] + return False + + def update_sg_quota(neutron_client, tenant_id, sg_quota, sg_rule_quota): json_body = {"quota": { "security_group": sg_quota, diff --git a/testcases/vPing/CI/libraries/ping.sh b/testcases/vPing/CI/libraries/ping.sh new file mode 100644 index 000000000..693b86825 --- /dev/null +++ b/testcases/vPing/CI/libraries/ping.sh @@ -0,0 +1,13 @@ +#!/bin/sh + +while true; do + ping -c 1 $1 2>&1 >/dev/null + RES=$? + if [ "Z$RES" = "Z0" ] ; then + echo 'vPing OK' + break + else + echo 'vPing KO' + fi + sleep 1 +done
\ No newline at end of file diff --git a/testcases/vPing/CI/libraries/vPing2.py b/testcases/vPing/CI/libraries/vPing2.py new file mode 100644 index 000000000..50000868c --- /dev/null +++ b/testcases/vPing/CI/libraries/vPing2.py @@ -0,0 +1,528 @@ +#!/usr/bin/python +# +# Copyright (c) 2015 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 +# +# 0.1: This script boots the VM1 and allocates IP address from Nova +# Later, the VM2 boots then execute cloud-init to ping VM1. +# After successful ping, both the VMs are deleted. +# 0.2: measure test duration and publish results under json format +# +# + +import os +import time +import argparse +import pprint +import sys +import logging +import yaml +import datetime +import subprocess +from novaclient import client as novaclient +from neutronclient.v2_0 import client as neutronclient +from keystoneclient.v2_0 import client as keystoneclient +from glanceclient import client as glanceclient + +pp = pprint.PrettyPrinter(indent=4) + +parser = argparse.ArgumentParser() + +parser.add_argument("-d", "--debug", help="Debug mode", action="store_true") +parser.add_argument("-r", "--report", + help="Create json result file", + action="store_true") + +args = parser.parse_args() + +""" logging configuration """ + +logger = logging.getLogger('vPing') +logger.setLevel(logging.DEBUG) + +ch = logging.StreamHandler() + +if args.debug: + ch.setLevel(logging.DEBUG) +else: + ch.setLevel(logging.INFO) + +formatter = logging.Formatter('%(asctime)s - %(name)s' + '- %(levelname)s - %(message)s') + +ch.setFormatter(formatter) +logger.addHandler(ch) + +REPO_PATH = os.environ['repos_dir']+'/functest/' +if not os.path.exists(REPO_PATH): + logger.error("Functest repository directory not found '%s'" % REPO_PATH) + exit(-1) +sys.path.append(REPO_PATH + "testcases/") +import functest_utils + +with open("/home/opnfv/functest/conf/config_functest.yaml") as f: + functest_yaml = yaml.safe_load(f) +f.close() + +HOME = os.environ['HOME'] + "/" +# vPing parameters +VM_BOOT_TIMEOUT = 180 +VM_DELETE_TIMEOUT = 100 +PING_TIMEOUT = functest_yaml.get("vping").get("ping_timeout") +TEST_DB = functest_yaml.get("results").get("test_db_url") +NAME_VM_1 = functest_yaml.get("vping").get("vm_name_1") +NAME_VM_2 = functest_yaml.get("vping").get("vm_name_2") +IP_1 = functest_yaml.get("vping").get("ip_1") +IP_2 = functest_yaml.get("vping").get("ip_2") +# GLANCE_IMAGE_NAME = functest_yaml.get("general"). \ +# get("openstack").get("image_name") +GLANCE_IMAGE_NAME = "functest-vping" +GLANCE_IMAGE_FILENAME = functest_yaml.get("general"). \ + get("openstack").get("image_file_name") +GLANCE_IMAGE_FORMAT = functest_yaml.get("general"). \ + get("openstack").get("image_disk_format") +GLANCE_IMAGE_PATH = functest_yaml.get("general"). \ + get("directories").get("dir_functest_data") + "/" + GLANCE_IMAGE_FILENAME + + +FLAVOR = functest_yaml.get("vping").get("vm_flavor") + +# NEUTRON Private Network parameters + +NEUTRON_PRIVATE_NET_NAME = functest_yaml.get("vping"). \ + get("vping_private_net_name") + +NEUTRON_PRIVATE_SUBNET_NAME = functest_yaml.get("vping"). \ + get("vping_private_subnet_name") + +NEUTRON_PRIVATE_SUBNET_CIDR = functest_yaml.get("vping"). \ + get("vping_private_subnet_cidr") + +NEUTRON_ROUTER_NAME = functest_yaml.get("vping"). \ + get("vping_router_name") + + +def pMsg(value): + + """pretty printing""" + pp.pprint(value) + + +def waitVmActive(nova, vm): + + # sleep and wait for VM status change + sleep_time = 3 + count = VM_BOOT_TIMEOUT / sleep_time + while True: + status = functest_utils.get_instance_status(nova, vm) + logger.debug("Status: %s" % status) + if status == "ACTIVE": + return True + if status == "ERROR" or status == "error": + return False + if count == 0: + logger.debug("Booting a VM timed out...") + return False + count -= 1 + time.sleep(sleep_time) + return False + + +def waitVmDeleted(nova, vm): + + # sleep and wait for VM status change + sleep_time = 3 + count = VM_DELETE_TIMEOUT / sleep_time + while True: + status = functest_utils.get_instance_status(nova, vm) + if not status: + return True + elif count == 0: + logger.debug("Timeout") + return False + else: + # return False + count -= 1 + time.sleep(sleep_time) + return False + + +def create_private_neutron_net(neutron): + + neutron.format = 'json' + logger.info('Creating neutron network %s...' % NEUTRON_PRIVATE_NET_NAME) + network_id = functest_utils. \ + create_neutron_net(neutron, NEUTRON_PRIVATE_NET_NAME) + + if not network_id: + return False + logger.debug("Network '%s' created successfully" % network_id) + logger.debug('Creating Subnet....') + subnet_id = functest_utils. \ + create_neutron_subnet(neutron, + NEUTRON_PRIVATE_SUBNET_NAME, + NEUTRON_PRIVATE_SUBNET_CIDR, + network_id) + if not subnet_id: + return False + logger.debug("Subnet '%s' created successfully" % subnet_id) + logger.debug('Creating Router...') + router_id = functest_utils. \ + create_neutron_router(neutron, NEUTRON_ROUTER_NAME) + + if not router_id: + return False + + logger.debug("Router '%s' created successfully" % router_id) + logger.debug('Adding router to subnet...') + + if not functest_utils.add_interface_router(neutron, router_id, subnet_id): + return False + logger.debug("Interface added successfully.") + + logger.debug('Adding gateway to router...') + if not functest_utils.add_gateway_router(neutron, router_id): + return False + logger.debug("Gateway added successfully.") + + network_dic = {'net_id': network_id, + 'subnet_id': subnet_id, + 'router_id': router_id} + return network_dic + + +def cleanup(nova, neutron, image_id, network_dic, port_id1, port_id2): + + # delete both VMs + logger.info("Cleaning up...") + logger.debug("Deleting image...") + if not functest_utils.delete_glance_image(nova, image_id): + logger.error("Error deleting the glance image") + + vm1 = functest_utils.get_instance_by_name(nova, NAME_VM_1) + if vm1: + logger.debug("Deleting '%s'..." % NAME_VM_1) + nova.servers.delete(vm1) + # wait until VMs are deleted + if not waitVmDeleted(nova, vm1): + logger.error( + "Instance '%s' with cannot be deleted. Status is '%s'" % ( + NAME_VM_1, functest_utils.get_instance_status(nova, vm1))) + else: + logger.debug("Instance %s terminated." % NAME_VM_1) + + vm2 = functest_utils.get_instance_by_name(nova, NAME_VM_2) + + if vm2: + logger.debug("Deleting '%s'..." % NAME_VM_2) + vm2 = nova.servers.find(name=NAME_VM_2) + nova.servers.delete(vm2) + + if not waitVmDeleted(nova, vm2): + logger.error( + "Instance '%s' with cannot be deleted. Status is '%s'" % ( + NAME_VM_2, functest_utils.get_instance_status(nova, vm2))) + else: + logger.debug("Instance %s terminated." % NAME_VM_2) + + # delete created network + logger.info("Deleting network '%s'..." % NEUTRON_PRIVATE_NET_NAME) + net_id = network_dic["net_id"] + subnet_id = network_dic["subnet_id"] + router_id = network_dic["router_id"] + + if not functest_utils.delete_neutron_port(neutron, port_id1): + logger.error("Unable to remove port '%s'" % port_id1) + return False + logger.debug("Port '%s' removed successfully" % port_id1) + + if not functest_utils.delete_neutron_port(neutron, port_id2): + logger.error("Unable to remove port '%s'" % port_id2) + return False + logger.debug("Port '%s' removed successfully" % port_id2) + + if not functest_utils.remove_interface_router(neutron, router_id, + subnet_id): + logger.error("Unable to remove subnet '%s' from router '%s'" % ( + subnet_id, router_id)) + return False + + logger.debug("Interface removed successfully") + if not functest_utils.delete_neutron_router(neutron, router_id): + logger.error("Unable to delete router '%s'" % router_id) + return False + + logger.debug("Router deleted successfully") + + if not functest_utils.delete_neutron_subnet(neutron, subnet_id): + logger.error("Unable to delete subnet '%s'" % subnet_id) + return False + + logger.debug( + "Subnet '%s' deleted successfully" % NEUTRON_PRIVATE_SUBNET_NAME) + + if not functest_utils.delete_neutron_net(neutron, net_id): + logger.error("Unable to delete network '%s'" % net_id) + return False + + logger.debug( + "Network '%s' deleted successfully" % NEUTRON_PRIVATE_NET_NAME) + + return True + + +def main(): + + creds_nova = functest_utils.get_credentials("nova") + nova_client = novaclient.Client('2', **creds_nova) + creds_neutron = functest_utils.get_credentials("neutron") + neutron_client = neutronclient.Client(**creds_neutron) + creds_keystone = functest_utils.get_credentials("keystone") + keystone_client = keystoneclient.Client(**creds_keystone) + glance_endpoint = keystone_client.service_catalog.url_for(service_type='image', + endpoint_type='publicURL') + glance_client = glanceclient.Client(1, glance_endpoint, + token=keystone_client.auth_token) + EXIT_CODE = -1 + + image = None + flavor = None + + logger.debug("Creating image '%s' from '%s'..." % (GLANCE_IMAGE_NAME, + GLANCE_IMAGE_PATH)) + image_id = functest_utils.create_glance_image(glance_client, + GLANCE_IMAGE_NAME, + GLANCE_IMAGE_PATH) + if not image_id: + logger.error("Failed to create a Glance image...") + return(EXIT_CODE) + + # Check if the given image exists + image = functest_utils.get_image_id(glance_client, GLANCE_IMAGE_NAME) + if image == '': + logger.error("ERROR: Glance image '%s' not found." % GLANCE_IMAGE_NAME) + logger.info("Available images are: ") + pMsg(nova_client.images.list()) + return(EXIT_CODE) + + network_dic = create_private_neutron_net(neutron_client) + + if not network_dic: + logger.error( + "There has been a problem when creating the neutron network") + return(EXIT_CODE) + + network_id = network_dic["net_id"] + + # Check if the given flavor exists + + try: + flavor = nova_client.flavors.find(name=FLAVOR) + logger.info("Flavor found '%s'" % FLAVOR) + except: + logger.error("Flavor '%s' not found." % FLAVOR) + logger.info("Available flavors are: ") + pMsg(nova_client.flavor.list()) + return(EXIT_CODE) + + # Deleting instances if they exist + + servers = nova_client.servers.list() + for server in servers: + if server.name == NAME_VM_1 or server.name == NAME_VM_2: + logger.info("Instance %s found. Deleting..." % server.name) + server.delete() + + # boot VM 1 + # basic boot + # tune (e.g. flavor, images, network) to your specific + # openstack configuration here + # we consider start time at VM1 booting + start_time_ts = time.time() + end_time_ts = start_time_ts + logger.info("vPing Start Time:'%s'" % ( + datetime.datetime.fromtimestamp(start_time_ts).strftime( + '%Y-%m-%d %H:%M:%S'))) + + # create VM + logger.debug("Creating port 'vping-port-1' with IP %s..." % IP_1) + port_id1 = functest_utils.create_neutron_port(neutron_client, + "vping-port-1", network_id, + IP_1) + if not port_id1: + logger.error("Unable to create port.") + return(EXIT_CODE) + + logger.info("Creating instance '%s' with IP %s..." % (NAME_VM_1, IP_1)) + logger.debug( + "Configuration:\n name=%s \n flavor=%s \n image=%s \n " + "network=%s \n" % (NAME_VM_1, flavor, image, network_id)) + vm1 = nova_client.servers.create( + name=NAME_VM_1, + flavor=flavor, + image=image, + # nics = [{"net-id": network_id, "v4-fixed-ip": IP_1}] + nics=[{"port-id": port_id1}] + ) + + # wait until VM status is active + if not waitVmActive(nova_client, vm1): + + logger.error("Instance '%s' cannot be booted. Status is '%s'" % ( + NAME_VM_1, functest_utils.get_instance_status(nova_client, vm1))) + cleanup(nova_client, neutron_client, image_id, network_dic, port_id1) + return (EXIT_CODE) + else: + logger.info("Instance '%s' is ACTIVE." % NAME_VM_1) + + # Retrieve IP of first VM + # logger.debug("Fetching IP...") + # server = functest_utils.get_instance_by_name(nova_client, NAME_VM_1) + # theoretically there is only one IP address so we take the + # first element of the table + # Dangerous! To be improved! + # test_ip = server.networks.get(NEUTRON_PRIVATE_NET_NAME)[0] + test_ip = IP_1 + logger.debug("Instance '%s' got %s" % (NAME_VM_1, test_ip)) + + # boot VM 2 + # we will boot then execute a ping script with cloud-init + # the long chain corresponds to the ping procedure converted with base 64 + # tune (e.g. flavor, images, network) to your specific openstack + # configuration here + + + # create VM + logger.debug("Creating port 'vping-port-2' with IP %s..." % IP_2) + port_id2 = functest_utils.create_neutron_port(neutron_client, + "vping-port-2", network_id, + IP_2) + + if not port_id2: + logger.error("Unable to create port.") + return(EXIT_CODE) + + logger.info("Creating instance '%s' with IP %s..." % (NAME_VM_2, IP_2)) + logger.debug( + "Configuration:\n name=%s \n flavor=%s \n image=%s \n network=%s " + "\n" % (NAME_VM_2, flavor, image, network_id)) + vm2 = nova_client.servers.create( + name=NAME_VM_2, + flavor=flavor, + image=image, + # nics = [{"net-id": network_id, "v4-fixed-ip": IP_2}], + nics=[{"port-id": port_id2}] + ) + + if not waitVmActive(nova_client, vm2): + logger.error("Instance '%s' cannot be booted. Status is '%s'" % ( + NAME_VM_2, functest_utils.get_instance_status(nova_client, vm2))) + cleanup(nova_client, neutron_client, image_id, network_dic, + port_id1, port_id2) + return (EXIT_CODE) + else: + logger.info("Instance '%s' is ACTIVE." % NAME_VM_2) + + logger.info("Creating floating IP for the second VM...") + floatip = functest_utils.create_floating_ip(neutron_client) + if floatip == None: + logger.error("Cannot create floating IP.") + return (EXIT_CODE) + logger.info("Floating IP created: '%s'" % floatip) + + logger.info("Associating floating ip: '%s' to VM2 " % floatip) + if not functest_utils.add_floating_ip(nova_client, vm2.id, floatip): + logger.error("Cannot associate floating IP to VM.") + return (EXIT_CODE) + + timeout = 30 + while timeout > 0: + response = os.system("ping -c 1 " + floatip) + if response == 0: + logger.debug("Floating IP '%s' is reachable!" % floatip) + time.sleep(5) # the VM still needs to do some bootup actions + break + timeout -= 1 + time.sleep(2) + + if timeout == 0: + logger.error("Cannot ping the floating IP '%s'." % floatip) + return (EXIT_CODE) + + logger.info("SCP ping script to VM2...") + SSH_OPTS="-o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no "+\ + "-o LogLevel=quiet" + ping_script = REPO_PATH + "testcases/vPing/CI/libraries/ping.sh" + cmd1 = "sshpass -p 'cubswin:)' scp " + SSH_OPTS + " " + \ + ping_script + " cirros@"+floatip+":~/ping.sh" + cmd2 = "sshpass -p 'cubswin:)' ssh " + SSH_OPTS + \ + " cirros@"+floatip+" 'chmod 755 ~/ping.sh '" + cmd3 = "sshpass -p 'cubswin:)' ssh " + SSH_OPTS + \ + " cirros@"+floatip+" '~/ping.sh "+IP_1+"'" + + logger.info("Waiting for ping...") + sec = 0 + duration = 0 + + while True: + time.sleep(1) + # we do the SCP every time in the loop because while testing, I observed + # that for some strange reason, the cirros VM was deleting the file if + # do the scp only once + subprocess.Popen(cmd1, shell=True, stdout=subprocess.PIPE).stdout.read() + subprocess.Popen(cmd2, shell=True, stdout=subprocess.PIPE).stdout.read() + output=subprocess.Popen(cmd3, shell=True, stdout=subprocess.PIPE).stdout.read() + # print "--"+console_log + # report if the test is failed + if "vPing OK" in output: + logger.info("vPing detected!") + + # we consider start time at VM1 booting + end_time_ts = time.time() + duration = round(end_time_ts - start_time_ts, 1) + logger.info("vPing duration:'%s'" % duration) + EXIT_CODE = 0 + break + elif sec == PING_TIMEOUT: + logger.info("Timeout reached.") + break + else: + logger.debug("No vPing detected...") + sec += 1 + + cleanup(nova_client, neutron_client, image_id, network_dic, + port_id1, port_id2) + + test_status = "NOK" + if EXIT_CODE == 0: + logger.info("vPing OK") + test_status = "OK" + else: + logger.error("vPing FAILED") + + try: + if args.report: + logger.debug("Push result into DB") + # TODO check path result for the file + git_version = functest_utils.get_git_branch(REPO_PATH) + pod_name = functest_utils.get_pod_name(logger) + functest_utils.push_results_to_db(TEST_DB, + "vPing", + logger, pod_name, git_version, + payload={'timestart': start_time_ts, + 'duration': duration, + 'status': test_status}) + # with open("vPing-result.json", "w") as outfile: + # json.dump({'timestart': start_time_ts, 'duration': duration, + # 'status': test_status}, outfile, indent=4) + except: + logger.error("Error pushing results into Database '%s'" % sys.exc_info()[0]) + + exit(EXIT_CODE) + +if __name__ == '__main__': + main() |