def create_network(neutron_client,
net,
subnet1,
cidr1,
router,
subnet2=None,
cidr2=None):
"""Network assoc won't work for networks/subnets created by this function.
It is an ODL limitation due to it handling routers as vpns.
See https://bugs.opendaylight.org/show_bug.cgi?id=6962"""
network_dic = os_utils.create_network_full(neutron_client, net, subnet1,
router, cidr1)
if not network_dic:
logger.error(
"There has been a problem when creating the neutron network")
sys.exit(-1)
net_id = network_dic["net_id"]
subnet_id = network_dic["subnet_id"]
router_id = network_dic["router_id"]
if subnet2 is not None:
logger.debug("Creating and attaching a second subnet...")
subnet_id = os_utils.create_neutron_subnet(neutron_client, subnet2,
cidr2, net_id)
if not subnet_id:
logger.error(
"There has been a problem when creating the second subnet")
sys.exit(-1)
logger.debug("Subnet '%s' created successfully" % subnet_id)
return net_id, subnet_id, router_id
def create_tempest_resources():
ks_creds = os_utils.get_credentials("keystone")
logger.debug("Creating tenant and user for Tempest suite")
keystone = ksclient.Client(**ks_creds)
tenant_id = os_utils.create_tenant(keystone,
TENANT_NAME,
TENANT_DESCRIPTION)
if tenant_id == '':
logger.error("Error : Failed to create %s tenant" % TENANT_NAME)
user_id = os_utils.create_user(keystone, USER_NAME, USER_PASSWORD,
None, tenant_id)
if user_id == '':
logger.error("Error : Failed to create %s user" % USER_NAME)
logger.debug("Creating private network for Tempest suite")
creds_neutron = os_utils.get_credentials("neutron")
neutron_client = neutronclient.Client(**creds_neutron)
network_dic = os_utils.create_network_full(logger,
neutron_client,
PRIVATE_NET_NAME,
PRIVATE_SUBNET_NAME,
ROUTER_NAME,
PRIVATE_SUBNET_CIDR)
if network_dic:
if not os_utils.update_neutron_net(neutron_client,
network_dic['net_id'],
shared=True):
logger.error("Failed to update private network...")
exit(-1)
else:
logger.debug("Network '%s' is available..." % PRIVATE_NET_NAME)
else:
logger.error("Private network creation failed")
exit(-1)
logger.debug("Creating image for Tempest suite")
glance_endpoint = keystone.service_catalog.url_for(
service_type='image', endpoint_type='publicURL')
glance_client = glanceclient.Client(1, glance_endpoint,
token=keystone.auth_token)
# Check if the given image exists
image_id = os_utils.get_image_id(glance_client, GLANCE_IMAGE_NAME)
if image_id != '':
logger.info("Using existing image '%s'..." % GLANCE_IMAGE_NAME)
else:
logger.info("Creating image '%s' from '%s'..." % (GLANCE_IMAGE_NAME,
GLANCE_IMAGE_PATH))
image_id = os_utils.create_glance_image(glance_client,
GLANCE_IMAGE_NAME,
GLANCE_IMAGE_PATH)
if not image_id:
logger.error("Failed to create a Glance image...")
exit(-1)
logger.debug("Image '%s' with ID=%s created successfully."
% (GLANCE_IMAGE_NAME, image_id))
def setup_neutron(neutron_client, net, subnet, router, subnet_cidr):
n_dict = os_utils.create_network_full(neutron_client,
net,
subnet,
router,
subnet_cidr)
if not n_dict:
logger.error("failed to create neutron network")
return False
return n_dict["net_id"]
def setup_neutron(neutron_client):
n_dict = os_utils.create_network_full(neutron_client,
NET_NAME,
SUBNET_NAME,
ROUTER_NAME,
SUBNET_CIDR)
if not n_dict:
logger.error("failed to create neutron network")
sys.exit(-1)
network_id = n_dict["net_id"]
return network_id
def create_network_full(self):
network_dic = os_utils.create_network_full(self.neutron_client,
self.private_net_name,
self.private_subnet_name,
self.router_name,
self.private_subnet_cidr)
if not network_dic:
self.logger.error(
"There has been a problem when creating the neutron network")
return None
network_id = network_dic["net_id"]
return network_id
def deploy_orchestrator(self):
self.logger.info("Additional pre-configuration steps")
nova_client = os_utils.get_nova_client()
neutron_client = os_utils.get_neutron_client()
glance_client = os_utils.get_glance_client()
# Import images if needed
# needs some images
self.logger.info("Upload some OS images if it doesn't exist")
temp_dir = os.path.join(self.data_dir, "tmp/")
for image_name, image_url in self.images.iteritems():
self.logger.info("image: %s, url: %s", image_name, image_url)
try:
image_id = os_utils.get_image_id(glance_client, image_name)
self.logger.info("image_id: %s", image_id)
except BaseException:
self.logger.error("Unexpected error: %s", sys.exc_info()[0])
if image_id == '':
self.logger.info("""%s image doesn't exist on glance
repository. Try downloading this image
and upload on glance !""" % image_name)
image_id = os_utils.download_and_add_image_on_glance(
glance_client, image_name, image_url, temp_dir)
if image_id == '':
self.logger.error("Failed to find or upload required OS "
"image for this deployment")
return False
network_dic = os_utils.create_network_full(neutron_client,
"openbaton_mgmt",
"openbaton_mgmt_subnet",
"openbaton_router",
"192.168.100.0/24")
# orchestrator VM flavor
self.logger.info(
"Check if orchestra Flavor is available, if not create one")
flavor_exist, flavor_id = os_utils.get_or_create_flavor("orchestra",
"4096",
'20',
'2',
public=True)
self.logger.debug("Flavor id: %s" % flavor_id)
if not network_dic:
self.logger.error("There has been a problem when creating the "
"neutron network")
network_id = network_dic["net_id"]
self.logger.info("Creating floating IP for VM in advance...")
floatip_dic = os_utils.create_floating_ip(neutron_client)
floatip = floatip_dic['fip_addr']
if floatip is None:
self.logger.error("Cannot create floating IP.")
return False
userdata = "#!/bin/bash\n"
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"
userdata += ("echo \"ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCuPXrV3"
"geeHc6QUdyUr/1Z+yQiqLcOskiEGBiXr4z76MK4abiFmDZ18OMQlc"
"fl0p3kS0WynVgyaOHwZkgy/DIoIplONVr2CKBKHtPK+Qcme2PVnCtv"
"EqItl/FcD+1h5XSQGoa+A1TSGgCod/DPo+pes0piLVXP8Ph6QS1k7S"
"ic7JDeRQ4oT1bXYpJ2eWBDMfxIWKZqcZRiGPgMIbJ1iEkxbpeaAd9O"
"4MiM9nGCPESmed+p54uYFjwEDlAJZShcAZziiZYAvMZhvAhe6USljc"
"7YAdalAnyD/jwCHuwIrUw/lxo7UdNCmaUxeobEYyyFA1YVXzpNFZya"
"XPGAAYIJwEq/ openbaton@opnfv\" >> /home/ubuntu/.ssh/aut"
"horized_keys\n")
userdata += "echo \"Download bootstrap...\"\n"
userdata += ("curl -s %s " "> ./bootstrap\n" % self.bootstrap_link)
userdata += ("curl -s %s"
"> ./config_file\n" % self.bootstrap_config_link)
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" %
floatip)
userdata += ("sed -i s/rabbitmq_broker_ip=localhost/rabbitmq_broker_ip"
"=%s/g /config_file\n" % floatip)
userdata += "echo \"Set autostart of components to 'false'\"\n"
userdata += "export OPENBATON_COMPONENT_AUTOSTART=false\n"
userdata += "echo \"Execute bootstrap...\"\n"
bootstrap = "sh ./bootstrap release -configFile=./config_file"
userdata += bootstrap + "\n"
userdata += "echo \"Setting 'nfvo.plugin.timeout' to '300000'\"\n"
userdata += ("echo \"nfvo.plugin.timeout=600000\" >> "
"/etc/openbaton/openbaton-nfvo.properties\n")
userdata += (
"wget %s -O /etc/openbaton/openbaton-vnfm-generic-user-data.sh\n" %
self.userdata_file)
userdata += "sed -i '113i\ \ \ \ sleep 60' " \
"/etc/openbaton/openbaton-vnfm-generic-user-data.sh\n"
userdata += "echo \"Starting NFVO\"\n"
userdata += "service openbaton-nfvo restart\n"
userdata += "echo \"Starting Generic VNFM\"\n"
userdata += "service openbaton-vnfm-generic restart\n"
userdata += "echo \"...end of userdata...\"\n"
sg_id = os_utils.create_security_group_full(neutron_client,
"orchestra-sec-group",
"allowall")
os_utils.create_secgroup_rule(neutron_client, sg_id, "ingress", "icmp",
0, 255)
os_utils.create_secgroup_rule(neutron_client, sg_id, "egress", "icmp",
0, 255)
os_utils.create_secgroup_rule(neutron_client, sg_id, "ingress", "tcp",
1, 65535)
os_utils.create_secgroup_rule(neutron_client, sg_id, "ingress", "udp",
1, 65535)
os_utils.create_secgroup_rule(neutron_client, sg_id, "egress", "tcp",
1, 65535)
os_utils.create_secgroup_rule(neutron_client, sg_id, "egress", "udp",
1, 65535)
self.logger.info("Security group set")
self.logger.info("Create instance....")
self.logger.info(
"flavor: m1.medium\n"
"image: %s\n"
"network_id: %s\n"
"userdata: %s\n", self.imagename, network_id, userdata)
instance = os_utils.create_instance_and_wait_for_active(
"orchestra",
os_utils.get_image_id(glance_client, self.imagename),
network_id,
"orchestra-openbaton",
config_drive=False,
userdata=userdata)
self.ob_instance_id = instance.id
self.logger.info("Adding sec group to orchestra instance")
os_utils.add_secgroup_to_instance(nova_client, self.ob_instance_id,
sg_id)
self.logger.info("Associating floating ip: '%s' to VM '%s' ", floatip,
"orchestra-openbaton")
if not os_utils.add_floating_ip(nova_client, instance.id, floatip):
self.logger.error("Cannot associate floating IP to VM.")
return False
self.logger.info("Waiting for Open Baton NFVO to be up and running...")
x = 0
while x < 200:
if servertest(floatip, "8080"):
break
else:
self.logger.debug("Open Baton NFVO is not started yet (%ss)" %
(x * 5))
time.sleep(5)
x += 1
if x == 200:
self.logger.error("Open Baton is not started correctly")
self.ob_ip = floatip
self.ob_password = "******"
self.ob_username = "******"
self.ob_https = False
self.ob_port = "8080"
self.logger.info("Waiting for all components up and running...")
time.sleep(60)
self.details["orchestrator"] = {
'status': "PASS",
'result': "Deploy Open Baton NFVO: OK"
}
self.logger.info("Deploy Open Baton NFVO: OK")
return True
def main():
global SUMMARY
global network_dict
start_time = time.time()
stop_time = start_time
# configure script
if not (args.test_name in tests):
logger.error('argument not valid')
exit(-1)
SUMMARY = []
creds_nova = openstack_utils.get_credentials("nova")
nova_client = novaclient.Client('2', **creds_nova)
creds_neutron = openstack_utils.get_credentials("neutron")
neutron_client = neutronclient.Client(**creds_neutron)
creds_keystone = openstack_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)
creds_cinder = openstack_utils.get_credentials("cinder")
cinder_client = cinderclient.Client('2',
creds_cinder['username'],
creds_cinder['api_key'],
creds_cinder['project_id'],
creds_cinder['auth_url'],
service_type="volume")
client_dict['neutron'] = neutron_client
volume_types = openstack_utils.list_volume_types(cinder_client,
private=False)
if not volume_types:
volume_type = openstack_utils.create_volume_type(
cinder_client, CINDER_VOLUME_TYPE_NAME)
if not volume_type:
logger.error("Failed to create volume type...")
exit(-1)
else:
logger.debug("Volume type '%s' created succesfully..." %
CINDER_VOLUME_TYPE_NAME)
else:
logger.debug("Using existing volume type(s)...")
image_id = openstack_utils.get_image_id(glance_client, GLANCE_IMAGE_NAME)
image_exists = False
if image_id == '':
logger.debug("Creating image '%s' from '%s'..." %
(GLANCE_IMAGE_NAME, GLANCE_IMAGE_PATH))
image_id = openstack_utils.create_glance_image(glance_client,
GLANCE_IMAGE_NAME,
GLANCE_IMAGE_PATH)
if not image_id:
logger.error("Failed to create the Glance image...")
exit(-1)
else:
logger.debug("Image '%s' with ID '%s' created succesfully ." %
(GLANCE_IMAGE_NAME, image_id))
else:
logger.debug("Using existing image '%s' with ID '%s'..." %
(GLANCE_IMAGE_NAME, image_id))
image_exists = True
logger.debug("Creating network '%s'..." % PRIVATE_NET_NAME)
network_dict = openstack_utils.create_network_full(
logger, client_dict['neutron'], PRIVATE_NET_NAME, PRIVATE_SUBNET_NAME,
ROUTER_NAME, PRIVATE_SUBNET_CIDR)
if not network_dict:
logger.error("Failed to create network...")
exit(-1)
else:
if not openstack_utils.update_neutron_net(
client_dict['neutron'], network_dict['net_id'], shared=True):
logger.error("Failed to update network...")
exit(-1)
else:
logger.debug("Network '%s' available..." % PRIVATE_NET_NAME)
if args.test_name == "all":
for test_name in tests:
if not (test_name == 'all' or test_name == 'vm'):
run_task(test_name)
else:
logger.debug("Test name: " + args.test_name)
run_task(args.test_name)
report = ("\n"
" "
"\n"
" Rally Summary Report\n"
"\n"
"+===================+============+===============+===========+"
"\n"
"| Module | Duration | nb. Test Run | Success |"
"\n"
"+===================+============+===============+===========+"
"\n")
payload = []
stop_time = time.time()
# for each scenario we draw a row for the table
total_duration = 0.0
total_nb_tests = 0
total_success = 0.0
for s in SUMMARY:
name = "{0:<17}".format(s['test_name'])
duration = float(s['overall_duration'])
total_duration += duration
duration = time.strftime("%M:%S", time.gmtime(duration))
duration = "{0:<10}".format(duration)
nb_tests = "{0:<13}".format(s['nb_tests'])
total_nb_tests += int(s['nb_tests'])
success = "{0:<10}".format(str(s['success']) + '%')
total_success += float(s['success'])
report += ("" + "| " + name + " | " + duration + " | " + nb_tests +
" | " + success + "|\n" +
"+-------------------+------------"
"+---------------+-----------+\n")
payload.append({
'module': name,
'details': {
'duration': s['overall_duration'],
'nb tests': s['nb_tests'],
'success': s['success']
}
})
total_duration_str = time.strftime("%H:%M:%S", time.gmtime(total_duration))
total_duration_str2 = "{0:<10}".format(total_duration_str)
total_nb_tests_str = "{0:<13}".format(total_nb_tests)
total_success = "{:0.2f}".format(total_success / len(SUMMARY))
total_success_str = "{0:<10}".format(str(total_success) + '%')
report += "+===================+============+===============+===========+"
report += "\n"
report += ("| TOTAL: | " + total_duration_str2 + " | " +
total_nb_tests_str + " | " + total_success_str + "|\n")
report += "+===================+============+===============+===========+"
report += "\n"
logger.info("\n" + report)
payload.append({
'summary': {
'duration': total_duration,
'nb tests': total_nb_tests,
'nb success': total_success
}
})
# Generate json results for DB
# json_results = {"timestart": time_start, "duration": total_duration,
# "tests": int(total_nb_tests),
# "success": int(total_success)}
# logger.info("Results: "+str(json_results))
# Evaluation of the success criteria
status = "failed"
# for Rally we decided that the overall success rate must be above 90%
if total_success >= 90:
status = "passed"
if args.sanity:
case_name = "rally_sanity"
else:
case_name = "rally_full"
if args.report:
logger.debug("Pushing Rally summary into DB...")
functest_utils.push_results_to_db("functest", case_name, None,
start_time, stop_time, status,
payload)
if args.noclean:
exit(0)
if not image_exists:
logger.debug("Deleting image '%s' with ID '%s'..." %
(GLANCE_IMAGE_NAME, image_id))
if not openstack_utils.delete_glance_image(nova_client, image_id):
logger.error("Error deleting the glance image")
if not volume_types:
logger.debug("Deleting volume type '%s'..." % CINDER_VOLUME_TYPE_NAME)
if not openstack_utils.delete_volume_type(cinder_client, volume_type):
logger.error("Error in deleting volume type...")
def main():
creds_nova = openstack_utils.get_credentials("nova")
nova_client = novaclient.Client('2', **creds_nova)
creds_neutron = openstack_utils.get_credentials("neutron")
neutron_client = neutronclient.Client(**creds_neutron)
creds_keystone = openstack_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_id = None
flavor = None
# Check if the given image exists
image_id = openstack_utils.get_image_id(glance_client, GLANCE_IMAGE_NAME)
if image_id != '':
logger.info("Using existing image '%s'..." % GLANCE_IMAGE_NAME)
global image_exists
image_exists = True
else:
logger.info("Creating image '%s' from '%s'..." % (GLANCE_IMAGE_NAME,
GLANCE_IMAGE_PATH))
image_id = openstack_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)
logger.debug("Image '%s' with ID=%s created successfully."
% (GLANCE_IMAGE_NAME, image_id))
network_dic = openstack_utils.create_network_full(logger,
neutron_client,
PRIVATE_NET_NAME,
PRIVATE_SUBNET_NAME,
ROUTER_NAME,
PRIVATE_SUBNET_CIDR)
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"]
create_security_group(neutron_client)
# 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())
exit(-1)
# 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 = time.time()
stop_time = start_time
logger.info("vPing Start Time:'%s'" % (
datetime.datetime.fromtimestamp(start_time).strftime(
'%Y-%m-%d %H:%M:%S')))
# create VM
logger.info("Creating instance '%s'..." % NAME_VM_1)
logger.debug(
"Configuration:\n name=%s \n flavor=%s \n image=%s \n "
"network=%s \n" % (NAME_VM_1, flavor, image_id, network_id))
vm1 = nova_client.servers.create(
name=NAME_VM_1,
flavor=flavor,
image=image_id,
config_drive=True,
nics=[{"net-id": network_id}]
)
# 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, openstack_utils.get_instance_status(nova_client, vm1)))
return (EXIT_CODE)
else:
logger.info("Instance '%s' is ACTIVE." % NAME_VM_1)
# Retrieve IP of first VM
test_ip = vm1.networks.get(PRIVATE_NET_NAME)[0]
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
u = ("#!/bin/sh\n\nwhile true; do\n ping -c 1 %s 2>&1 >/dev/null\n "
"RES=$?\n if [ \"Z$RES\" = \"Z0\" ] ; then\n echo 'vPing OK'\n "
"break\n else\n echo 'vPing KO'\n fi\n sleep 1\ndone\n" % test_ip)
# create VM
logger.info("Creating instance '%s'..." % NAME_VM_2)
logger.debug(
"Configuration:\n name=%s \n flavor=%s \n image=%s \n network=%s "
"\n userdata= \n%s" % (
NAME_VM_2, flavor, image_id, network_id, u))
vm2 = nova_client.servers.create(
name=NAME_VM_2,
flavor=flavor,
image=image_id,
nics=[{"net-id": network_id}],
config_drive=True,
userdata=u
)
if not waitVmActive(nova_client, vm2):
logger.error("Instance '%s' cannot be booted. Status is '%s'" % (
NAME_VM_2, openstack_utils.get_instance_status(nova_client, vm2)))
return (EXIT_CODE)
else:
logger.info("Instance '%s' is ACTIVE." % NAME_VM_2)
logger.info("Waiting for ping...")
sec = 0
metadata_tries = 0
console_log = vm2.get_console_output()
duration = 0
stop_time = time.time()
while True:
time.sleep(1)
console_log = vm2.get_console_output()
# print "--"+console_log
# report if the test is failed
if "vPing OK" in console_log:
logger.info("vPing detected!")
# we consider start time at VM1 booting
stop_time = time.time()
duration = round(stop_time - start_time, 1)
logger.info("vPing duration:'%s'" % duration)
EXIT_CODE = 0
break
elif ("failed to read iid from metadata" in console_log or
metadata_tries > 5):
EXIT_CODE = -2
break
elif sec == PING_TIMEOUT:
logger.info("Timeout reached.")
break
elif sec % 10 == 0:
if "request failed" in console_log:
logger.debug("It seems userdata is not supported in "
"nova boot. Waiting a bit...")
metadata_tries += 1
else:
logger.debug("Pinging %s. Waiting for response..." % test_ip)
sec += 1
test_status = "NOK"
if EXIT_CODE == 0:
logger.info("vPing OK")
test_status = "OK"
elif EXIT_CODE == -2:
duration = 0
logger.info("Userdata is not supported in nova boot. Aborting test...")
else:
duration = 0
logger.error("vPing FAILED")
if args.report:
try:
logger.debug("Pushing vPing userdata results into DB...")
functest_utils.push_results_to_db("functest",
"vping_userdata",
logger,
start_time,
stop_time,
test_status,
details={'timestart': start_time,
'duration': duration,
'status': test_status})
except:
logger.error("Error pushing results into Database '%s'"
% sys.exc_info()[0])
exit(EXIT_CODE)
def main():
exit_code = -1
start_time = time.time()
ks_creds = openstack_utils.get_credentials("keystone")
nv_creds = openstack_utils.get_credentials("nova")
nt_creds = openstack_utils.get_credentials("neutron")
keystone = ksclient.Client(**ks_creds)
user_id = openstack_utils.get_user_id(keystone, ks_creds['username'])
if user_id == '':
logger.error("Error : Failed to get id of %s user" %
ks_creds['username'])
exit(-1)
logger.info("Creating tenant '%s'..." % PROMISE_TENANT_NAME)
tenant_id = openstack_utils.create_tenant(keystone, PROMISE_TENANT_NAME,
TENANT_DESCRIPTION)
if not tenant_id:
logger.error("Error : Failed to create %s tenant" %
PROMISE_TENANT_NAME)
exit(-1)
logger.debug("Tenant '%s' created successfully." % PROMISE_TENANT_NAME)
roles_name = ["admin", "Admin"]
role_id = ''
for role_name in roles_name:
if role_id == '':
role_id = openstack_utils.get_role_id(keystone, role_name)
if role_id == '':
logger.error("Error : Failed to get id for %s role" % role_name)
exit(-1)
logger.info("Adding role '%s' to tenant '%s'..." %
(role_id, PROMISE_TENANT_NAME))
if not openstack_utils.add_role_user(keystone, user_id, role_id,
tenant_id):
logger.error("Error : Failed to add %s on tenant %s" %
(ks_creds['username'], PROMISE_TENANT_NAME))
exit(-1)
logger.debug("Role added successfully.")
logger.info("Creating user '%s'..." % PROMISE_USER_NAME)
user_id = openstack_utils.create_user(keystone, PROMISE_USER_NAME,
PROMISE_USER_PWD, None, tenant_id)
if not user_id:
logger.error("Error : Failed to create %s user" % PROMISE_USER_NAME)
exit(-1)
logger.debug("User '%s' created successfully." % PROMISE_USER_NAME)
logger.info("Updating OpenStack credentials...")
ks_creds.update({
"username": PROMISE_TENANT_NAME,
"password": PROMISE_TENANT_NAME,
"tenant_name": PROMISE_TENANT_NAME,
})
nt_creds.update({
"tenant_name": PROMISE_TENANT_NAME,
})
nv_creds.update({
"project_id": PROMISE_TENANT_NAME,
})
glance = openstack_utils.get_glance_client()
nova = nvclient.Client("2", **nv_creds)
logger.info("Creating image '%s' from '%s'..." %
(PROMISE_IMAGE_NAME, GLANCE_IMAGE_PATH))
image_id = openstack_utils.create_glance_image(glance, PROMISE_IMAGE_NAME,
GLANCE_IMAGE_PATH)
if not image_id:
logger.error("Failed to create the Glance image...")
exit(-1)
logger.debug("Image '%s' with ID '%s' created successfully." %
(PROMISE_IMAGE_NAME, image_id))
flavor_id = openstack_utils.get_flavor_id(nova, PROMISE_FLAVOR_NAME)
if flavor_id == '':
logger.info("Creating flavor '%s'..." % PROMISE_FLAVOR_NAME)
flavor_id = openstack_utils.create_flavor(nova, PROMISE_FLAVOR_NAME,
PROMISE_FLAVOR_RAM,
PROMISE_FLAVOR_DISK,
PROMISE_FLAVOR_VCPUS)
if not flavor_id:
logger.error("Failed to create the Flavor...")
exit(-1)
logger.debug("Flavor '%s' with ID '%s' created successfully." %
(PROMISE_FLAVOR_NAME, flavor_id))
else:
logger.debug("Using existing flavor '%s' with ID '%s'..." %
(PROMISE_FLAVOR_NAME, flavor_id))
neutron = ntclient.Client(**nt_creds)
network_dic = openstack_utils.create_network_full(neutron,
PROMISE_NET_NAME,
PROMISE_SUBNET_NAME,
PROMISE_ROUTER_NAME,
PROMISE_SUBNET_CIDR)
if not network_dic:
logger.error("Failed to create the private network...")
exit(-1)
logger.info("Exporting environment variables...")
os.environ["NODE_ENV"] = "functest"
os.environ["OS_PASSWORD"] = PROMISE_USER_PWD
os.environ["OS_TEST_IMAGE"] = image_id
os.environ["OS_TEST_FLAVOR"] = flavor_id
os.environ["OS_TEST_NETWORK"] = network_dic["net_id"]
os.environ["OS_TENANT_NAME"] = PROMISE_TENANT_NAME
os.environ["OS_USERNAME"] = PROMISE_USER_NAME
os.chdir(PROMISE_REPO_DIR + '/source/')
results_file_name = os.path.join(RESULTS_DIR, 'promise-results.json')
results_file = open(results_file_name, 'w+')
cmd = 'npm run -s test -- --reporter json'
logger.info("Running command: %s" % cmd)
ret = subprocess.call(cmd,
shell=True,
stdout=results_file,
stderr=subprocess.STDOUT)
results_file.close()
if ret == 0:
logger.info("The test succeeded.")
# test_status = 'OK'
else:
logger.info("The command '%s' failed." % cmd)
# test_status = "Failed"
# Print output of file
with open(results_file_name, 'r') as results_file:
data = results_file.read()
logger.debug("\n%s" % data)
json_data = json.loads(data)
suites = json_data["stats"]["suites"]
tests = json_data["stats"]["tests"]
passes = json_data["stats"]["passes"]
pending = json_data["stats"]["pending"]
failures = json_data["stats"]["failures"]
start_time_json = json_data["stats"]["start"]
end_time = json_data["stats"]["end"]
duration = float(json_data["stats"]["duration"]) / float(1000)
logger.info("\n"
"****************************************\n"
" Promise test report\n\n"
"****************************************\n"
" Suites: \t%s\n"
" Tests: \t%s\n"
" Passes: \t%s\n"
" Pending: \t%s\n"
" Failures:\t%s\n"
" Start: \t%s\n"
" End: \t%s\n"
" Duration:\t%s\n"
"****************************************\n\n" %
(suites, tests, passes, pending, failures, start_time_json,
end_time, duration))
if args.report:
stop_time = time.time()
json_results = {
"timestart": start_time,
"duration": duration,
"tests": int(tests),
"failures": int(failures)
}
logger.debug("Promise Results json: " + str(json_results))
# criteria for Promise in Release B was 100% of tests OK
status = "FAIL"
if int(tests) > 32 and int(failures) < 1:
status = "PASS"
exit_code = 0
ft_utils.push_results_to_db("promise", "promise", start_time,
stop_time, status, json_results)
exit(exit_code)
def main():
start_time = time.time()
ks_creds = openstack_utils.get_credentials("keystone")
nv_creds = openstack_utils.get_credentials("nova")
nt_creds = openstack_utils.get_credentials("neutron")
keystone = ksclient.Client(**ks_creds)
user_id = openstack_utils.get_user_id(keystone, ks_creds['username'])
if user_id == '':
logger.error("Error : Failed to get id of %s user" %
ks_creds['username'])
exit(-1)
logger.info("Creating tenant '%s'..." % TENANT_NAME)
tenant_id = openstack_utils.create_tenant(
keystone, TENANT_NAME, TENANT_DESCRIPTION)
if tenant_id == '':
logger.error("Error : Failed to create %s tenant" % TENANT_NAME)
exit(-1)
logger.debug("Tenant '%s' created successfully." % TENANT_NAME)
roles_name = ["admin", "Admin"]
role_id = ''
for role_name in roles_name:
if role_id == '':
role_id = openstack_utils.get_role_id(keystone, role_name)
if role_id == '':
logger.error("Error : Failed to get id for %s role" % role_name)
exit(-1)
logger.info("Adding role '%s' to tenant '%s'..." % (role_id, TENANT_NAME))
if not openstack_utils.add_role_user(keystone, user_id,
role_id, tenant_id):
logger.error("Error : Failed to add %s on tenant %s" %
(ks_creds['username'], TENANT_NAME))
exit(-1)
logger.debug("Role added successfully.")
logger.info("Creating user '%s'..." % USER_NAME)
user_id = openstack_utils.create_user(
keystone, USER_NAME, USER_PWD, None, tenant_id)
if user_id == '':
logger.error("Error : Failed to create %s user" % USER_NAME)
exit(-1)
logger.debug("User '%s' created successfully." % USER_NAME)
logger.info("Updating OpenStack credentials...")
ks_creds.update({
"username": TENANT_NAME,
"password": TENANT_NAME,
"tenant_name": TENANT_NAME,
})
nt_creds.update({
"tenant_name": TENANT_NAME,
})
nv_creds.update({
"project_id": TENANT_NAME,
})
glance_endpoint = keystone.service_catalog.url_for(
service_type='image', endpoint_type='publicURL')
glance = glclient.Client(1, glance_endpoint, token=keystone.auth_token)
nova = nvclient.Client("2", **nv_creds)
logger.info("Creating image '%s' from '%s'..." % (IMAGE_NAME,
GLANCE_IMAGE_PATH))
image_id = openstack_utils.create_glance_image(glance,
IMAGE_NAME,
GLANCE_IMAGE_PATH)
if not image_id:
logger.error("Failed to create the Glance image...")
exit(-1)
logger.debug("Image '%s' with ID '%s' created successfully." % (IMAGE_NAME,
image_id))
flavor_id = openstack_utils.get_flavor_id(nova, FLAVOR_NAME)
if flavor_id == '':
logger.info("Creating flavor '%s'..." % FLAVOR_NAME)
flavor_id = openstack_utils.create_flavor(nova,
FLAVOR_NAME,
FLAVOR_RAM,
FLAVOR_DISK,
FLAVOR_VCPUS)
if not flavor_id:
logger.error("Failed to create the Flavor...")
exit(-1)
logger.debug("Flavor '%s' with ID '%s' created successfully." %
(FLAVOR_NAME, flavor_id))
else:
logger.debug("Using existing flavor '%s' with ID '%s'..."
% (FLAVOR_NAME, flavor_id))
neutron = ntclient.Client(**nt_creds)
network_dic = openstack_utils.create_network_full(logger,
neutron,
NET_NAME,
SUBNET_NAME,
ROUTER_NAME,
SUBNET_CIDR)
if network_dic is False:
logger.error("Failed to create the private network...")
exit(-1)
logger.info("Exporting environment variables...")
os.environ["NODE_ENV"] = "functest"
os.environ["OS_TENANT_NAME"] = TENANT_NAME
os.environ["OS_USERNAME"] = USER_NAME
os.environ["OS_PASSWORD"] = USER_PWD
os.environ["OS_TEST_IMAGE"] = image_id
os.environ["OS_TEST_FLAVOR"] = flavor_id
os.environ["OS_TEST_NETWORK"] = network_dic["net_id"]
os.chdir(PROMISE_REPO)
results_file_name = 'promise-results.json'
results_file = open(results_file_name, 'w+')
cmd = 'npm run -s test -- --reporter json'
logger.info("Running command: %s" % cmd)
ret = subprocess.call(cmd, shell=True, stdout=results_file,
stderr=subprocess.STDOUT)
results_file.close()
if ret == 0:
logger.info("The test succeeded.")
# test_status = 'OK'
else:
logger.info("The command '%s' failed." % cmd)
# test_status = "Failed"
# Print output of file
with open(results_file_name, 'r') as results_file:
data = results_file.read()
logger.debug("\n%s" % data)
json_data = json.loads(data)
suites = json_data["stats"]["suites"]
tests = json_data["stats"]["tests"]
passes = json_data["stats"]["passes"]
pending = json_data["stats"]["pending"]
failures = json_data["stats"]["failures"]
start_time_json = json_data["stats"]["start"]
end_time = json_data["stats"]["end"]
duration = float(json_data["stats"]["duration"]) / float(1000)
logger.info("\n"
"****************************************\n"
" Promise test report\n\n"
"****************************************\n"
" Suites: \t%s\n"
" Tests: \t%s\n"
" Passes: \t%s\n"
" Pending: \t%s\n"
" Failures:\t%s\n"
" Start: \t%s\n"
" End: \t%s\n"
" Duration:\t%s\n"
"****************************************\n\n"
% (suites, tests, passes, pending, failures,
start_time_json, end_time, duration))
if args.report:
stop_time = time.time()
json_results = {"timestart": start_time, "duration": duration,
"tests": int(tests), "failures": int(failures)}
logger.debug("Promise Results json: " + str(json_results))
# criteria for Promise in Release B was 100% of tests OK
status = "FAIL"
if int(tests) > 32 and int(failures) < 1:
status = "PASS"
functest_utils.push_results_to_db("promise",
"promise",
logger,
start_time,
stop_time,
status,
json_results)
def main():
creds_nova = openstack_utils.get_credentials("nova")
nova_client = novaclient.Client('2', **creds_nova)
creds_neutron = openstack_utils.get_credentials("neutron")
neutron_client = neutronclient.Client(**creds_neutron)
creds_keystone = openstack_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_id = None
flavor = None
# Check if the given image exists
image_id = openstack_utils.get_image_id(glance_client, GLANCE_IMAGE_NAME)
if image_id != '':
logger.info("Using existing image '%s'..." % GLANCE_IMAGE_NAME)
global image_exists
image_exists = True
else:
logger.info("Creating image '%s' from '%s'..." % (GLANCE_IMAGE_NAME,
GLANCE_IMAGE_PATH))
image_id = openstack_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)
logger.debug("Image '%s' with ID=%s created successfully."
% (GLANCE_IMAGE_NAME, image_id))
network_dic = openstack_utils.create_network_full(logger,
neutron_client,
PRIVATE_NET_NAME,
PRIVATE_SUBNET_NAME,
ROUTER_NAME,
PRIVATE_SUBNET_CIDR)
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"]
sg_id = create_security_group(neutron_client)
# Check if the given flavor exists
try:
flavor = nova_client.flavors.find(name=FLAVOR)
logger.info("Using existing Flavor '%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
start_time = time.time()
stop_time = start_time
logger.info("vPing Start Time:'%s'" % (
datetime.datetime.fromtimestamp(start_time).strftime(
'%Y-%m-%d %H:%M:%S')))
logger.info("Creating instance '%s'..." % NAME_VM_1)
logger.debug(
"Configuration:\n name=%s \n flavor=%s \n image=%s \n "
"network=%s \n" % (NAME_VM_1, flavor, image_id, network_id))
vm1 = nova_client.servers.create(
name=NAME_VM_1,
flavor=flavor,
image=image_id,
nics=[{"net-id": network_id}]
)
# 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, openstack_utils.get_instance_status(nova_client, vm1)))
return (EXIT_CODE)
else:
logger.info("Instance '%s' is ACTIVE." % NAME_VM_1)
# Retrieve IP of first VM
test_ip = vm1.networks.get(PRIVATE_NET_NAME)[0]
logger.debug("Instance '%s' got private ip '%s'." % (NAME_VM_1, test_ip))
logger.info("Adding '%s' to security group '%s'..."
% (NAME_VM_1, SECGROUP_NAME))
openstack_utils.add_secgroup_to_instance(nova_client, vm1.id, sg_id)
# boot VM 2
logger.info("Creating instance '%s'..." % NAME_VM_2)
logger.debug(
"Configuration:\n name=%s \n flavor=%s \n image=%s \n "
"network=%s \n" % (NAME_VM_2, flavor, image_id, network_id))
vm2 = nova_client.servers.create(
name=NAME_VM_2,
flavor=flavor,
image=image_id,
nics=[{"net-id": network_id}]
)
if not waitVmActive(nova_client, vm2):
logger.error("Instance '%s' cannot be booted. Status is '%s'" % (
NAME_VM_2, openstack_utils.get_instance_status(nova_client, vm2)))
return (EXIT_CODE)
else:
logger.info("Instance '%s' is ACTIVE." % NAME_VM_2)
logger.info("Adding '%s' to security group '%s'..." % (NAME_VM_2,
SECGROUP_NAME))
openstack_utils.add_secgroup_to_instance(nova_client, vm2.id, sg_id)
logger.info("Creating floating IP for VM '%s'..." % NAME_VM_2)
floatip_dic = openstack_utils.create_floating_ip(neutron_client)
floatip = floatip_dic['fip_addr']
# floatip_id = floatip_dic['fip_id']
if floatip is None:
logger.error("Cannot create floating IP.")
return (EXIT_CODE)
logger.info("Floating IP created: '%s'" % floatip)
logger.info("Associating floating ip: '%s' to VM '%s' "
% (floatip, NAME_VM_2))
if not openstack_utils.add_floating_ip(nova_client, vm2.id, floatip):
logger.error("Cannot associate floating IP to VM.")
return (EXIT_CODE)
logger.info("Trying to establish SSH connection to %s..." % floatip)
username = '******'
password = '******'
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
timeout = 50
nolease = False
got_ip = False
discover_count = 0
cidr_first_octet = PRIVATE_SUBNET_CIDR.split('.')[0]
while timeout > 0:
try:
ssh.connect(floatip, username=username,
password=password, timeout=2)
logger.debug("SSH connection established to %s." % floatip)
break
except:
logger.debug("Waiting for %s..." % floatip)
time.sleep(6)
timeout -= 1
console_log = vm2.get_console_output()
# print each "Sending discover" captured on the console log
if (len(re.findall("Sending discover", console_log)) >
discover_count and not got_ip):
discover_count += 1
logger.debug("Console-log '%s': Sending discover..."
% NAME_VM_2)
# check if eth0 got an ip,the line looks like this:
# "inet addr:192.168."....
# if the dhcp agent fails to assing ip, this line will not appear
if "inet addr:" + cidr_first_octet in console_log and not got_ip:
got_ip = True
logger.debug("The instance '%s' succeeded to get the IP "
"from the dhcp agent.")
# if dhcp doesnt work,it shows "No lease, failing".The test will fail
if "No lease, failing" in console_log and not nolease and not got_ip:
nolease = True
logger.debug("Console-log '%s': No lease, failing..."
% NAME_VM_2)
logger.info("The instance failed to get an IP from the "
"DHCP agent. The test will probably timeout...")
if timeout == 0: # 300 sec timeout (5 min)
logger.error("Cannot establish connection to IP '%s'. Aborting"
% floatip)
return (EXIT_CODE)
scp = SCPClient(ssh.get_transport())
ping_script = REPO_PATH + "testcases/OpenStack/vPing/ping.sh"
try:
scp.put(ping_script, "~/")
except:
logger.error("Cannot SCP the file '%s' to VM '%s'"
% (ping_script, floatip))
return (EXIT_CODE)
cmd = 'chmod 755 ~/ping.sh'
(stdin, stdout, stderr) = ssh.exec_command(cmd)
for line in stdout.readlines():
print line
logger.info("Waiting for ping...")
sec = 0
stop_time = time.time()
duration = 0
cmd = '~/ping.sh ' + test_ip
flag = False
status = "FAIL"
while True:
time.sleep(1)
(stdin, stdout, stderr) = ssh.exec_command(cmd)
output = stdout.readlines()
for line in output:
if "vPing OK" in line:
logger.info("vPing detected!")
status = "PASS"
# we consider start time at VM1 booting
stop_time = time.time()
duration = round(stop_time - start_time, 1)
logger.info("vPing duration:'%s' s." % duration)
EXIT_CODE = 0
flag = True
break
elif sec == PING_TIMEOUT:
logger.info("Timeout reached.")
flag = True
break
if flag:
break
logger.debug("Pinging %s. Waiting for response..." % test_ip)
sec += 1
if status == "PASS":
logger.info("vPing OK")
else:
duration = 0
logger.error("vPing FAILED")
if args.report:
try:
logger.debug("Pushing vPing SSH results into DB...")
functest_utils.push_results_to_db("functest",
"vping_ssh",
logger,
start_time,
stop_time,
status,
details={'timestart': start_time,
'duration': duration,
'status': status})
except:
logger.error("Error pushing results into Database '%s'"
% sys.exc_info()[0])
exit(EXIT_CODE)
def main():
nova_client = os_utils.get_nova_client()
neutron_client = os_utils.get_neutron_client()
glance_client = os_utils.get_glance_client()
# Download the image
if not os.path.isfile(IMAGE_PATH):
logger.info("Downloading image")
ft_utils.download_url(
"http://artifacts.opnfv.org/sfc/demo/sf_summit2016.qcow2",
"/home/opnfv/functest/data/")
else:
logger.info("Using old image")
# Allow any port so that tacker commands reaches the server.
# CHECK IF THIS STILL MAKES SENSE WHEN TACKER IS INCLUDED IN OPNFV INSTALATION
controller_command = ("sshpass -p r00tme ssh [email protected]"
" 'fuel node'|grep controller|awk '{print $10}'")
logger.info("Executing tacker script: '%s'" % controller_command)
process = subprocess.Popen(controller_command,
shell=True,
stdout=subprocess.PIPE)
ip = process.stdout.readline()
iptable_command1 = ("sshpass -p r00tme ssh [email protected] ssh"
" " + ip + " iptables -P INPUT ACCEPT ")
iptable_command2 = ("sshpass -p r00tme ssh [email protected] ssh"
" " + ip + "iptables -t nat -P INPUT ACCEPT ")
subprocess.call(iptable_command1, shell=True)
subprocess.call(iptable_command2, shell=True)
# Create glance image and the neutron network
image_id = os_utils.create_glance_image(glance_client,
IMAGE_NAME,
IMAGE_PATH,
disk=IMAGE_FORMAT,
container="bare",
public=True,
logger=logger)
network_dic = os_utils.create_network_full(logger,
neutron_client,
NET_NAME,
SUBNET_NAME,
ROUTER_NAME,
SUBNET_CIDR)
if not network_dic:
logger.error(
"There has been a problem when creating the neutron network")
sys.exit(-1)
network_id = network_dic["net_id"]
sg_id = os_utils.create_security_group_full(logger, neutron_client,
SECGROUP_NAME, SECGROUP_DESCR)
# boot INTANCE
logger.info("Creating instance '%s'..." % INSTANCE_NAME)
logger.debug(
"Configuration:\n name=%s \n flavor=%s \n image=%s \n "
"network=%s \n" % (INSTANCE_NAME, FLAVOR, image_id, network_id))
instance = os_utils.create_instance_and_wait_for_active(FLAVOR,
image_id,
network_id,
INSTANCE_NAME)
if instance is None:
logger.error("Error while booting instance.")
sys.exit(-1)
# Retrieve IP of INSTANCE
instance_ip = instance.networks.get(NET_NAME)[0]
logger.debug("Instance '%s' got private ip '%s'." %
(INSTANCE_NAME, instance_ip))
logger.info("Adding '%s' to security group '%s'..."
% (INSTANCE_NAME, SECGROUP_NAME))
os_utils.add_secgroup_to_instance(nova_client, instance.id, sg_id)
logger.info("Creating floating IP for VM '%s'..." % INSTANCE_NAME)
floatip_dic = os_utils.create_floating_ip(neutron_client)
floatip_client = floatip_dic['fip_addr']
# floatip_id = floatip_dic['fip_id']
if floatip_client is None:
logger.error("Cannot create floating IP.")
sys.exit(-1)
logger.info("Floating IP created: '%s'" % floatip_client)
logger.info("Associating floating ip: '%s' to VM '%s' "
% (floatip_client, INSTANCE_NAME))
if not os_utils.add_floating_ip(nova_client, instance.id, floatip_client):
logger.error("Cannot associate floating IP to VM.")
sys.exit(-1)
# STARTING SECOND VM (server) ###
# boot INTANCE
logger.info("Creating instance '%s'..." % INSTANCE_NAME)
logger.debug(
"Configuration:\n name=%s \n flavor=%s \n image=%s \n "
"network=%s \n" % (INSTANCE_NAME, FLAVOR, image_id, network_id))
instance_2 = os_utils.create_instance_and_wait_for_active(FLAVOR,
image_id,
network_id,
INSTANCE_NAME_2)
if instance_2 is None:
logger.error("Error while booting instance.")
sys.exit(-1)
# Retrieve IP of INSTANCE
instance_ip_2 = instance_2.networks.get(NET_NAME)[0]
logger.debug("Instance '%s' got private ip '%s'." %
(INSTANCE_NAME_2, instance_ip_2))
logger.info("Adding '%s' to security group '%s'..."
% (INSTANCE_NAME_2, SECGROUP_NAME))
os_utils.add_secgroup_to_instance(nova_client, instance_2.id, sg_id)
logger.info("Creating floating IP for VM '%s'..." % INSTANCE_NAME_2)
floatip_dic = os_utils.create_floating_ip(neutron_client)
floatip_server = floatip_dic['fip_addr']
# floatip_id = floatip_dic['fip_id']
if floatip_server is None:
logger.error("Cannot create floating IP.")
sys.exit(-1)
logger.info("Floating IP created: '%s'" % floatip_server)
logger.info("Associating floating ip: '%s' to VM '%s' "
% (floatip_server, INSTANCE_NAME_2))
if not os_utils.add_floating_ip(nova_client,
instance_2.id,
floatip_server):
logger.error("Cannot associate floating IP to VM.")
sys.exit(-1)
# CREATION OF THE 2 SF ####
tacker_script = "/home/opnfv/repos/functest/testcases/features/sfc/" + \
TACKER_SCRIPT
logger.info("Executing tacker script: '%s'" % tacker_script)
subprocess.call(tacker_script, shell=True)
# SSH CALL TO START HTTP SERVER
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
try:
ssh.connect(floatip_server, username="******",
password="******", timeout=2)
command = "python -m SimpleHTTPServer 80 > /dev/null 2>&1 &"
logger.info("Starting HTTP server")
(stdin, stdout, stderr) = ssh.exec_command(command)
except:
logger.debug("Waiting for %s..." % floatip_server)
time.sleep(6)
# timeout -= 1
instances = nova_client.servers.list(search_opts={'all_tenants': 1})
ips = []
try:
for instance in instances:
if "server" not in instance.name:
if "client" not in instance.name:
logger.debug(
"This is the instance name: %s " % instance.name)
floatip_dic = os_utils.create_floating_ip(neutron_client)
floatip = floatip_dic['fip_addr']
ips.append(floatip)
instance.add_floating_ip(floatip)
except:
logger.debug("Problems assigning floating IP to SFs")
logger.debug("Floating IPs for SFs: %s..." % ips)
# SSH TO START THE VXLAN_TOOL ON SF1
logger.info("Configuring the SFs")
try:
ssh.connect(ips[0], username="******",
password="******", timeout=2)
command = ("nohup python vxlan_tool.py -i eth0 "
"-d forward -v off -f -b 80 &")
(stdin, stdout, stderr) = ssh.exec_command(command)
except:
logger.debug("Waiting for %s..." % ips[0])
time.sleep(6)
# timeout -= 1
# SSH TO START THE VXLAN_TOOL ON SF2
try:
ssh.connect(ips[1], username="******",
password="******", timeout=2)
command = ("nohup python vxlan_tool.py -i eth0 "
"-d forward -v off -f -b 22 &")
(stdin, stdout, stderr) = ssh.exec_command(command)
except:
logger.debug("Waiting for %s..." % ips[1])
time.sleep(6)
# timeout -= 1
# SSH TO EXECUTE cmd_client
logger.info("TEST STARTED")
try:
ssh.connect(floatip_client, username="******",
password="******", timeout=2)
command = "nc -w 5 -zv " + floatip_server + " 22 2>&1"
(stdin, stdout, stderr) = ssh.exec_command(command)
except:
logger.debug("Waiting for %s..." % floatip_client)
time.sleep(6)
# timeout -= 1
# WRITE THE CORRECT WAY TO DO LOGGING
i = 0
logger.info("First output: %s" % stdout.readlines())
if "timed out" in stdout.readlines()[0]:
logger.info('\033[92m' + "TEST 1 [PASSED] "
"==> SSH BLOCKED" + '\033[0m')
i = i + 1
else:
logger.debug('\033[91m' + "TEST 1 [FAILED] "
"==> SSH NOT BLOCKED" + '\033[0m')
return
# SSH TO EXECUTE cmd_client
try:
ssh.connect(floatip_client, username="******",
password="******", timeout=2)
command = "nc -w 5 -zv " + floatip_server + " 80 2>&1"
(stdin, stdout, stderr) = ssh.exec_command(command)
except:
logger.debug("Waiting for %s..." % floatip_client)
time.sleep(6)
# timeout -= 1
if "succeeded" in stdout.readlines()[0]:
logger.info('\033[92m' + "TEST 2 [PASSED] "
"==> HTTP WORKS" + '\033[0m')
i = i + 1
else:
logger.debug('\033[91m' + "TEST 2 [FAILED] "
"==> HTTP BLOCKED" + '\033[0m')
return
# CHANGE OF CLASSIFICATION #
logger.info("Changing the classification")
tacker_classi = "/home/opnfv/repos/functest/testcases/features/sfc/" + \
TACKER_CHANGECLASSI
subprocess.call(tacker_classi, shell=True)
# SSH TO EXECUTE cmd_client
try:
ssh.connect(floatip_client, username="******",
password="******", timeout=2)
command = "nc -w 5 -zv " + floatip_server + " 80 2>&1"
(stdin, stdout, stderr) = ssh.exec_command(command)
except:
logger.debug("Waiting for %s..." % floatip_client)
time.sleep(6)
# timeout -= 1
if "timed out" in stdout.readlines()[0]:
logger.info('\033[92m' + "TEST 3 [WORKS] "
"==> HTTP BLOCKED" + '\033[0m')
i = i + 1
else:
logger.debug('\033[91m' + "TEST 3 [FAILED] "
"==> HTTP NOT BLOCKED" + '\033[0m')
return
# SSH TO EXECUTE cmd_client
try:
ssh.connect(floatip_client, username="******",
password="******", timeout=2)
command = "nc -w 5 -zv " + floatip_server + " 22 2>&1"
(stdin, stdout, stderr) = ssh.exec_command(command)
except:
logger.debug("Waiting for %s..." % floatip_client)
time.sleep(6)
# timeout -= 1
if "succeeded" in stdout.readlines()[0]:
logger.info('\033[92m' + "TEST 4 [WORKS] "
"==> SSH WORKS" + '\033[0m')
i = i + 1
else:
logger.debug('\033[91m' + "TEST 4 [FAILED] "
"==> SSH BLOCKED" + '\033[0m')
return
if i == 4:
for x in range(0, 5):
logger.info('\033[92m' + "SFC TEST WORKED"
" :) \n" + '\033[0m')
sys.exit(0)
def main():
nova_client = os_utils.get_nova_client()
neutron_client = os_utils.get_neutron_client()
glance_client = os_utils.get_glance_client()
image_id = os_utils.create_glance_image(glance_client,
IMAGE_NAME,
IMAGE_PATH,
disk=IMAGE_FORMAT,
container="bare",
public=True,
logger=logger)
network_dic = os_utils.create_network_full(logger,
neutron_client,
NET_NAME,
SUBNET_NAME,
ROUTER_NAME,
SUBNET_CIDR)
if not network_dic:
logger.error(
"There has been a problem when creating the neutron network")
sys.exit(-1)
network_id = network_dic["net_id"]
sg_id = os_utils.create_security_group_full(logger, neutron_client,
SECGROUP_NAME, SECGROUP_DESCR)
# boot INTANCE
logger.info("Creating instance '%s'..." % INSTANCE_NAME)
logger.debug(
"Configuration:\n name=%s \n flavor=%s \n image=%s \n "
"network=%s \n" % (INSTANCE_NAME, FLAVOR, image_id, network_id))
instance = os_utils.create_instance_and_wait_for_active(FLAVOR,
image_id,
network_id,
INSTANCE_NAME)
if instance is None:
logger.error("Error while booting instance.")
sys.exit(-1)
# Retrieve IP of INSTANCE
instance_ip = instance.networks.get(NET_NAME)[0]
logger.debug("Instance '%s' got private ip '%s'." %
(INSTANCE_NAME, instance_ip))
logger.info("Adding '%s' to security group '%s'..."
% (INSTANCE_NAME, SECGROUP_NAME))
os_utils.add_secgroup_to_instance(nova_client, instance.id, sg_id)
logger.info("Creating floating IP for VM '%s'..." % INSTANCE_NAME)
floatip_dic = os_utils.create_floating_ip(neutron_client)
floatip = floatip_dic['fip_addr']
# floatip_id = floatip_dic['fip_id']
if floatip is None:
logger.error("Cannot create floating IP.")
sys.exit(-1)
logger.info("Floating IP created: '%s'" % floatip)
logger.info("Associating floating ip: '%s' to VM '%s' "
% (floatip, INSTANCE_NAME))
if not os_utils.add_floating_ip(nova_client, instance.id, floatip):
logger.error("Cannot associate floating IP to VM.")
sys.exit(-1)
sys.exit(0)
def main():
global SUMMARY
global network_dict
start_time = time.time()
stop_time = start_time
# configure script
if not (args.test_name in tests):
logger.error('argument not valid')
exit(-1)
SUMMARY = []
creds_nova = openstack_utils.get_credentials("nova")
nova_client = novaclient.Client('2', **creds_nova)
creds_neutron = openstack_utils.get_credentials("neutron")
neutron_client = neutronclient.Client(**creds_neutron)
creds_keystone = openstack_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)
creds_cinder = openstack_utils.get_credentials("cinder")
cinder_client = cinderclient.Client('2', creds_cinder['username'],
creds_cinder['api_key'],
creds_cinder['project_id'],
creds_cinder['auth_url'],
service_type="volume")
client_dict['neutron'] = neutron_client
volume_types = openstack_utils.list_volume_types(cinder_client,
private=False)
if not volume_types:
volume_type = openstack_utils.create_volume_type(
cinder_client, CINDER_VOLUME_TYPE_NAME)
if not volume_type:
logger.error("Failed to create volume type...")
exit(-1)
else:
logger.debug("Volume type '%s' created succesfully..."
% CINDER_VOLUME_TYPE_NAME)
else:
logger.debug("Using existing volume type(s)...")
image_id = openstack_utils.get_image_id(glance_client, GLANCE_IMAGE_NAME)
image_exists = False
if image_id == '':
logger.debug("Creating image '%s' from '%s'..." % (GLANCE_IMAGE_NAME,
GLANCE_IMAGE_PATH))
image_id = openstack_utils.create_glance_image(glance_client,
GLANCE_IMAGE_NAME,
GLANCE_IMAGE_PATH)
if not image_id:
logger.error("Failed to create the Glance image...")
exit(-1)
else:
logger.debug("Image '%s' with ID '%s' created succesfully ."
% (GLANCE_IMAGE_NAME, image_id))
else:
logger.debug("Using existing image '%s' with ID '%s'..."
% (GLANCE_IMAGE_NAME, image_id))
image_exists = True
logger.debug("Creating network '%s'..." % PRIVATE_NET_NAME)
network_dict = openstack_utils.create_network_full(logger,
client_dict['neutron'],
PRIVATE_NET_NAME,
PRIVATE_SUBNET_NAME,
ROUTER_NAME,
PRIVATE_SUBNET_CIDR)
if not network_dict:
logger.error("Failed to create network...")
exit(-1)
else:
if not openstack_utils.update_neutron_net(client_dict['neutron'],
network_dict['net_id'],
shared=True):
logger.error("Failed to update network...")
exit(-1)
else:
logger.debug("Network '%s' available..." % PRIVATE_NET_NAME)
if args.test_name == "all":
for test_name in tests:
if not (test_name == 'all' or
test_name == 'vm'):
run_task(test_name)
else:
logger.debug("Test name: " + args.test_name)
run_task(args.test_name)
report = ("\n"
" "
"\n"
" Rally Summary Report\n"
"\n"
"+===================+============+===============+===========+"
"\n"
"| Module | Duration | nb. Test Run | Success |"
"\n"
"+===================+============+===============+===========+"
"\n")
payload = []
stop_time = time.time()
# for each scenario we draw a row for the table
total_duration = 0.0
total_nb_tests = 0
total_success = 0.0
for s in SUMMARY:
name = "{0:<17}".format(s['test_name'])
duration = float(s['overall_duration'])
total_duration += duration
duration = time.strftime("%M:%S", time.gmtime(duration))
duration = "{0:<10}".format(duration)
nb_tests = "{0:<13}".format(s['nb_tests'])
total_nb_tests += int(s['nb_tests'])
success = "{0:<10}".format(str(s['success']) + '%')
total_success += float(s['success'])
report += ("" +
"| " + name + " | " + duration + " | " +
nb_tests + " | " + success + "|\n" +
"+-------------------+------------"
"+---------------+-----------+\n")
payload.append({'module': name,
'details': {'duration': s['overall_duration'],
'nb tests': s['nb_tests'],
'success': s['success']}})
total_duration_str = time.strftime("%H:%M:%S", time.gmtime(total_duration))
total_duration_str2 = "{0:<10}".format(total_duration_str)
total_nb_tests_str = "{0:<13}".format(total_nb_tests)
total_success = "{:0.2f}".format(total_success / len(SUMMARY))
total_success_str = "{0:<10}".format(str(total_success) + '%')
report += "+===================+============+===============+===========+"
report += "\n"
report += ("| TOTAL: | " + total_duration_str2 + " | " +
total_nb_tests_str + " | " + total_success_str + "|\n")
report += "+===================+============+===============+===========+"
report += "\n"
logger.info("\n" + report)
payload.append({'summary': {'duration': total_duration,
'nb tests': total_nb_tests,
'nb success': total_success}})
# Generate json results for DB
# json_results = {"timestart": time_start, "duration": total_duration,
# "tests": int(total_nb_tests),
# "success": int(total_success)}
# logger.info("Results: "+str(json_results))
# Evaluation of the success criteria
status = "failed"
# for Rally we decided that the overall success rate must be above 90%
if total_success >= 90:
status = "passed"
if args.sanity:
case_name = "rally_sanity"
else:
case_name = "rally_full"
if args.report:
logger.debug("Pushing Rally summary into DB...")
functest_utils.push_results_to_db("functest",
case_name,
None,
start_time,
stop_time,
status,
payload)
if args.noclean:
exit(0)
if not image_exists:
logger.debug("Deleting image '%s' with ID '%s'..."
% (GLANCE_IMAGE_NAME, image_id))
if not openstack_utils.delete_glance_image(nova_client, image_id):
logger.error("Error deleting the glance image")
if not volume_types:
logger.debug("Deleting volume type '%s'..."
% CINDER_VOLUME_TYPE_NAME)
if not openstack_utils.delete_volume_type(cinder_client, volume_type):
logger.error("Error in deleting volume type...")
def main():
nova_client = os_utils.get_nova_client()
neutron_client = os_utils.get_neutron_client()
glance_client = os_utils.get_glance_client()
image_id = os_utils.create_glance_image(glance_client,
EXAMPLE_IMAGE_NAME,
IMAGE_PATH,
disk=IMAGE_FORMAT,
container="bare",
public=True)
network_dic = os_utils.create_network_full(
neutron_client,
EXAMPLE_PRIVATE_NET_NAME,
EXAMPLE_PRIVATE_SUBNET_NAME,
EXAMPLE_ROUTER_NAME,
EXAMPLE_PRIVATE_SUBNET_CIDR)
if not network_dic:
logger.error(
"There has been a problem when creating the neutron network")
sys.exit(-1)
network_id = network_dic["net_id"]
sg_id = os_utils.create_security_group_full(neutron_client,
EXAMPLE_SECGROUP_NAME,
EXAMPLE_SECGROUP_DESCR)
# boot INTANCE
logger.info("Creating instance '%s'..." % EXAMPLE_INSTANCE_NAME)
logger.debug(
"Configuration:\n name=%s \n flavor=%s \n image=%s \n "
"network=%s \n"
% (EXAMPLE_INSTANCE_NAME, EXAMPLE_FLAVOR, image_id, network_id))
instance = os_utils.create_instance_and_wait_for_active(
EXAMPLE_FLAVOR,
image_id,
network_id,
EXAMPLE_INSTANCE_NAME)
if instance is None:
logger.error("Error while booting instance.")
sys.exit(-1)
# Retrieve IP of INSTANCE
instance_ip = instance.networks.get(EXAMPLE_PRIVATE_NET_NAME)[0]
logger.debug("Instance '%s' got private ip '%s'." %
(EXAMPLE_INSTANCE_NAME, instance_ip))
logger.info("Adding '%s' to security group '%s'..."
% (EXAMPLE_INSTANCE_NAME, EXAMPLE_SECGROUP_NAME))
os_utils.add_secgroup_to_instance(nova_client, instance.id, sg_id)
logger.info("Creating floating IP for VM '%s'..." % EXAMPLE_INSTANCE_NAME)
floatip_dic = os_utils.create_floating_ip(neutron_client)
floatip = floatip_dic['fip_addr']
# floatip_id = floatip_dic['fip_id']
if floatip is None:
logger.error("Cannot create floating IP.")
sys.exit(-1)
logger.info("Floating IP created: '%s'" % floatip)
logger.info("Associating floating ip: '%s' to VM '%s' "
% (floatip, EXAMPLE_INSTANCE_NAME))
if not os_utils.add_floating_ip(nova_client, instance.id, floatip):
logger.error("Cannot associate floating IP to VM.")
sys.exit(-1)
sys.exit(0)
