def get_vim_descriptor(self):
""""Create VIM descriptor to be used for onboarding"""
self.logger.info("Building VIM descriptor with PoP creds: %s",
self.creds)
# Depending on API version either tenant ID or project name must be
# used
if os_utils.is_keystone_v3():
self.logger.info(
"Using v3 API of OpenStack... -> Using OS_PROJECT_ID")
project_id = os_utils.get_tenant_id(os_utils.get_keystone_client(),
self.creds.get("project_name"))
else:
self.logger.info(
"Using v2 API of OpenStack... -> Using OS_TENANT_NAME")
project_id = self.creds.get("tenant_name")
self.logger.debug("VIM project/tenant id: %s", project_id)
vim_json = {
"name": "vim-instance",
"authUrl": self.creds.get("auth_url"),
"tenant": project_id,
"username": self.creds.get("username"),
"password": self.creds.get("password"),
"securityGroups": [self.mano['details']['sec_group']],
"type": "openstack",
"location": {
"name": "opnfv",
"latitude": "52.525876",
"longitude": "13.314400"
}
}
self.logger.info("Built VIM descriptor: %s", vim_json)
return vim_json
def main():
logger.info("Generating OpenStack snapshot...")
nova_client = os_utils.get_nova_client()
neutron_client = os_utils.get_neutron_client()
keystone_client = os_utils.get_keystone_client()
cinder_client = os_utils.get_cinder_client()
if not os_utils.check_credentials():
logger.error("Please source the openrc credentials and run the" +
"script again.")
exit(-1)
snapshot = {}
snapshot.update(get_instances(nova_client))
snapshot.update(get_images(nova_client))
snapshot.update(get_volumes(cinder_client))
snapshot.update(get_networks(neutron_client))
snapshot.update(get_routers(neutron_client))
snapshot.update(get_security_groups(neutron_client))
snapshot.update(get_floatinips(nova_client))
snapshot.update(get_users(keystone_client))
snapshot.update(get_tenants(keystone_client))
with open(OS_SNAPSHOT_FILE, 'w+') as yaml_file:
yaml_file.write(yaml.safe_dump(snapshot, default_flow_style=False))
yaml_file.seek(0)
logger.debug("Openstack Snapshot found in the deployment:\n%s" %
yaml_file.read())
logger.debug("NOTE: These objects will NOT be deleted after " +
"running the test.")
def __init__(self, **kwargs):
if "case_name" not in kwargs:
kwargs["case_name"] = "juju_epc"
super(JujuEpc, self).__init__(**kwargs)
# Retrieve the configuration
self.case_dir = pkg_resources.resource_filename(
'functest', 'opnfv_tests/vnf/epc')
try:
self.config = CONST.__getattribute__(
'vnf_{}_config'.format(self.case_name))
except Exception:
raise Exception("VNF config file not found")
config_file = os.path.join(self.case_dir, self.config)
self.orchestrator = dict(
requirements=get_config("orchestrator.requirements", config_file),
)
self.created_object = []
self.snaps_creds = ''
self.os_creds = openstack_tests.get_credentials(
os_env_file=CONST.__getattribute__('openstack_creds'))
self.details['orchestrator'] = dict(
name=get_config("orchestrator.name", config_file),
version=get_config("orchestrator.version", config_file),
status='ERROR',
result=''
)
self.vnf = dict(
descriptor=get_config("vnf.descriptor", config_file),
requirements=get_config("vnf.requirements", config_file)
)
self.details['vnf'] = dict(
descriptor_version=self.vnf['descriptor']['version'],
name=get_config("vnf.name", config_file),
version=get_config("vnf.version", config_file),
)
self.__logger.debug("VNF configuration: %s", self.vnf)
self.details['test_vnf'] = dict(
name=get_config("vnf_test_suite.name", config_file),
version=get_config("vnf_test_suite.version", config_file),
tag_name=get_config("vnf_test_suite.tag_name", config_file)
)
self.images = get_config("tenant_images", config_file)
self.__logger.info("Images needed for vEPC: %s", self.images)
self.keystone_client = os_utils.get_keystone_client()
self.glance_client = os_utils.get_glance_client()
self.neutron_client = os_utils.get_neutron_client()
self.nova_client = os_utils.get_nova_client()
self.sec_group_id = None
self.public_auth_url = None
self.creds = None
self.filename = None
def prepare(self):
self.creds = os_utils.get_credentials()
self.keystone_client = os_utils.get_keystone_client()
self.logger.info("Prepare OpenStack plateform(create tenant and user)")
admin_user_id = os_utils.get_user_id(self.keystone_client,
self.creds['username'])
if admin_user_id == '':
self.step_failure("Failed to get id of " + self.creds['username'])
tenant_id = os_utils.create_tenant(self.keystone_client,
self.tenant_name,
self.tenant_description)
if not tenant_id:
self.step_failure("Failed to create " + self.tenant_name +
" tenant")
roles_name = ["admin", "Admin"]
role_id = ''
for role_name in roles_name:
if role_id == '':
role_id = os_utils.get_role_id(self.keystone_client, role_name)
if role_id == '':
self.logger.error("Failed to get id for %s role" % role_name)
self.step_failure("Failed to get role id of " + role_name)
if not os_utils.add_role_user(self.keystone_client, admin_user_id,
role_id, tenant_id):
self.logger.error("Failed to add %s on tenant" %
self.creds['username'])
self.step_failure("Failed to add %s on tenant" %
self.creds['username'])
user_id = os_utils.create_user(self.keystone_client, self.tenant_name,
self.tenant_name, None, tenant_id)
if not user_id:
self.logger.error("Failed to create %s user" % self.tenant_name)
self.step_failure("Failed to create user ")
if not os_utils.add_role_user(self.keystone_client, user_id, role_id,
tenant_id):
self.logger.error("Failed to add %s on tenant" % self.tenant_name)
self.step_failure("Failed to add %s on tenant" % self.tenant_name)
self.logger.info("Update OpenStack creds informations")
self.admin_creds = self.creds.copy()
self.admin_creds.update({"tenant": self.tenant_name})
self.neutron_client = os_utils.get_neutron_client(self.admin_creds)
self.nova_client = os_utils.get_nova_client(self.admin_creds)
self.creds.update({
"tenant": self.tenant_name,
"username": self.tenant_name,
"password": self.tenant_name,
})
def main():
logging.basicConfig()
logger.info("Cleaning OpenStack resources...")
nova_client = os_utils.get_nova_client()
neutron_client = os_utils.get_neutron_client()
keystone_client = os_utils.get_keystone_client()
cinder_client = os_utils.get_cinder_client()
glance_client = os_utils.get_glance_client()
try:
with open(OS_SNAPSHOT_FILE) as f:
snapshot_yaml = yaml.safe_load(f)
except Exception:
logger.info("The file %s does not exist. The OpenStack snapshot must"
" be created first. Aborting cleanup." % OS_SNAPSHOT_FILE)
return 0
default_images = snapshot_yaml.get('images')
default_instances = snapshot_yaml.get('instances')
default_volumes = snapshot_yaml.get('volumes')
default_networks = snapshot_yaml.get('networks')
default_routers = snapshot_yaml.get('routers')
default_security_groups = snapshot_yaml.get('secgroups')
default_floatingips = snapshot_yaml.get('floatingips')
default_users = snapshot_yaml.get('users')
default_tenants = snapshot_yaml.get('tenants')
if not os_utils.check_credentials():
logger.error("Please source the openrc credentials and run "
"the script again.")
return -1
remove_instances(nova_client, default_instances)
separator()
remove_images(glance_client, default_images)
separator()
remove_volumes(cinder_client, default_volumes)
separator()
remove_floatingips(neutron_client, default_floatingips)
separator()
remove_networks(neutron_client, default_networks, default_routers)
separator()
remove_security_groups(neutron_client, default_security_groups)
separator()
remove_users(keystone_client, default_users)
separator()
remove_tenants(keystone_client, default_tenants)
separator()
return 0
def create_tempest_resources(self):
keystone_client = os_utils.get_keystone_client()
logger.debug("Creating tenant and user for Tempest suite")
tenant_id = os_utils.create_tenant(
keystone_client,
CONST.tempest_identity_tenant_name,
CONST.tempest_identity_tenant_description)
if not tenant_id:
logger.error("Failed to create %s tenant"
% CONST.tempest_identity_tenant_name)
user_id = os_utils.create_user(keystone_client,
CONST.tempest_identity_user_name,
CONST.tempest_identity_user_password,
None, tenant_id)
if not user_id:
logger.error("Failed to create %s user" %
CONST.tempest_identity_user_name)
logger.debug("Creating private network for Tempest suite")
network_dic = os_utils.create_shared_network_full(
CONST.tempest_private_net_name,
CONST.tempest_private_subnet_name,
CONST.tempest_router_name,
CONST.tempest_private_subnet_cidr)
if network_dic is None:
raise Exception('Failed to create private network')
if CONST.tempest_use_custom_images:
# adding alternative image should be trivial should we need it
logger.debug("Creating image for Tempest suite")
_, self.IMAGE_ID = os_utils.get_or_create_image(
CONST.openstack_image_name, conf_utils.GLANCE_IMAGE_PATH,
CONST.openstack_image_disk_format)
if self.IMAGE_ID is None:
raise Exception('Failed to create image')
if CONST.tempest_use_custom_flavors:
# adding alternative flavor should be trivial should we need it
logger.debug("Creating flavor for Tempest suite")
_, self.FLAVOR_ID = os_utils.get_or_create_flavor(
CONST.openstack_flavor_name,
CONST.openstack_flavor_ram,
CONST.openstack_flavor_disk,
CONST.openstack_flavor_vcpus)
if self.FLAVOR_ID is None:
raise Exception('Failed to create flavor')
def run(self):
try:
kclient = op_utils.get_keystone_client()
keystone_url = kclient.service_catalog.url_for(
service_type='identity', endpoint_type='publicURL')
neutron_url = kclient.service_catalog.url_for(
service_type='network', endpoint_type='publicURL')
kwargs = {'keystoneip': urlparse.urlparse(keystone_url).hostname}
kwargs['neutronip'] = urlparse.urlparse(neutron_url).hostname
kwargs['odlip'] = kwargs['neutronip']
kwargs['odlwebport'] = '8080'
kwargs['odlrestconfport'] = '8181'
kwargs['odlusername'] = '******'
kwargs['odlpassword'] = '******'
installer_type = ft_constants.CI_INSTALLER_TYPE
kwargs['osusername'] = ft_constants.OS_USERNAME
kwargs['ostenantname'] = ft_constants.OS_TENANT_NAME
kwargs['ospassword'] = ft_constants.OS_PASSWORD
if installer_type == 'fuel':
kwargs['odlwebport'] = '8282'
elif installer_type == 'apex':
if ft_constants.SDN_CONTROLLER_IP is None:
return self.EX_RUN_ERROR
kwargs['odlip'] = ft_constants.SDN_CONTROLLER_IP
kwargs['odlwebport'] = '8181'
elif installer_type == 'joid':
if ft_constants.SDN_CONTROLLER is None:
return self.EX_RUN_ERROR
kwargs['odlip'] = ft_constants.SDN_CONTROLLER
elif installer_type == 'compass':
kwargs['odlwebport'] = '8181'
else:
if ft_constants.SDN_CONTROLLER_IP is None:
return self.EX_RUN_ERROR
kwargs['odlip'] = ft_constants.SDN_CONTROLLER_IP
except KeyError as e:
self.logger.error("Cannot run ODL testcases. "
"Please check env var: "
"%s" % str(e))
return self.EX_RUN_ERROR
except Exception:
self.logger.exception("Cannot run ODL testcases.")
return self.EX_RUN_ERROR
return self.main(**kwargs)
def clean_enviroment(self, cfy):
# ########### CLOUDIFY UNDEPLOYMENT #############
cfy.undeploy_manager()
# ############## TNENANT CLEANUP ################
self.ks_cresds = os_utils.get_credentials()
self.logger.info("Removing %s tenant .." %
CFY_INPUTS['keystone_tenant_name'])
keystone = os_utils.get_keystone_client()
tenant_id = os_utils.get_tenant_id(keystone,
CFY_INPUTS['keystone_tenant_name'])
if tenant_id == '':
self.logger.error("Error : Failed to get id of %s tenant" %
CFY_INPUTS['keystone_tenant_name'])
else:
resulut = os_utils.delete_tenant(keystone, tenant_id)
if not resulut:
self.logger.error("Error : Failed to remove %s tenant" %
CFY_INPUTS['keystone_tenant_name'])
self.logger.info("Removing %s user .." %
CFY_INPUTS['keystone_username'])
user_id = os_utils.get_user_id(keystone,
CFY_INPUTS['keystone_username'])
if user_id == '':
self.logger.error("Error : Failed to get id of %s user" %
CFY_INPUTS['keystone_username'])
else:
result = os_utils.delete_user(keystone, user_id)
if not result:
self.logger.error("Error : Failed to remove %s user" %
CFY_INPUTS['keystone_username'])
return self.set_resultdata(self.testcase_start_time, "", "",
self.results)
def __init__(self,
project='functest',
case_name='orchestra_ims',
repo='',
cmd=''):
super(ImsVnf, self).__init__(project, case_name, repo, cmd)
self.logger = logging.getLogger(__name__)
self.logger.info("Orchestra IMS VNF onboarding test starting")
self.ob_password = "******"
self.ob_username = "******"
self.ob_https = False
self.ob_port = "8080"
self.ob_ip = "localhost"
self.ob_instance_id = ""
self.case_dir = pkg_resources.resource_filename(
'functest', 'opnfv_tests/vnf/ims/')
self.data_dir = CONST.__getattribute__('dir_ims_data')
self.test_dir = CONST.__getattribute__('dir_repo_vims_test')
self.ob_projectid = ""
self.keystone_client = os_utils.get_keystone_client()
self.ob_nsr_id = ""
self.nsr = None
self.main_agent = None
# vIMS Data directory creation
if not os.path.exists(self.data_dir):
os.makedirs(self.data_dir)
# Retrieve the configuration
try:
self.config = CONST.__getattribute__('vnf_{}_config'.format(
self.case_name))
except BaseException:
raise Exception("Orchestra VNF config file not found")
config_file = self.case_dir + self.config
self.imagename = get_config("openbaton.imagename", config_file)
self.bootstrap_link = get_config("openbaton.bootstrap_link",
config_file)
self.bootstrap_config_link = get_config(
"openbaton.bootstrap_config_link", config_file)
self.market_link = get_config("openbaton.marketplace_link",
config_file)
self.images = get_config("tenant_images", config_file)
self.ims_conf = get_config("vIMS", config_file)
self.userdata_file = get_config("openbaton.userdata.file", config_file)
def prepare_floating_ip(self):
"""Select/Create Floating IP if it doesn't exist yet"""
self.logger.info("Retrieving floating IP for Open Baton NFVO")
neutron_client = snaps_utils.neutron_utils.neutron_client(
self.snaps_creds)
# Finding Tenant ID to check to which tenant the Floating IP belongs
tenant_id = os_utils.get_tenant_id(
os_utils.get_keystone_client(self.creds),
self.tenant_name)
# Use os_utils to retrieve complete information of Floating IPs
floating_ips = os_utils.get_floating_ips(neutron_client)
my_floating_ips = []
# Filter Floating IPs with tenant id
for floating_ip in floating_ips:
# self.logger.info("Floating IP: %s", floating_ip)
if floating_ip.get('tenant_id') == tenant_id:
my_floating_ips.append(floating_ip.get('floating_ip_address'))
# Select if Floating IP exist else create new one
if len(my_floating_ips) >= 1:
# Get Floating IP object from snaps for clean up
snaps_floating_ips = snaps_utils.neutron_utils.get_floating_ips(
neutron_client)
for my_floating_ip in my_floating_ips:
for snaps_floating_ip in snaps_floating_ips:
if snaps_floating_ip.ip == my_floating_ip:
self.mano['details']['fip'] = snaps_floating_ip
self.logger.info(
"Selected floating IP for Open Baton NFVO %s",
(self.mano['details']['fip'].ip))
break
if self.mano['details']['fip'] is not None:
break
else:
self.logger.info("Creating floating IP for Open Baton NFVO")
self.mano['details']['fip'] = (
snaps_utils.neutron_utils. create_floating_ip(
neutron_client, self.mano['details']['external_net_name']))
self.logger.info(
"Created floating IP for Open Baton NFVO %s",
(self.mano['details']['fip'].ip))
def create_tempest_resources():
keystone_client = os_utils.get_keystone_client()
logger.debug("Creating tenant and user for Tempest suite")
tenant_id = os_utils.create_tenant(keystone_client, TEMPEST_TENANT_NAME,
TEMPEST_TENANT_DESCRIPTION)
if not tenant_id:
logger.error("Error : Failed to create %s tenant" %
TEMPEST_TENANT_NAME)
user_id = os_utils.create_user(keystone_client, TEMPEST_USER_NAME,
TEMPEST_USER_PASSWORD, None, tenant_id)
if not user_id:
logger.error("Error : Failed to create %s user" % TEMPEST_USER_NAME)
logger.debug("Creating private network for Tempest suite")
network_dic = \
os_utils.create_shared_network_full(TEMPEST_PRIVATE_NET_NAME,
TEMPEST_PRIVATE_SUBNET_NAME,
TEMPEST_ROUTER_NAME,
TEMPEST_PRIVATE_SUBNET_CIDR)
if not network_dic:
exit(1)
if TEMPEST_USE_CUSTOM_IMAGES:
# adding alternative image should be trivial should we need it
logger.debug("Creating image for Tempest suite")
_, GlobalVariables.IMAGE_ID = os_utils.get_or_create_image(
GLANCE_IMAGE_NAME, GLANCE_IMAGE_PATH, GLANCE_IMAGE_FORMAT)
if not GlobalVariables.IMAGE_ID:
exit(-1)
if TEMPEST_USE_CUSTOM_FLAVORS:
# adding alternative flavor should be trivial should we need it
logger.debug("Creating flavor for Tempest suite")
_, GlobalVariables.FLAVOR_ID = os_utils.get_or_create_flavor(
FLAVOR_NAME, FLAVOR_RAM, FLAVOR_DISK, FLAVOR_VCPUS)
if not GlobalVariables.FLAVOR_ID:
exit(-1)
def create_tempest_resources(use_custom_images=False,
use_custom_flavors=False):
keystone_client = os_utils.get_keystone_client()
logger.debug("Creating tenant and user for Tempest suite")
tenant_id = os_utils.create_tenant(
keystone_client,
CONST.__getattribute__('tempest_identity_tenant_name'),
CONST.__getattribute__('tempest_identity_tenant_description'))
if not tenant_id:
logger.error("Failed to create %s tenant"
% CONST.__getattribute__('tempest_identity_tenant_name'))
user_id = os_utils.create_user(
keystone_client,
CONST.__getattribute__('tempest_identity_user_name'),
CONST.__getattribute__('tempest_identity_user_password'),
None, tenant_id)
if not user_id:
logger.error("Failed to create %s user" %
CONST.__getattribute__('tempest_identity_user_name'))
logger.debug("Creating private network for Tempest suite")
network_dic = os_utils.create_shared_network_full(
CONST.__getattribute__('tempest_private_net_name'),
CONST.__getattribute__('tempest_private_subnet_name'),
CONST.__getattribute__('tempest_router_name'),
CONST.__getattribute__('tempest_private_subnet_cidr'))
if network_dic is None:
raise Exception('Failed to create private network')
image_id = ""
image_id_alt = ""
flavor_id = ""
flavor_id_alt = ""
if (CONST.__getattribute__('tempest_use_custom_images') or
use_custom_images):
# adding alternative image should be trivial should we need it
logger.debug("Creating image for Tempest suite")
_, image_id = os_utils.get_or_create_image(
CONST.__getattribute__('openstack_image_name'),
GLANCE_IMAGE_PATH,
CONST.__getattribute__('openstack_image_disk_format'))
if image_id is None:
raise Exception('Failed to create image')
if use_custom_images:
logger.debug("Creating 2nd image for Tempest suite")
_, image_id_alt = os_utils.get_or_create_image(
CONST.__getattribute__('openstack_image_name_alt'),
GLANCE_IMAGE_PATH,
CONST.__getattribute__('openstack_image_disk_format'))
if image_id_alt is None:
raise Exception('Failed to create image')
if (CONST.__getattribute__('tempest_use_custom_flavors') or
use_custom_flavors):
# adding alternative flavor should be trivial should we need it
logger.debug("Creating flavor for Tempest suite")
_, flavor_id = os_utils.get_or_create_flavor(
CONST.__getattribute__('openstack_flavor_name'),
CONST.__getattribute__('openstack_flavor_ram'),
CONST.__getattribute__('openstack_flavor_disk'),
CONST.__getattribute__('openstack_flavor_vcpus'))
if flavor_id is None:
raise Exception('Failed to create flavor')
if use_custom_flavors:
logger.debug("Creating 2nd flavor for tempest_defcore")
_, flavor_id_alt = os_utils.get_or_create_flavor(
CONST.__getattribute__('openstack_flavor_name_alt'),
CONST.__getattribute__('openstack_flavor_ram'),
CONST.__getattribute__('openstack_flavor_disk'),
CONST.__getattribute__('openstack_flavor_vcpus'))
if flavor_id_alt is None:
raise Exception('Failed to create flavor')
img_flavor_dict = {}
img_flavor_dict['image_id'] = image_id
img_flavor_dict['image_id_alt'] = image_id_alt
img_flavor_dict['flavor_id'] = flavor_id
img_flavor_dict['flavor_id_alt'] = flavor_id_alt
return img_flavor_dict
def deploy_vnf(self):
self.logger.info("Starting vIMS Deployment...")
self.main_agent = MainAgent(nfvo_ip=self.ob_ip,
nfvo_port=self.ob_port,
https=self.ob_https,
version=1,
username=self.ob_username,
password=self.ob_password)
self.logger.info(
"Check if openims Flavor is available, if not create one")
flavor_exist, flavor_id = os_utils.get_or_create_flavor("m1.small",
"2048",
'20',
'1',
public=True)
self.logger.debug("Flavor id: %s", flavor_id)
self.logger.info("Getting project 'default'...")
project_agent = self.main_agent.get_agent("project", self.ob_projectid)
for p in json.loads(project_agent.find()):
if p.get("name") == "default":
self.ob_projectid = p.get("id")
self.logger.info("Found project 'default': %s", p)
break
self.logger.debug("project id: %s", self.ob_projectid)
if self.ob_projectid == "":
self.logger.error("Default project id was not found!")
creds = os_utils.get_credentials()
self.logger.info("PoP creds: %s", creds)
if os_utils.is_keystone_v3():
self.logger.info(
"Using v3 API of OpenStack... -> Using OS_PROJECT_ID")
project_id = os_utils.get_tenant_id(os_utils.get_keystone_client(),
creds.get("project_name"))
else:
self.logger.info(
"Using v2 API of OpenStack... -> Using OS_TENANT_NAME")
project_id = creds.get("tenant_name")
self.logger.debug("project id: %s", project_id)
vim_json = {
"name": "vim-instance",
"authUrl": creds.get("auth_url"),
"tenant": project_id,
"username": creds.get("username"),
"password": creds.get("password"),
"securityGroups": ["default", "orchestra-sec-group"],
"type": "openstack",
"location": {
"name": "opnfv",
"latitude": "52.525876",
"longitude": "13.314400"
}
}
self.logger.debug("Registering VIM: %s", vim_json)
self.main_agent.get_agent(
"vim",
project_id=self.ob_projectid).create(entity=json.dumps(vim_json))
market_agent = self.main_agent.get_agent("market",
project_id=self.ob_projectid)
nsd = {}
try:
self.logger.info("sending: %s", self.market_link)
nsd = market_agent.create(entity=self.market_link)
self.logger.info("Onboarded NSD: " + nsd.get("name"))
except NfvoException as e:
self.logger.error(e.message)
nsr_agent = self.main_agent.get_agent("nsr",
project_id=self.ob_projectid)
nsd_id = nsd.get('id')
if nsd_id is None:
self.logger.error("NSD not onboarded correctly")
try:
self.nsr = nsr_agent.create(nsd_id)
except NfvoException as e:
self.logger.error(e.message)
if self.nsr.get('code') is not None:
self.logger.error("vIMS cannot be deployed: %s -> %s",
self.nsr.get('code'), self.nsr.get('message'))
self.logger.error("vIMS cannot be deployed")
i = 0
self.logger.info("Waiting for NSR to go to ACTIVE...")
while self.nsr.get("status") != 'ACTIVE' and self.nsr.get(
"status") != 'ERROR':
i += 1
if i == 150:
self.logger.error("INACTIVE NSR after %s sec..", 5 * i)
time.sleep(5)
self.nsr = json.loads(nsr_agent.find(self.nsr.get('id')))
if self.nsr.get("status") == 'ACTIVE':
self.details["vnf"] = {'status': "PASS", 'result': self.nsr}
self.logger.info("Deploy VNF: OK")
else:
self.details["vnf"] = {'status': "FAIL", 'result': self.nsr}
self.logger.error(self.nsr)
self.logger.error("Deploy VNF: ERROR")
return False
self.ob_nsr_id = self.nsr.get("id")
self.logger.info(
"Sleep for 60s to ensure that all services are up and running...")
time.sleep(60)
return True
def main():
logger.info("Cleaning OpenStack resources...")
nova_client = os_utils.get_nova_client()
neutron_client = os_utils.get_neutron_client()
keystone_client = os_utils.get_keystone_client()
cinder_client = os_utils.get_cinder_client()
tacker_client = os_tacker.get_tacker_client()
try:
with open(OS_SNAPSHOT_FILE) as f:
snapshot_yaml = yaml.safe_load(f)
except Exception:
logger.info("The file %s does not exist. The OpenStack snapshot must"
" be created first. Aborting cleanup." % OS_SNAPSHOT_FILE)
exit(0)
default_images = snapshot_yaml.get('images')
default_instances = snapshot_yaml.get('instances')
default_volumes = snapshot_yaml.get('volumes')
default_networks = snapshot_yaml.get('networks')
default_routers = snapshot_yaml.get('routers')
default_security_groups = snapshot_yaml.get('secgroups')
default_floatingips = snapshot_yaml.get('floatingips')
default_users = snapshot_yaml.get('users')
default_tenants = snapshot_yaml.get('tenants')
default_vnfds = snapshot_yaml.get('vnfds')
default_vnfs = snapshot_yaml.get('vnfs')
default_sfcs = snapshot_yaml.get('sfcs')
default_sfc_classifiers = snapshot_yaml.get('sfc_classifiers')
if not os_utils.check_credentials():
logger.error("Please source the openrc credentials and run "
"the script again.")
exit(-1)
remove_instances(nova_client, default_instances)
separator()
remove_images(nova_client, default_images)
separator()
remove_volumes(cinder_client, default_volumes)
separator()
remove_floatingips(nova_client, default_floatingips)
separator()
remove_networks(neutron_client, default_networks, default_routers)
separator()
remove_security_groups(neutron_client, default_security_groups)
separator()
remove_users(keystone_client, default_users)
separator()
remove_tenants(keystone_client, default_tenants)
separator()
# Note: Delete in this order
# 1. Classifiers, 2. SFCs, 3. VNFs, 4. VNFDs
remove_tacker_sfc_classifiers(tacker_client, default_sfc_classifiers)
separator()
remove_tacker_sfcs(tacker_client, default_sfcs)
separator()
remove_tacker_vnfs(tacker_client, default_vnfs)
separator()
remove_tacker_vnfds(tacker_client, default_vnfds)
separator()
def deploy_orchestrator(self, **kwargs):
self.logger.info("Additional pre-configuration steps")
self.neutron_client = os_utils.get_neutron_client(self.admin_creds)
self.glance_client = os_utils.get_glance_client(self.admin_creds)
self.keystone_client = os_utils.get_keystone_client(self.admin_creds)
self.nova_client = os_utils.get_nova_client(self.admin_creds)
# 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(self.glance_client,
image_name)
self.logger.debug("image_id: %s" % image_id)
except:
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 = download_and_add_image_on_glance(
self.glance_client, image_name, image_url, temp_dir)
if image_id == '':
self.step_failure("Failed to find or upload required OS "
"image for this deployment")
# Need to extend quota
self.logger.info("Update security group quota for this tenant")
tenant_id = os_utils.get_tenant_id(self.keystone_client,
self.tenant_name)
self.logger.debug("Tenant id found %s" % tenant_id)
if not os_utils.update_sg_quota(self.neutron_client, tenant_id, 50,
100):
self.step_failure("Failed to update security group quota" +
" for tenant " + self.tenant_name)
self.logger.debug("group quota extended")
# start the deployment of cloudify
public_auth_url = os_utils.get_endpoint('identity')
self.logger.debug("CFY inputs: %s" % self.orchestrator['inputs'])
cfy = Orchestrator(self.data_dir, self.orchestrator['inputs'])
self.orchestrator['object'] = cfy
self.logger.debug("Orchestrator object created")
self.logger.debug("Tenant name: %s" % self.tenant_name)
cfy.set_credentials(username=self.tenant_name,
password=self.tenant_name,
tenant_name=self.tenant_name,
auth_url=public_auth_url)
self.logger.info("Credentials set in CFY")
# orchestrator VM flavor
self.logger.info("Check Flavor is available, if not create one")
self.logger.debug("Flavor details %s " %
self.orchestrator['requirements']['ram_min'])
flavor_exist, flavor_id = os_utils.get_or_create_flavor(
"m1.large",
self.orchestrator['requirements']['ram_min'],
'1',
'1',
public=True)
self.logger.debug("Flavor id: %s" % flavor_id)
if not flavor_id:
self.logger.info("Available flavors are: ")
self.logger.info(self.nova_client.flavor.list())
self.step_failure("Failed to find required flavor"
"for this deployment")
cfy.set_flavor_id(flavor_id)
self.logger.debug("Flavor OK")
# orchestrator VM image
self.logger.debug("Orchestrator image")
if 'os_image' in self.orchestrator['requirements'].keys():
image_id = os_utils.get_image_id(
self.glance_client,
self.orchestrator['requirements']['os_image'])
self.logger.debug("Orchestrator image id: %s" % image_id)
if image_id == '':
self.logger.error("CFY image not found")
self.step_failure("Failed to find required OS image"
" for cloudify manager")
else:
self.step_failure("Failed to find required OS image"
" for cloudify manager")
cfy.set_image_id(image_id)
self.logger.debug("Orchestrator image set")
self.logger.debug("Get External network")
ext_net = os_utils.get_external_net(self.neutron_client)
self.logger.debug("External network: %s" % ext_net)
if not ext_net:
self.step_failure("Failed to get external network")
cfy.set_external_network_name(ext_net)
self.logger.debug("CFY External network set")
self.logger.debug("get resolvconf")
ns = ft_utils.get_resolvconf_ns()
if ns:
cfy.set_nameservers(ns)
self.logger.debug("Resolvconf set")
self.logger.info("Prepare virtualenv for cloudify-cli")
cmd = "chmod +x " + self.case_dir + "create_venv.sh"
ft_utils.execute_command(cmd)
time.sleep(3)
cmd = self.case_dir + "create_venv.sh " + self.data_dir
ft_utils.execute_command(cmd)
cfy.download_manager_blueprint(
self.orchestrator['blueprint']['url'],
self.orchestrator['blueprint']['branch'])
cfy.deploy_manager()
return {'status': 'PASS', 'result': ''}
def execute(self):
nova_client = os_utils.get_nova_client()
neutron_client = os_utils.get_neutron_client()
tenant_id = os_utils.get_tenant_id(os_utils.get_keystone_client(),
os.environ['OS_PROJECT_NAME'])
neutron_quota = test_utils.get_neutron_quota(neutron_client, tenant_id)
(neutron_nw_quota, neutron_subnet_quota,
neutron_port_quota) = (neutron_quota['network'],
neutron_quota['subnet'], neutron_quota['port'])
instances_quota = test_utils.get_nova_instances_quota(nova_client)
self.__logger.info("Setting net/subnet/port quota to unlimited")
test_utils.update_nw_subnet_port_quota(
neutron_client, tenant_id, COMMON_CONFIG.neutron_nw_quota,
COMMON_CONFIG.neutron_subnet_quota,
COMMON_CONFIG.neutron_port_quota)
# Workaround for
# https://jira.opnfv.org/projects/SDNVPN/issues/SDNVPN-115
self.__logger.info("Setting instances quota class to unlimited")
test_utils.update_instance_quota_class(
nova_client, COMMON_CONFIG.nova_instances_quota_class)
with open(COMMON_CONFIG.config_file) as f:
config_yaml = yaml.safe_load(f)
testcases = config_yaml.get("testcases")
overall_status = "PASS"
for tc in testcases:
if testcases[tc]['enabled']:
test_name = tc
test_descr = testcases[tc]['description']
title = ("Running '%s - %s'" % (test_name, test_descr))
self.__logger.info(title)
self.__logger.info("%s\n" % ("=" * len(title)))
t = importlib.import_module(test_name, package=None)
try:
result = t.main()
except Exception as ex:
result = -1
self.__logger.info("Caught Exception in %s: %s Trace: %s" %
(test_name, ex, traceback.format_exc()))
if result < 0:
status = "FAIL"
overall_status = "FAIL"
self.__logger.info("Testcase %s failed" % test_name)
else:
status = result.get("status")
self.details.update({
test_name: {
'status': status,
'details': result.get("details")
}
})
self.__logger.info(
"Results of test case '%s - %s':\n%s\n" %
(test_name, test_descr, result))
if status == "FAIL":
overall_status = "FAIL"
self.__logger.info("Resetting subnet/net/port quota")
test_utils.update_nw_subnet_port_quota(neutron_client, tenant_id,
neutron_nw_quota,
neutron_subnet_quota,
neutron_port_quota)
self.__logger.info("Resetting instances quota class")
test_utils.update_instance_quota_class(nova_client, instances_quota)
try:
installer_type = str(os.environ['INSTALLER_TYPE'].lower())
if installer_type in ["fuel", "apex"]:
gather_logs('overall')
else:
self.__logger.info("Skipping log gathering because installer"
"type %s is neither fuel nor apex" %
installer_type)
except Exception as ex:
self.__logger.error(
('Something went wrong in the Log gathering.'
'Ex: %s, Trace: %s') % (ex, traceback.format_exc()))
if overall_status == "PASS":
self.result = 100
return base.Feature.EX_OK
return base.Feature.EX_RUN_ERROR
def init(self):
start_time_ts = time.time()
self.util = utilvnf(self.logger)
self.ks_cresds = os_utils.get_credentials()
self.logger.info("Prepare OpenStack plateform(create tenant and user)")
keystone = os_utils.get_keystone_client()
user_id = os_utils.get_user_id(keystone, self.ks_cresds['username'])
if user_id == '':
return self.step_failure(
"init",
"Error : Failed to get id of " + self.ks_cresds['username'])
tenant_id = os_utils.create_tenant(keystone, TENANT_NAME,
TENANT_DESCRIPTION)
if tenant_id == '':
return self.step_failure(
"init", "Error : Failed to create " + TENANT_NAME + " tenant")
roles_name = ["admin", "Admin"]
role_id = ''
for role_name in roles_name:
if role_id == '':
role_id = os_utils.get_role_id(keystone, role_name)
if role_id == '':
self.logger.error("Error : Failed to get id for %s role" %
role_name)
if not os_utils.add_role_user(keystone, user_id, role_id, tenant_id):
self.logger.error("Error : Failed to add %s on tenant" %
self.ks_cresds['username'])
user_id = os_utils.create_user(keystone, TENANT_NAME, TENANT_NAME,
None, tenant_id)
if user_id == '':
self.logger.error("Error : Failed to create %s user" % TENANT_NAME)
if not os_utils.add_role_user(keystone, user_id, role_id, tenant_id):
self.logger.error("Failed to add %s on tenant" % TENANT_NAME)
self.logger.info("Update OpenStack creds informations")
self.ks_cresds.update({
"tenant_name": TENANT_NAME,
})
self.neutron = os_utils.get_neutron_client(self.ks_cresds)
nova = os_utils.get_nova_client()
self.glance = os_utils.get_glance_client(self.ks_cresds)
self.ks_cresds.update({
"username": TENANT_NAME,
"password": TENANT_NAME,
})
self.load_test_env_config()
self.logger.info("Upload some OS images if it doesn't exist")
images = {}
images.update(IMAGES)
images.update(self.VNF_TEST_IMAGES)
for img in images.keys():
image_name = images[img]['image_name']
self.logger.info("image name = " + image_name)
image_url = images[img]['image_url']
image_id = os_utils.get_image_id(self.glance, image_name)
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 = self.download_and_add_image_on_glance(
self.glance, image_name, image_url)
if image_id == '':
return self.step_failure(
"init", "Error : Failed to find or upload required OS "
"image for this deployment")
self.logger.info("Update security group quota for this tenant")
result = os_utils.update_sg_quota(self.neutron, tenant_id, 50, 100)
if not result:
return self.step_failure(
"init", "Failed to update security group quota for tenant " +
TENANT_NAME)
self.credentials = {
"username": TENANT_NAME,
"password": TENANT_NAME,
"auth_url": os_utils.get_endpoint('identity'),
"tenant_name": TENANT_NAME,
"region_name": os.environ['OS_REGION_NAME']
}
self.util.set_credentials(self.credentials["username"],
self.credentials["password"],
self.credentials["auth_url"],
self.credentials["tenant_name"],
self.credentials["region_name"])
test_scenario_file = open(self.util.TEST_SCENATIO_YAML_FILE, 'r')
self.test_scenario_yaml = yaml.safe_load(test_scenario_file)
test_scenario_file.close()
res = self.util.test_scenario_validation_check(self.test_scenario_yaml)
if res["status"] is False:
self.logger.error(res["message"])
return self.step_failure("init",
"Error : Faild to test execution.")
self.logger.info("Test scenario yaml validation check : " +
res["message"])
end_time_ts = time.time()
duration = round(end_time_ts - start_time_ts, 1)
self.set_result("init", duration, "OK")
return self.set_resultdata(self.testcase_start_time, "", "",
self.results)
