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)