def OnosTest():
start_time = time.time()
stop_time = start_time
if INSTALLER_TYPE == "joid":
logger.debug("Installer is Joid")
SetOnosIpForJoid()
else:
SetOnosIp()
RunScript("FUNCvirNetNB")
RunScript("FUNCvirNetNBL3")
try:
logger.debug("Push ONOS results into DB")
# TODO check path result for the file
result = GetResult()
stop_time = time.time()
# ONOS success criteria = all tests OK
# i.e. FUNCvirNet & FUNCvirNetL3
status = "FAIL"
try:
if (result['FUNCvirNet']['result'] == "Success"
and result['FUNCvirNetL3']['result'] == "Success"):
status = "PASS"
except:
logger.error("Unable to set ONOS criteria")
ft_utils.push_results_to_db("functest", "onos", start_time, stop_time,
status, result)
except:
logger.error("Error pushing results into Database")
if status == "FAIL":
EXIT_CODE = -1
exit(EXIT_CODE)
def main():
start_time = time.time()
stop_time = start_time
# DownloadCodes()
if args.installer == "joid":
logger.debug("Installer is Joid")
SetOnosIpForJoid()
else:
SetOnosIp()
RunScript("FUNCvirNetNB")
RunScript("FUNCvirNetNBL3")
try:
logger.debug("Push ONOS results into DB")
# TODO check path result for the file
result = GetResult()
stop_time = time.time()
# ONOS success criteria = all tests OK
# i.e. FUNCvirNet & FUNCvirNetL3
status = "failed"
try:
if (result['FUNCvirNet']['result'] == "Success"
and result['FUNCvirNetL3']['result'] == "Success"):
status = "passed"
except:
logger.error("Unable to set ONOS criteria")
functest_utils.push_results_to_db("functest", "onos", logger,
start_time, stop_time, status,
result)
except:
logger.error("Error pushing results into Database")
def push_results(testname, start_time, end_time, criteria, details):
logger.info("Push testcase '%s' results into the DB...\n" % testname)
ft_utils.push_results_to_db("sdnvpn",
testname,
start_time,
end_time,
criteria,
details)
def step_failure(step_name, error_msg):
logger.error(error_msg)
set_result(step_name, 0, error_msg)
status = "FAIL"
# in case of failure starting and stoping time are not correct
stop_time = time.time()
if step_name == "sig_test":
status = "PASS"
ft_utils.push_results_to_db("functest", "vims", TESTCASE_START_TIME,
stop_time, status, RESULTS)
exit(-1)
def _test_push_results_to_db_missing_env(self, env_var):
dic = self._get_env_dict(env_var)
CONST.__setattr__('results_test_db_url', self.db_url)
with mock.patch.dict(os.environ,
dic,
clear=True), \
mock.patch('functest.utils.functest_utils.logger.error') \
as mock_logger_error:
functest_utils.push_results_to_db(self.project, self.case_name,
self.start_date, self.stop_date,
self.result, self.details)
mock_logger_error.assert_called_once_with("Please set env var: " +
str("\'" + env_var +
"\'"))
def step_failure(step_name, error_msg):
logger.error(error_msg)
set_result(step_name, 0, error_msg)
status = "FAIL"
# in case of failure starting and stoping time are not correct
stop_time = time.time()
if step_name == "sig_test":
status = "PASS"
functest_utils.push_results_to_db("functest",
"vHello",
None,
TESTCASE_START_TIME,
stop_time,
status,
RESULTS)
exit(-1)
def push_to_db(self):
"""Push the results of TestCase to the DB.
It allows publishing the results and to check the status.
It could be overriden if the common implementation is not
suitable. The following attributes must be set before pushing
the results to DB:
* project_name,
* case_name,
* criteria,
* start_time,
* stop_time.
Returns:
TestCase.EX_OK if results were pushed to DB.
TestCase.EX_PUSH_TO_DB_ERROR otherwise.
"""
try:
assert self.project_name
assert self.case_name
assert self.criteria
assert self.start_time
assert self.stop_time
if ft_utils.push_results_to_db(self.project_name, self.case_name,
self.start_time, self.stop_time,
self.criteria, self.details):
self.logger.info("The results were successfully pushed to DB")
return TestCase.EX_OK
else:
self.logger.error("The results cannot be pushed to DB")
return TestCase.EX_PUSH_TO_DB_ERROR
except Exception: # pylint: disable=broad-except
self.logger.exception("The results cannot be pushed to DB")
return TestCase.EX_PUSH_TO_DB_ERROR
def main():
cmd = 'cd %s/tests && ./run.sh' % DOCTOR_REPO
start_time = time.time()
ret = functest_utils.execute_command(cmd, logger, exit_on_error=False)
stop_time = time.time()
duration = round(stop_time - start_time, 1)
if ret == 0:
logger.info("doctor OK")
test_status = 'OK'
else:
logger.info("doctor FAILED")
test_status = 'NOK'
details = {
'timestart': start_time,
'duration': duration,
'status': test_status,
}
pod_name = functest_utils.get_pod_name(logger)
scenario = functest_utils.get_scenario(logger)
version = functest_utils.get_version(logger)
build_tag = functest_utils.get_build_tag(logger)
status = "FAIL"
if details['status'] == "OK":
status = "PASS"
logger.info("Pushing Doctor results: TEST_DB_URL=%(db)s pod_name=%(pod)s "
"version=%(v)s scenario=%(s)s criteria=%(c)s details=%(d)s" % {
'db': TEST_DB_URL,
'pod': pod_name,
'v': version,
's': scenario,
'c': status,
'b': build_tag,
'd': details,
})
functest_utils.push_results_to_db("doctor",
"doctor-notification",
logger,
start_time,
stop_time,
status,
details)
def test_wrong_shema(self):
CONST.__setattr__('results_test_db_url', '/dev/null')
self.assertFalse(
functest_utils.push_results_to_db(self._project_name,
self._case_name,
self._start_time,
self._stop_time, self._result,
{}))
def main():
cmd = 'cd %s/tests && ./run.sh' % DOCTOR_REPO
start_time = time.time()
ret = functest_utils.execute_command(cmd, logger, exit_on_error=False)
stop_time = time.time()
duration = round(stop_time - start_time, 1)
if ret:
logger.info("doctor OK")
test_status = 'OK'
else:
logger.info("doctor FAILED")
test_status = 'NOK'
details = {
'timestart': start_time,
'duration': duration,
'status': test_status,
}
pod_name = functest_utils.get_pod_name(logger)
scenario = functest_utils.get_scenario(logger)
version = functest_utils.get_version(logger)
build_tag = functest_utils.get_build_tag(logger)
status = "failed"
if details['status'] == "OK":
status = "passed"
logger.info("Pushing Doctor results: TEST_DB_URL=%(db)s pod_name=%(pod)s "
"version=%(v)s scenario=%(s)s criteria=%(c)s details=%(d)s" % {
'db': TEST_DB_URL,
'pod': pod_name,
'v': version,
's': scenario,
'c': status,
'b': build_tag,
'd': details,
})
functest_utils.push_results_to_db("doctor",
"doctor-notification",
logger,
start_time,
stop_time,
status,
details)
def test_makedirs_exc(self, *args):
CONST.__setattr__('results_test_db_url', URL)
self.assertFalse(
functest_utils.push_results_to_db(self._project_name,
self._case_name,
self._start_time,
self._stop_time, self._result,
{}))
args[0].assert_called_once_with(DIR)
def PushDB(status, info):
logger.info("Summary :")
try:
logger.debug("Push ONOS SFC results into DB")
stop_time = time.time()
# ONOS SFC success criteria = all tests OK
duration = round(stop_time - start_time, 1)
logger.info("Result is " + status)
ft_utils.push_results_to_db("functest",
"onos_sfc",
start_time,
stop_time,
status,
details={'duration': duration,
'error': info})
except:
logger.error("Error pushing results into Database")
def main():
start_time = time.time()
result_os = test_moon_openstack()
result_odl = test_federation()
stop_time = time.time()
duration = round(stop_time - start_time, 1)
if result_os[0] == 0 and result_odl[0]:
logger.info("OS MOON PASSED")
test_status = 'PASS'
else:
logger.info("OS MOON ERROR")
test_status = 'FAIL'
logger.info("Errors from OpenStack tests:")
logger.info(result_os[1])
logger.info("Errors from Federation tests:")
logger.info(result_odl[1])
details = {
'timestart': start_time,
'duration': duration,
'status': test_status,
'results': {
'openstack': result_os,
'opendaylight': result_odl
}
}
functest_utils.logger_test_results("moon",
"moon_authentication",
test_status, details)
if args.report:
functest_utils.push_results_to_db("moon",
"moon_authentication",
start_time,
stop_time,
test_status,
details)
logger.info("Moon results pushed to DB")
if result_os[0] != 0 or not result_odl[0]:
return False
return True
def main():
cmd = "%s/tests/run.sh %s/tests" % (COPPER_REPO_DIR, COPPER_REPO_DIR)
start_time = time.time()
log_file = RESULTS_DIR + "/copper.log"
ret_val = functest_utils.execute_command(cmd,
output_file=log_file)
stop_time = time.time()
duration = round(stop_time - start_time, 1)
if ret_val == 0:
logger.info("COPPER PASSED")
test_status = 'PASS'
else:
logger.info("COPPER FAILED")
test_status = 'FAIL'
details = {
'timestart': start_time,
'duration': duration,
'status': test_status,
}
functest_utils.logger_test_results("Copper",
"copper-notification",
details['status'], details)
try:
if args.report:
functest_utils.push_results_to_db("copper",
"copper-notification",
start_time,
stop_time,
details['status'],
details)
logger.info("COPPER results pushed to DB")
except:
logger.error("Error pushing results into Database '%s'"
% sys.exc_info()[0])
if ret_val != 0:
sys.exit(-1)
sys.exit(0)
def main():
cmd = ('%s/tests/run.sh' % COPPER_REPO)
start_time = time.time()
ret = functest_utils.execute_command(cmd, logger, exit_on_error=False)
stop_time = time.time()
duration = round(stop_time - start_time, 1)
if ret == 0:
logger.info("COPPER PASSED")
test_status = 'PASS'
else:
logger.info("COPPER FAILED")
test_status = 'FAIL'
details = {
'timestart': start_time,
'duration': duration,
'status': test_status,
}
pod_name = functest_utils.get_pod_name(logger)
scenario = functest_utils.get_scenario(logger)
version = functest_utils.get_version(logger)
build_tag = functest_utils.get_build_tag(logger)
logger.info("Pushing COPPER results: TEST_DB_URL=%(db)s pod_name=%(pod)s "
"version=%(v)s scenario=%(s)s criteria=%(c)s details=%(d)s" % {
'db': TEST_DB_URL,
'pod': pod_name,
'v': version,
's': scenario,
'c': details['status'],
'b': build_tag,
'd': details,
})
functest_utils.push_results_to_db("COPPER",
"COPPER-notification",
logger,
start_time,
stop_time,
details['status'],
details)
def main():
exit_code = -1
# if the image name is explicitly set for the doctor suite, set it as
# enviroment variable
if 'doctor' in functest_yaml and 'image_name' in functest_yaml['doctor']:
os.environ["IMAGE_NAME"] = functest_yaml['doctor']['image_name']
cmd = 'cd %s/tests && ./run.sh' % DOCTOR_REPO_DIR
log_file = RESULTS_DIR + "/doctor.log"
start_time = time.time()
ret = functest_utils.execute_command(cmd, info=True, output_file=log_file)
stop_time = time.time()
duration = round(stop_time - start_time, 1)
if ret == 0:
logger.info("Doctor test case OK")
test_status = 'OK'
exit_code = 0
else:
logger.info("Doctor test case FAILED")
test_status = 'NOK'
details = {
'timestart': start_time,
'duration': duration,
'status': test_status,
}
status = "FAIL"
if details['status'] == "OK":
status = "PASS"
functest_utils.logger_test_results("Doctor", "doctor-notification", status,
details)
if args.report:
functest_utils.push_results_to_db("doctor", "doctor-notification",
start_time, stop_time, status,
details)
logger.info("Doctor results pushed to DB")
exit(exit_code)
def main():
start_time = time.time()
stop_time = start_time
# DownloadCodes()
# if args.installer == "joid":
if INSTALLER_TYPE == "joid":
logger.debug("Installer is Joid")
SetOnosIpForJoid()
else:
SetOnosIp()
RunScript("FUNCvirNetNB")
RunScript("FUNCvirNetNBL3")
if DEPLOY_SCENARIO == "os-onos-sfc-ha":
CreateImage()
SetSfcConf()
SfcTest()
try:
logger.debug("Push ONOS results into DB")
# TODO check path result for the file
result = GetResult()
stop_time = time.time()
# ONOS success criteria = all tests OK
# i.e. FUNCvirNet & FUNCvirNetL3
status = "FAIL"
try:
if (result['FUNCvirNet']['result'] == "Success" and
result['FUNCvirNetL3']['result'] == "Success"):
status = "PASS"
except:
logger.error("Unable to set ONOS criteria")
functest_utils.push_results_to_db("functest",
"onos",
logger,
start_time,
stop_time,
status,
result)
except:
logger.error("Error pushing results into Database")
def test_push_results_to_db_default(self):
dic = self._get_env_dict(None)
CONST.__setattr__('results_test_db_url', self.db_url)
with mock.patch.dict(os.environ,
dic,
clear=True), \
mock.patch('functest.utils.functest_utils.requests.post'):
self.assertTrue(
functest_utils.push_results_to_db(self.project, self.case_name,
self.start_date,
self.stop_date, self.result,
self.details))
def test_push_results_to_db_default(self):
dic = self._get_env_dict(None)
with mock.patch('functest.utils.functest_utils.get_db_url',
return_value=self.db_url), \
mock.patch.dict(os.environ,
dic,
clear=True), \
mock.patch('functest.utils.functest_utils.requests.post'):
self.assertTrue(
functest_utils.push_results_to_db(self.project, self.case_name,
self.start_date,
self.stop_date,
self.criteria, self.details))
def test_http_shema(self, *args):
CONST.__setattr__('results_test_db_url', 'http://127.0.0.1')
self.assertTrue(
functest_utils.push_results_to_db(self._project_name,
self._case_name,
self._start_time,
self._stop_time, self._result,
{}))
args[1].assert_called_once_with()
args[0].assert_called_once_with(
'http://127.0.0.1',
data=self._get_json(),
headers={'Content-Type': 'application/json'})
def main():
start_time = time.time()
stop_time = start_time
# DownloadCodes()
if args.installer == "joid":
logger.debug("Installer is Joid")
SetOnosIpForJoid()
else:
SetOnosIp()
RunScript("FUNCvirNetNB")
RunScript("FUNCvirNetNBL3")
try:
logger.debug("Push ONOS results into DB")
# TODO check path result for the file
result = GetResult()
stop_time = time.time()
# ONOS success criteria = all tests OK
# i.e. FUNCvirNet & FUNCvirNetL3
status = "failed"
try:
if (result['FUNCvirNet']['result'] == "Success" and
result['FUNCvirNetL3']['result'] == "Success"):
status = "passed"
except:
logger.error("Unable to set ONOS criteria")
functest_utils.push_results_to_db("functest",
"onos",
logger,
start_time,
stop_time,
status,
result)
except:
logger.error("Error pushing results into Database")
def test_push_results_to_db_request_post_exception(self):
dic = self._get_env_dict(None)
CONST.__setattr__('results_test_db_url', self.db_url)
with mock.patch.dict(os.environ,
dic,
clear=True), \
mock.patch('functest.utils.functest_utils.logger.error') \
as mock_logger_error, \
mock.patch('functest.utils.functest_utils.requests.post',
side_effect=Exception):
self.assertFalse(
functest_utils.push_results_to_db(self.project, self.case_name,
self.start_date,
self.stop_date, self.result,
self.details))
self.assertTrue(mock_logger_error.called)
def push_to_db(self):
try:
assert self.project_name
assert self.case_name
assert self.criteria
assert self.start_time
assert self.stop_time
if ft_utils.push_results_to_db(self.project_name, self.case_name,
self.start_time, self.stop_time,
self.criteria, self.details):
self.logger.info("The results were successfully pushed to DB")
return TestcaseBase.EX_OK
else:
self.logger.error("The results cannot be pushed to DB")
return TestcaseBase.EX_PUSH_TO_DB_ERROR
except Exception:
self.logger.exception("The results cannot be pushed to DB")
return TestcaseBase.EX_PUSH_TO_DB_ERROR
def test_push_results_to_db_incorrect_buildtag(self):
dic = self._get_env_dict(None)
dic['BUILD_TAG'] = 'incorrect_build_tag'
with mock.patch('functest.utils.functest_utils.get_db_url',
return_value=self.db_url), \
mock.patch.dict(os.environ,
dic,
clear=True), \
mock.patch('functest.utils.functest_utils.logger.error') \
as mock_logger_error:
self.assertFalse(
functest_utils.push_results_to_db(self.project, self.case_name,
self.start_date,
self.stop_date,
self.criteria, self.details))
mock_logger_error.assert_called_once_with("Please fix BUILD_TAG"
" env var: incorrect_"
"build_tag")
def _test_dump(self, *args):
CONST.__setattr__('results_test_db_url', URL)
with mock.patch.object(decorators,
'open',
mock.mock_open(),
create=True) as mock_open:
self.assertTrue(
functest_utils.push_results_to_db(self._project_name,
self._case_name,
self._start_time,
self._stop_time,
self._result, {}))
mock_open.assert_called_once_with(FILE, 'a')
handle = mock_open()
call_args, _ = handle.write.call_args
self.assertIn('POST', call_args[0])
self.assertIn(self._get_json(), call_args[0])
args[0].assert_called_once_with()
def test_push_results_to_db_request_post_failed(self):
dic = self._get_env_dict(None)
CONST.__setattr__('results_test_db_url', self.db_url)
with mock.patch.dict(os.environ,
dic,
clear=True), \
mock.patch('functest.utils.functest_utils.logger.error') \
as mock_logger_error, \
mock.patch('functest.utils.functest_utils.requests.post',
side_effect=requests.RequestException):
self.assertFalse(
functest_utils.push_results_to_db(self.project, self.case_name,
self.start_date,
self.stop_date, self.result,
self.details))
mock_logger_error.assert_called_once_with(
test_utils.RegexMatch("Pushing "
"Result to"
" DB"
"(\S+\s*) "
"failed:"))
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 run_task(test_name):
#
# the "main" function of the script who launch rally for a task
# :param test_name: name for the rally test
# :return: void
#
global SUMMARY
logger.info('Starting test scenario "{}" ...'.format(test_name))
start_time = time.time()
stop_time = start_time
task_file = '{}task.yaml'.format(RALLY_DIR)
if not os.path.exists(task_file):
logger.error("Task file '%s' does not exist." % task_file)
exit(-1)
test_file_name = '{}opnfv-{}.yaml'.format(RALLY_DIR + "scenario/",
test_name)
if not os.path.exists(test_file_name):
logger.error("The scenario '%s' does not exist." % test_file_name)
exit(-1)
logger.debug('Scenario fetched from : {}'.format(test_file_name))
cmd_line = ("rally task start --abort-on-sla-failure " +
"--task {} ".format(task_file) +
"--task-args \"{}\" ".format(build_task_args(test_name)))
logger.debug('running command line : {}'.format(cmd_line))
p = subprocess.Popen(cmd_line, stdout=subprocess.PIPE,
stderr=RALLY_STDERR, shell=True)
output = get_output(p, test_name)
task_id = get_task_id(output)
logger.debug('task_id : {}'.format(task_id))
if task_id is None:
logger.error('Failed to retrieve task_id, validating task...')
cmd_line = ("rally task validate " +
"--task {} ".format(task_file) +
"--task-args \"{}\" ".format(build_task_args(test_name)))
logger.debug('running command line : {}'.format(cmd_line))
p = subprocess.Popen(cmd_line, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT, shell=True)
output = get_cmd_output(p)
logger.error("Task validation result:" + "\n" + output)
return
# check for result directory and create it otherwise
if not os.path.exists(RESULTS_DIR):
logger.debug('%s does not exist, we create it.'.format(RESULTS_DIR))
os.makedirs(RESULTS_DIR)
# write html report file
report_file_name = '{}opnfv-{}.html'.format(RESULTS_DIR, test_name)
cmd_line = "rally task report {} --out {}".format(task_id,
report_file_name)
logger.debug('running command line : {}'.format(cmd_line))
os.popen(cmd_line)
# get and save rally operation JSON result
cmd_line = "rally task results %s" % task_id
logger.debug('running command line : {}'.format(cmd_line))
cmd = os.popen(cmd_line)
json_results = cmd.read()
with open('{}opnfv-{}.json'.format(RESULTS_DIR, test_name), 'w') as f:
logger.debug('saving json file')
f.write(json_results)
with open('{}opnfv-{}.json'
.format(RESULTS_DIR, test_name)) as json_file:
json_data = json.load(json_file)
""" parse JSON operation result """
status = "failed"
if task_succeed(json_results):
logger.info('Test scenario: "{}" OK.'.format(test_name) + "\n")
status = "passed"
else:
logger.info('Test scenario: "{}" Failed.'.format(test_name) + "\n")
# Push results in payload of testcase
if args.report:
stop_time = time.time()
logger.debug("Push Rally detailed results into DB")
functest_utils.push_results_to_db("functest",
"Rally_details",
logger,
start_time,
stop_time,
status,
json_data)
def run_tempest(OPTION):
#
# the "main" function of the script which launches Rally to run Tempest
# :param option: tempest option (smoke, ..)
# :return: void
#
logger.info("Starting Tempest test suite: '%s'." % OPTION)
start_time = time.time()
stop_time = start_time
cmd_line = "rally verify start " + OPTION + " --system-wide"
header = ("Tempest environment:\n"
" Installer: %s\n Scenario: %s\n Node: %s\n Date: %s\n" %
(ft_constants.CI_INSTALLER_TYPE, ft_constants.CI_SCENARIO,
ft_constants.CI_NODE, time.strftime("%a %b %d %H:%M:%S %Z %Y")))
f_stdout = open(TEMPEST_RESULTS_DIR + "/tempest.log", 'w+')
f_stderr = open(TEMPEST_RESULTS_DIR + "/tempest-error.log", 'w+')
f_env = open(TEMPEST_RESULTS_DIR + "/environment.log", 'w+')
f_env.write(header)
# subprocess.call(cmd_line, shell=True, stdout=f_stdout, stderr=f_stderr)
p = subprocess.Popen(cmd_line,
shell=True,
stdout=subprocess.PIPE,
stderr=f_stderr,
bufsize=1)
with p.stdout:
for line in iter(p.stdout.readline, b''):
if re.search("\} tempest\.", line):
logger.info(line.replace('\n', ''))
f_stdout.write(line)
p.wait()
f_stdout.close()
f_stderr.close()
f_env.close()
cmd_line = "rally verify show"
output = ""
p = subprocess.Popen(cmd_line,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
for line in p.stdout:
if re.search("Tests\:", line):
break
output += line
logger.info(output)
cmd_line = "rally verify list"
cmd = os.popen(cmd_line)
output = (((cmd.read()).splitlines()[-2]).replace(" ", "")).split("|")
# Format:
# | UUID | Deployment UUID | smoke | tests | failures | Created at |
# Duration | Status |
num_tests = output[4]
num_failures = output[5]
time_start = output[6]
duration = output[7]
# Compute duration (lets assume it does not take more than 60 min)
dur_min = int(duration.split(':')[1])
dur_sec_float = float(duration.split(':')[2])
dur_sec_int = int(round(dur_sec_float, 0))
dur_sec_int = dur_sec_int + 60 * dur_min
stop_time = time.time()
try:
diff = (int(num_tests) - int(num_failures))
success_rate = 100 * diff / int(num_tests)
except:
success_rate = 0
if 'smoke' in args.mode:
case_name = 'tempest_smoke_serial'
elif 'feature' in args.mode:
case_name = args.mode.replace("feature_", "")
else:
case_name = 'tempest_full_parallel'
status = ft_utils.check_success_rate(case_name, success_rate)
logger.info("Tempest %s success_rate is %s%%, is marked as %s" %
(case_name, success_rate, status))
# Push results in payload of testcase
if args.report:
# add the test in error in the details sections
# should be possible to do it during the test
logger.debug("Pushing tempest results into DB...")
with open(TEMPEST_RESULTS_DIR + "/tempest.log", 'r') as myfile:
output = myfile.read()
error_logs = ""
for match in re.findall('(.*?)[. ]*FAILED', output):
error_logs += match
# Generate json results for DB
json_results = {
"timestart": time_start,
"duration": dur_sec_int,
"tests": int(num_tests),
"failures": int(num_failures),
"errors": error_logs
}
logger.info("Results: " + str(json_results))
# split Tempest smoke and full
try:
ft_utils.push_results_to_db("functest", case_name, start_time,
stop_time, status, json_results)
except:
logger.error("Error pushing results into Database '%s'" %
sys.exc_info()[0])
if status == "PASS":
return 0
else:
return -1
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():
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 run_task(test_name):
#
# the "main" function of the script who launch rally for a task
# :param test_name: name for the rally test
# :return: void
#
global SUMMARY
logger.info('Starting test scenario "{}" ...'.format(test_name))
start_time = time.time()
stop_time = start_time
task_file = '{}task.yaml'.format(RALLY_DIR)
if not os.path.exists(task_file):
logger.error("Task file '%s' does not exist." % task_file)
exit(-1)
test_file_name = '{}opnfv-{}.yaml'.format(RALLY_DIR + "scenario/",
test_name)
if not os.path.exists(test_file_name):
logger.error("The scenario '%s' does not exist." % test_file_name)
exit(-1)
logger.debug('Scenario fetched from : {}'.format(test_file_name))
cmd_line = ("rally task start --abort-on-sla-failure " +
"--task {} ".format(task_file) +
"--task-args \"{}\" ".format(build_task_args(test_name)))
logger.debug('running command line : {}'.format(cmd_line))
p = subprocess.Popen(cmd_line,
stdout=subprocess.PIPE,
stderr=RALLY_STDERR,
shell=True)
output = get_output(p, test_name)
task_id = get_task_id(output)
logger.debug('task_id : {}'.format(task_id))
if task_id is None:
logger.error('Failed to retrieve task_id, validating task...')
cmd_line = ("rally task validate " + "--task {} ".format(task_file) +
"--task-args \"{}\" ".format(build_task_args(test_name)))
logger.debug('running command line : {}'.format(cmd_line))
p = subprocess.Popen(cmd_line,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
shell=True)
output = get_cmd_output(p)
logger.error("Task validation result:" + "\n" + output)
return
# check for result directory and create it otherwise
if not os.path.exists(RESULTS_DIR):
logger.debug('%s does not exist, we create it.'.format(RESULTS_DIR))
os.makedirs(RESULTS_DIR)
# write html report file
report_file_name = '{}opnfv-{}.html'.format(RESULTS_DIR, test_name)
cmd_line = "rally task report {} --out {}".format(task_id,
report_file_name)
logger.debug('running command line : {}'.format(cmd_line))
os.popen(cmd_line)
# get and save rally operation JSON result
cmd_line = "rally task results %s" % task_id
logger.debug('running command line : {}'.format(cmd_line))
cmd = os.popen(cmd_line)
json_results = cmd.read()
with open('{}opnfv-{}.json'.format(RESULTS_DIR, test_name), 'w') as f:
logger.debug('saving json file')
f.write(json_results)
with open('{}opnfv-{}.json'.format(RESULTS_DIR, test_name)) as json_file:
json_data = json.load(json_file)
""" parse JSON operation result """
status = "failed"
if task_succeed(json_results):
logger.info('Test scenario: "{}" OK.'.format(test_name) + "\n")
status = "passed"
else:
logger.info('Test scenario: "{}" Failed.'.format(test_name) + "\n")
# Push results in payload of testcase
if args.report:
stop_time = time.time()
logger.debug("Push Rally detailed results into DB")
functest_utils.push_results_to_db("functest", "Rally_details", logger,
start_time, stop_time, status,
json_data)
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():
installer_type = os.environ.get("INSTALLER_TYPE")
if installer_type != "fuel":
logger.error(
'\033[91mCurrently supported only Fuel Installer type\033[0m')
sys.exit(1)
installer_ip = os.environ.get("INSTALLER_IP")
if not installer_ip:
logger.error(
'\033[91minstaller ip is not set\033[0m')
logger.error(
'\033[91mexport INSTALLER_IP=<ip>\033[0m')
sys.exit(1)
start_time = time.time()
status = "PASS"
configure_iptables()
download_image()
_, custom_flv_id = os_utils.get_or_create_flavor(
FLAVOR, 1500, 10, 1, public=True)
if not custom_flv_id:
logger.error("Failed to create custom flavor")
sys.exit(1)
glance_client = os_utils.get_glance_client()
neutron_client = os_utils.get_neutron_client()
nova_client = os_utils.get_nova_client()
controller_clients = get_ssh_clients("controller")
compute_clients = get_ssh_clients("compute")
ovs_logger = ovs_utils.OVSLogger(
os.path.join(os.getcwd(), 'ovs-logs'),
FUNCTEST_RESULTS_DIR)
image_id = setup_glance(glance_client)
network_id = setup_neutron(neutron_client)
sg_id = setup_security_groups(neutron_client)
boot_instance(
nova_client, CLIENT, "custom-3", "97a399a4-a736-449d-9d20-0cc92cf2cbe4", network_id, sg_id)
srv_prv_ip = boot_instance(
nova_client, SERVER, FLAVOR, image_id, network_id, sg_id)
subprocess.call(TACKER_SCRIPT, shell=True)
# Start measuring the time it takes to implement the classification rules
# try:
# thread.start_new_thread(capture_time_log,
# (ovs_logger, compute_clients,))
# except Exception, e:
# logger.error("Unable to start the thread that counts time %s" % e)
server_ip, client_ip, sf1, sf2 = get_floating_ips(
nova_client, neutron_client)
if not check_ssh([sf1, sf2]):
logger.error("Cannot establish SSH connection to the SFs")
sys.exit(1)
logger.info("Starting HTTP server on %s" % server_ip)
if not start_http_server(server_ip):
logger.error(
'\033[91mFailed to start HTTP server on %s\033[0m' % server_ip)
sys.exit(1)
logger.info("Starting HTTP firewall on %s" % sf2)
vxlan_firewall(sf2, port="80")
logger.info("Starting SSH firewall on %s" % sf1)
vxlan_firewall(sf1, port="22")
logger.info("Wait for ODL to update the classification rules in OVS")
time.sleep(120)
logger.info("Test SSH")
if is_ssh_blocked(srv_prv_ip, client_ip):
logger.info('\033[92mTEST 1 [PASSED] ==> SSH BLOCKED\033[0m')
update_json_results("Test 1: SSH Blocked", "Passed")
else:
error = ('\033[91mTEST 1 [FAILED] ==> SSH NOT BLOCKED\033[0m')
logger.error(error)
capture_err_logs(
ovs_logger, controller_clients, compute_clients, error)
update_json_results("Test 1: SSH Blocked", "Failed")
logger.info("Test HTTP")
if not is_http_blocked(srv_prv_ip, client_ip):
logger.info('\033[92mTEST 2 [PASSED] ==> HTTP WORKS\033[0m')
update_json_results("Test 2: HTTP works", "Passed")
else:
error = ('\033[91mTEST 2 [FAILED] ==> HTTP BLOCKED\033[0m')
logger.error(error)
capture_err_logs(
ovs_logger, controller_clients, compute_clients, error)
update_json_results("Test 2: HTTP works", "Failed")
sys.exit(-1)
logger.info("Changing the classification")
subprocess.call(TACKER_CHANGECLASSI, shell=True)
# Start measuring the time it takes to implement the classification rules
# try:
# thread.start_new_thread(capture_time_log,
# (ovs_logger, compute_clients,))
# except Exception, e:
# logger.error("Unable to start the thread that counts time %s" % e)
logger.info("Wait for ODL to update the classification rules in OVS")
time.sleep(100)
logger.info("Test HTTP")
if is_http_blocked(srv_prv_ip, client_ip):
logger.info('\033[92mTEST 3 [PASSED] ==> HTTP Blocked\033[0m')
update_json_results("Test 3: HTTP Blocked", "Passed")
else:
error = ('\033[91mTEST 3 [FAILED] ==> HTTP WORKS\033[0m')
logger.error(error)
capture_err_logs(controller_clients, compute_clients, error)
update_json_results("Test 3: HTTP Blocked", "Failed")
logger.info("Test SSH")
if not is_ssh_blocked(srv_prv_ip, client_ip):
logger.info('\033[92mTEST 4 [PASSED] ==> SSH Works\033[0m')
update_json_results("Test 4: SSH Works", "Passed")
else:
error = ('\033[91mTEST 4 [FAILED] ==> SSH BLOCKED\033[0m')
logger.error(error)
capture_err_logs(controller_clients, compute_clients, error)
update_json_results("Test 4: SSH Works", "Failed")
if json_results["failures"]:
status = "FAIL"
logger.error('\033[91mSFC TESTS: %s :( FOUND %s FAIL \033[0m' % (
status, json_results["failures"]))
ovs_logger.create_artifact_archive()
if args.report:
stop_time = time.time()
logger.debug("Promise Results json: " + str(json_results))
ft_utils.push_results_to_db("sfc",
"functest-odl-sfc",
start_time,
stop_time,
status,
json_results)
if status == "PASS":
logger.info('\033[92mSFC ALL TESTS: %s :)\033[0m' % status)
sys.exit(0)
sys.exit(1)
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 run_tempest(OPTION):
#
# the "main" function of the script which launches Rally to run Tempest
# :param option: tempest option (smoke, ..)
# :return: void
#
logger.info("Starting Tempest test suite: '%s'." % OPTION)
start_time = time.time()
stop_time = start_time
cmd_line = "rally verify start " + OPTION + " --system-wide"
header = ("Tempest environment:\n"
" Installer: %s\n Scenario: %s\n Node: %s\n Date: %s\n" %
(os.getenv('INSTALLER_TYPE', 'Unknown'),
os.getenv('DEPLOY_SCENARIO', 'Unknown'),
os.getenv('NODE_NAME', 'Unknown'),
time.strftime("%a %b %d %H:%M:%S %Z %Y")))
f_stdout = open(TEMPEST_RESULTS_DIR + "/tempest.log", 'w+')
f_stderr = open(TEMPEST_RESULTS_DIR + "/tempest-error.log", 'w+')
f_env = open(TEMPEST_RESULTS_DIR + "/environment.log", 'w+')
f_env.write(header)
subprocess.call(cmd_line, shell=True, stdout=f_stdout, stderr=f_stderr)
f_stdout.close()
f_stderr.close()
f_env.close()
cmd_line = "rally verify show"
ft_utils.execute_command(cmd_line, logger,
exit_on_error=True, info=True)
cmd_line = "rally verify list"
logger.debug('Executing command : {}'.format(cmd_line))
cmd = os.popen(cmd_line)
output = (((cmd.read()).splitlines()[-2]).replace(" ", "")).split("|")
# Format:
# | UUID | Deployment UUID | smoke | tests | failures | Created at |
# Duration | Status |
num_tests = output[4]
num_failures = output[5]
time_start = output[6]
duration = output[7]
# Compute duration (lets assume it does not take more than 60 min)
dur_min = int(duration.split(':')[1])
dur_sec_float = float(duration.split(':')[2])
dur_sec_int = int(round(dur_sec_float, 0))
dur_sec_int = dur_sec_int + 60 * dur_min
stop_time = time.time()
# Push results in payload of testcase
if args.report:
logger.debug("Pushing tempest results into DB...")
# Note criteria hardcoded...TODO move to testcase.yaml
status = "FAIL"
try:
diff = (int(num_tests) - int(num_failures))
success_rate = 100 * diff / int(num_tests)
except:
success_rate = 0
# For Tempest we assume that the success rate is above 90%
if success_rate >= 90:
status = "PASS"
# add the test in error in the details sections
# should be possible to do it during the test
with open(TEMPEST_RESULTS_DIR + "/tempest.log", 'r') as myfile:
output = myfile.read()
error_logs = ""
for match in re.findall('(.*?)[. ]*FAILED', output):
error_logs += match
# Generate json results for DB
json_results = {"timestart": time_start, "duration": dur_sec_int,
"tests": int(num_tests), "failures": int(num_failures),
"errors": error_logs}
logger.info("Results: " + str(json_results))
# split Tempest smoke and full
if "smoke" in args.mode:
case_name = "tempest_smoke_serial"
else:
case_name = "tempest_full_parallel"
try:
ft_utils.push_results_to_db("functest",
case_name,
None,
start_time,
stop_time,
status,
json_results)
except:
logger.error("Error pushing results into Database '%s'"
% sys.exc_info()[0])
def main():
GlobalVariables.nova_client = os_utils.get_nova_client()
GlobalVariables.neutron_client = os_utils.get_neutron_client()
cinder_client = os_utils.get_cinder_client()
start_time = time.time()
# configure script
if not (args.test_name in tests):
logger.error('argument not valid')
exit(-1)
GlobalVariables.SUMMARY = []
volume_types = os_utils.list_volume_types(cinder_client, private=False)
if not volume_types:
volume_type = os_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_exists, image_id = os_utils.get_or_create_image(
GLANCE_IMAGE_NAME, GLANCE_IMAGE_PATH, GLANCE_IMAGE_FORMAT)
if not image_id:
exit(-1)
logger.debug("Creating network '%s'..." % RALLY_PRIVATE_NET_NAME)
GlobalVariables.network_dict = \
os_utils.create_shared_network_full(RALLY_PRIVATE_NET_NAME,
RALLY_PRIVATE_SUBNET_NAME,
RALLY_ROUTER_NAME,
RALLY_PRIVATE_SUBNET_CIDR)
if not GlobalVariables.network_dict:
exit(1)
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 GlobalVariables.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)
if len(GlobalVariables.SUMMARY):
success_rate = total_success / len(GlobalVariables.SUMMARY)
else:
success_rate = 100
success_rate = "{:0.2f}".format(success_rate)
success_rate_str = "{0:<10}".format(str(success_rate) + '%')
report += "+===================+============+===============+===========+"
report += "\n"
report += ("| TOTAL: | " + total_duration_str2 + " | " +
total_nb_tests_str + " | " + success_rate_str + "|\n")
report += "+===================+============+===============+===========+"
report += "\n"
logger.info("\n" + report)
payload.append({
'summary': {
'duration': total_duration,
'nb tests': total_nb_tests,
'nb success': success_rate
}
})
if args.sanity:
case_name = "rally_sanity"
else:
case_name = "rally_full"
# Evaluation of the success criteria
status = ft_utils.check_success_rate(case_name, success_rate)
exit_code = -1
if status == "PASS":
exit_code = 0
if args.report:
logger.debug("Pushing Rally summary into DB...")
ft_utils.push_results_to_db("functest", case_name, start_time,
stop_time, status, payload)
if args.noclean:
exit(exit_code)
if not image_exists:
logger.debug("Deleting image '%s' with ID '%s'..." %
(GLANCE_IMAGE_NAME, image_id))
if not os_utils.delete_glance_image(GlobalVariables.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 os_utils.delete_volume_type(cinder_client, volume_type):
logger.error("Error in deleting volume type...")
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 test_clearwater():
script = "source " + VIMS_DATA_DIR + "venv_cloudify/bin/activate; "
script += "cd " + VIMS_DATA_DIR + "; "
script += "cfy status | grep -Eo \"([0-9]{1,3}\.){3}[0-9]{1,3}\""
cmd = "/bin/bash -c '" + script + "'"
try:
logger.debug("Trying to get clearwater manager IP ... ")
mgr_ip = os.popen(cmd).read()
mgr_ip = mgr_ip.splitlines()[0]
except:
step_failure("sig_test", "Unable to retrieve the IP of the "
"cloudify manager server !")
api_url = "http://" + mgr_ip + "/api/v2"
dep_outputs = requests.get(api_url + "/deployments/" +
CW_DEPLOYMENT_NAME + "/outputs")
dns_ip = dep_outputs.json()['outputs']['dns_ip']
ellis_ip = dep_outputs.json()['outputs']['ellis_ip']
ellis_url = "http://" + ellis_ip + "/"
url = ellis_url + "accounts"
params = {"password": "******",
"full_name": "opnfv functest user",
"email": "*****@*****.**",
"signup_code": "secret"}
rq = requests.post(url, data=params)
i = 20
while rq.status_code != 201 and i > 0:
rq = requests.post(url, data=params)
i = i - 1
time.sleep(10)
if rq.status_code == 201:
url = ellis_url + "session"
rq = requests.post(url, data=params)
cookies = rq.cookies
url = ellis_url + "accounts/" + params['email'] + "/numbers"
if cookies != "":
rq = requests.post(url, cookies=cookies)
i = 24
while rq.status_code != 200 and i > 0:
rq = requests.post(url, cookies=cookies)
i = i - 1
time.sleep(25)
if rq.status_code != 200:
step_failure("sig_test", "Unable to create a number: %s"
% rq.json()['reason'])
start_time_ts = time.time()
end_time_ts = start_time_ts
logger.info("vIMS functional test Start Time:'%s'" % (
datetime.datetime.fromtimestamp(start_time_ts).strftime(
'%Y-%m-%d %H:%M:%S')))
nameservers = functest_utils.get_resolvconf_ns()
resolvconf = ""
for ns in nameservers:
resolvconf += "\nnameserver " + ns
if dns_ip != "":
script = ('echo -e "nameserver ' + dns_ip + resolvconf +
'" > /etc/resolv.conf; ')
script += 'source /etc/profile.d/rvm.sh; '
script += 'cd ' + VIMS_TEST_DIR + '; '
script += ('rake test[' + CW_INPUTS["public_domain"] +
'] SIGNUP_CODE="secret"')
cmd = "/bin/bash -c '" + script + "'"
output_file = "output.txt"
f = open(output_file, 'w+')
subprocess.call(cmd, shell=True, stdout=f,
stderr=subprocess.STDOUT)
f.close()
end_time_ts = time.time()
duration = round(end_time_ts - start_time_ts, 1)
logger.info("vIMS functional test duration:'%s'" % duration)
f = open(output_file, 'r')
result = f.read()
if result != "" and logger:
logger.debug(result)
vims_test_result = ""
try:
logger.debug("Trying to load test results")
with open(VIMS_TEST_DIR + "temp.json") as f:
vims_test_result = json.load(f)
f.close()
except:
logger.error("Unable to retrieve test results")
set_result("sig_test", duration, vims_test_result)
# success criteria for vIMS (for Brahmaputra)
# - orchestrator deployed
# - VNF deployed
# TODO use test criteria defined in config file
status = "FAIL"
try:
if (RESULTS['orchestrator']['duration'] > 0 and
RESULTS['vIMS']['duration'] > 0):
status = "PASS"
except:
logger.error("Unable to set test status")
functest_utils.push_results_to_db("functest",
"vims",
logger,
TESTCASE_START_TIME,
end_time_ts,
status,
RESULTS)
try:
os.remove(VIMS_TEST_DIR + "temp.json")
except:
logger.error("Deleting file failed")
def main(argv):
(xml_file, pod, installer, scenario) = None, None, None, None
try:
opts, args = getopt.getopt(argv,
'x:p:i:s:h',
['xml=', 'pod=',
'installer=',
'scenario=',
'help'])
except getopt.GetoptError:
usage()
for opt, arg in opts:
if opt in ('-h', '--help'):
usage()
elif opt in ('-x', '--xml'):
xml_file = arg
elif opt in ('-p', '--pod'):
pod = arg
elif opt in ('-i', '--installer'):
installer = arg
elif opt in ('-s', '--scenario'):
scenario = arg
else:
usage()
if not all(x is not None for x in (xml_file, pod, installer, scenario)):
usage()
with open(xml_file, "r") as myfile:
xml_input = myfile.read().replace('\n', '')
# dictionary populated with data from xml file
all_data = xmltodict.parse(xml_input)['robot']
try:
data = parse_suites(all_data['suite']['suite'])
data['description'] = all_data['suite']['@name']
data['version'] = all_data['@generator']
data['test_project'] = "functest"
data['case_name'] = "odl"
data['pod_name'] = pod
data['installer'] = installer
json.dumps(data, indent=4, separators=(',', ': '))
# example:
# python odlreport2db.py -x ~/Pictures/Perso/odl/output3.xml
# -i fuel
# -p opnfv-jump-2
# -s os-odl_l2-ha
# success criteria for ODL = 100% of tests OK
status = "FAIL"
# TODO as part of the tests are executed before in the bash
# start and stoptime have no real meaning
start_time = time.time()
stop_time = start_time
tests_passed = 0
tests_failed = 0
for v in data['details']:
if v['test_status']['@status'] == "PASS":
tests_passed += 1
else:
tests_failed += 1
if (tests_failed < 1):
status = "PASS"
functest_utils.push_results_to_db(data['test_project'],
data['case_name'],
None,
start_time,
stop_time,
status,
data)
except:
print("Error pushing ODL results into DB '%s'" % sys.exc_info()[0])
