X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=nfvo.py;h=21e57195a40510a15339c32eb5868950b57f44d7;hb=4540ea5619ae62e29ecec6b07bf0e81e35fd56f0;hp=1229f4c644e70bc47352d762d8c47c4b3baf533c;hpb=a2793919ce06ce40e809c3578a0aec27c7efbae4;p=osm%2FRO.git diff --git a/nfvo.py b/nfvo.py index 1229f4c6..21e57195 100644 --- a/nfvo.py +++ b/nfvo.py @@ -42,6 +42,8 @@ from db_base import db_base_Exception global global_config global vimconn_imported global logger +global default_volume_size +default_volume_size = '5' #size in GB vimconn_imported={} #dictionary with VIM type as key, loaded module as value @@ -108,9 +110,9 @@ def get_vim(mydb, nfvo_tenant=None, datacenter_id=None, datacenter_name=None, da if vim_tenant_name is not None: WHERE_dict['vim_tenant_name'] = vim_tenant_name if nfvo_tenant or vim_tenant or vim_tenant_name or datacenter_tenant_id: from_= 'tenants_datacenters as td join datacenters as d on td.datacenter_id=d.uuid join datacenter_tenants as dt on td.datacenter_tenant_id=dt.uuid' - select_ = ('type','config','d.uuid as datacenter_id', 'vim_url', 'vim_url_admin', 'd.name as datacenter_name', + select_ = ('type','d.config as config','d.uuid as datacenter_id', 'vim_url', 'vim_url_admin', 'd.name as datacenter_name', 'dt.uuid as datacenter_tenant_id','dt.vim_tenant_name as vim_tenant_name','dt.vim_tenant_id as vim_tenant_id', - 'user','passwd') + 'user','passwd', 'dt.config as dt_config') else: from_ = 'datacenters as d' select_ = ('type','config','d.uuid as datacenter_id', 'vim_url', 'vim_url_admin', 'd.name as datacenter_name') @@ -119,8 +121,10 @@ def get_vim(mydb, nfvo_tenant=None, datacenter_id=None, datacenter_name=None, da vim_dict={} for vim in vims: extra={'datacenter_tenant_id': vim.get('datacenter_tenant_id')} - if vim["config"] != None: + if vim["config"]: extra.update(yaml.load(vim["config"])) + if vim.get('dt_config'): + extra.update(yaml.load(vim["dt_config"])) if vim["type"] not in vimconn_imported: module_info=None try: @@ -212,7 +216,14 @@ def check_vnf_descriptor(vnf_descriptor): HTTP_Bad_Request) name_list.append( interface["name"] ) vnfc_interfaces[ vnfc["name"] ] = name_list - + # check bood-data info + if "boot-data" in vnfc: + # check that user-data is incompatible with users and config-files + if (vnfc["boot-data"].get("users") or vnfc["boot-data"].get("config-files")) and vnfc["boot-data"].get("user-data"): + raise NfvoException( + "Error at vnf:VNFC:boot-data, fields 'users' and 'config-files' are not compatible with 'user-data'", + HTTP_Bad_Request) + #check if the info in external_connections matches with the one in the vnfcs name_list=[] for external_connection in vnf_descriptor["vnf"].get("external-connections",() ): @@ -255,23 +266,26 @@ def check_vnf_descriptor(vnf_descriptor): HTTP_Bad_Request) return -HTTP_Bad_Request, -def create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=False, return_on_error = False): +def create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=False, return_on_error = None): #look if image exist if only_create_at_vim: image_mano_id = image_dict['uuid'] + if return_on_error == None: + return_on_error = True else: - if image_dict['location'] is not None: + if image_dict['location']: images = mydb.get_rows(FROM="images", WHERE={'location':image_dict['location'], 'metadata':image_dict['metadata']}) else: images = mydb.get_rows(FROM="images", WHERE={'universal_name':image_dict['universal_name'], 'checksum':image_dict['checksum']}) if len(images)>=1: image_mano_id = images[0]['uuid'] else: - #create image + #create image in MANO DB temp_image_dict={'name':image_dict['name'], 'description':image_dict.get('description',None), 'location':image_dict['location'], 'metadata':image_dict.get('metadata',None), 'universal_name':image_dict['universal_name'] , 'checksum':image_dict['checksum'] } + #temp_image_dict['location'] = image_dict.get('new_location') if image_dict['location'] is None image_mano_id = mydb.new_row('images', temp_image_dict, add_uuid=True) rollback_list.append({"where":"mano", "what":"image","uuid":image_mano_id}) #create image at every vim @@ -284,35 +298,45 @@ def create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vi if image_dict['location'] is not None: image_vim_id = vim.get_image_id_from_path(image_dict['location']) else: - filter_dict={} - filter_dict['name']=image_dict['universal_name'] - filter_dict['checksum']=image_dict['checksum'] + filter_dict = {} + filter_dict['name'] = image_dict['universal_name'] + if image_dict.get('checksum') != None: + filter_dict['checksum'] = image_dict['checksum'] #logger.debug('>>>>>>>> Filter dict: %s', str(filter_dict)) vim_images = vim.get_image_list(filter_dict) + #logger.debug('>>>>>>>> VIM images: %s', str(vim_images)) if len(vim_images) > 1: - raise NfvoException("More than one candidate VIM image found for filter: " + str(filter_dict), HTTP_Conflict) + raise vimconn.vimconnException("More than one candidate VIM image found for filter: {}".format(str(filter_dict)), HTTP_Conflict) elif len(vim_images) == 0: - raise NfvoException("Image not found at VIM with filter: '%s'", str(filter_dict)) + raise vimconn.vimconnNotFoundException("Image not found at VIM with filter: '{}'".format(str(filter_dict))) else: - image_vim_id = vim_images[0].id + #logger.debug('>>>>>>>> VIM image 0: %s', str(vim_images[0])) + image_vim_id = vim_images[0]['id'] except vimconn.vimconnNotFoundException as e: - #Create the image in VIM + #Create the image in VIM only if image_dict['location'] or image_dict['new_location'] is not None try: - image_vim_id = vim.new_image(image_dict) - rollback_list.append({"where":"vim", "vim_id": vim_id, "what":"image","uuid":image_vim_id}) - image_created="true" + #image_dict['location']=image_dict.get('new_location') if image_dict['location'] is None + if image_dict['location']: + image_vim_id = vim.new_image(image_dict) + rollback_list.append({"where":"vim", "vim_id": vim_id, "what":"image","uuid":image_vim_id}) + image_created="true" + else: + raise vimconn.vimconnException("Cannot create image without location") except vimconn.vimconnException as e: if return_on_error: - logger.error("Error creating image at VIM: %s", str(e)) + logger.error("Error creating image at VIM '%s': %s", vim["name"], str(e)) raise - image_vim_id = str(e) - logger.warn("Error creating image at VIM: %s", str(e)) + image_vim_id = None + logger.warn("Error creating image at VIM '%s': %s", vim["name"], str(e)) continue except vimconn.vimconnException as e: + if return_on_error: + logger.error("Error contacting VIM to know if the image exists at VIM: %s", str(e)) + raise logger.warn("Error contacting VIM to know if the image exists at VIM: %s", str(e)) - image_vim_id = str(e) - continue + image_vim_id = None + continue #if we reach here, the image has been created or existed if len(image_db)==0: #add new vim_id at datacenters_images @@ -323,7 +347,7 @@ def create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vi return image_vim_id if only_create_at_vim else image_mano_id -def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_vim=False, return_on_error = False): +def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_vim=False, return_on_error = None): temp_flavor_dict= {'disk':flavor_dict.get('disk',1), 'ram':flavor_dict.get('ram'), 'vcpus':flavor_dict.get('vcpus'), @@ -336,6 +360,8 @@ def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_ #look if flavor exist if only_create_at_vim: flavor_mano_id = flavor_dict['uuid'] + if return_on_error == None: + return_on_error = True else: flavors = mydb.get_rows(FROM="flavors", WHERE=temp_flavor_dict) if len(flavors)>=1: @@ -347,13 +373,14 @@ def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_ if 'extended' in flavor_dict and flavor_dict['extended']!=None: dev_nb=0 for device in flavor_dict['extended'].get('devices',[]): - if "image" not in device or "image name" not in device: + if "image" not in device and "image name" not in device: continue image_dict={} image_dict['name']=device.get('image name',flavor_dict['name']+str(dev_nb)+"-img") image_dict['universal_name']=device.get('image name') image_dict['description']=flavor_dict['name']+str(dev_nb)+"-img" image_dict['location']=device.get('image') + #image_dict['new_location']=vnfc.get('image location') image_dict['checksum']=device.get('image checksum') image_metadata_dict = device.get('image metadata', None) image_metadata_str = None @@ -386,9 +413,11 @@ def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_ #Create the flavor in VIM #Translate images at devices from MANO id to VIM id + disk_list = [] if 'extended' in flavor_dict and flavor_dict['extended']!=None and "devices" in flavor_dict['extended']: #make a copy of original devices devices_original=[] + for device in flavor_dict["extended"].get("devices",[]): dev={} dev.update(device) @@ -400,13 +429,16 @@ def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_ dev_nb=0 for index in range(0,len(devices_original)) : device=devices_original[index] - if "image" not in device or "image name" not in device: + if "image" not in device and "image name" not in device: + if 'size' in device: + disk_list.append({'size': device.get('size', default_volume_size)}) continue image_dict={} image_dict['name']=device.get('image name',flavor_dict['name']+str(dev_nb)+"-img") image_dict['universal_name']=device.get('image name') image_dict['description']=flavor_dict['name']+str(dev_nb)+"-img" image_dict['location']=device.get('image') + #image_dict['new_location']=device.get('image location') image_dict['checksum']=device.get('image checksum') image_metadata_dict = device.get('image metadata', None) image_metadata_str = None @@ -416,6 +448,10 @@ def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_ image_mano_id=create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=False, return_on_error=return_on_error ) image_dict["uuid"]=image_mano_id image_vim_id=create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=True, return_on_error=return_on_error) + + #save disk information (image must be based on and size + disk_list.append({'image_id': image_vim_id, 'size': device.get('size', default_volume_size)}) + flavor_dict["extended"]["devices"][index]['imageRef']=image_vim_id dev_nb += 1 if len(flavor_db)>0: @@ -437,11 +473,19 @@ def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_ logger.error("Error creating flavor at VIM %s: %s.", vim["name"], str(e)) raise logger.warn("Error creating flavor at VIM %s: %s.", vim["name"], str(e)) + flavor_vim_id = None continue #if reach here the flavor has been create or exist if len(flavor_db)==0: #add new vim_id at datacenters_flavors - mydb.new_row('datacenters_flavors', {'datacenter_id':vim_id, 'flavor_id':flavor_mano_id, 'vim_id': flavor_vim_id, 'created':flavor_created}) + extended_devices_yaml = None + if len(disk_list) > 0: + extended_devices = dict() + extended_devices['disks'] = disk_list + extended_devices_yaml = yaml.safe_dump(extended_devices,default_flow_style=True,width=256) + mydb.new_row('datacenters_flavors', + {'datacenter_id':vim_id, 'flavor_id':flavor_mano_id, 'vim_id': flavor_vim_id, + 'created':flavor_created,'extended': extended_devices_yaml}) elif flavor_db[0]["vim_id"]!=flavor_vim_id: #modify existing vim_id at datacenters_flavors mydb.update_rows('datacenters_flavors', UPDATE={'vim_id':flavor_vim_id}, WHERE={'datacenter_id':vim_id, 'flavor_id':flavor_mano_id}) @@ -556,6 +600,7 @@ def new_vnf(mydb, tenant_id, vnf_descriptor): image_dict['universal_name']=vnfc.get('image name') image_dict['description']=vnfc.get('image name', VNFCDict[vnfc['name']]['description']) image_dict['location']=vnfc.get('VNFC image') + #image_dict['new_location']=vnfc.get('image location') image_dict['checksum']=vnfc.get('image checksum') image_metadata_dict = vnfc.get('image metadata', None) image_metadata_str = None @@ -567,6 +612,8 @@ def new_vnf(mydb, tenant_id, vnf_descriptor): #print "Image id for VNFC %s: %s" % (vnfc['name'],image_id) VNFCDict[vnfc['name']]["image_id"] = image_id VNFCDict[vnfc['name']]["image_path"] = vnfc.get('VNFC image') + if vnfc.get("boot-data"): + VNFCDict[vnfc['name']]["boot_data"] = yaml.safe_dump(vnfc["boot-data"], default_flow_style=True, width=256) # Step 7. Storing the VNF descriptor in the repository @@ -694,6 +741,7 @@ def new_vnf_v02(mydb, tenant_id, vnf_descriptor): image_dict['universal_name']=vnfc.get('image name') image_dict['description']=vnfc.get('image name', VNFCDict[vnfc['name']]['description']) image_dict['location']=vnfc.get('VNFC image') + #image_dict['new_location']=vnfc.get('image location') image_dict['checksum']=vnfc.get('image checksum') image_metadata_dict = vnfc.get('image metadata', None) image_metadata_str = None @@ -705,8 +753,9 @@ def new_vnf_v02(mydb, tenant_id, vnf_descriptor): #print "Image id for VNFC %s: %s" % (vnfc['name'],image_id) VNFCDict[vnfc['name']]["image_id"] = image_id VNFCDict[vnfc['name']]["image_path"] = vnfc.get('VNFC image') + if vnfc.get("boot-data"): + VNFCDict[vnfc['name']]["boot_data"] = yaml.safe_dump(vnfc["boot-data"], default_flow_style=True, width=256) - # Step 7. Storing the VNF descriptor in the repository if "descriptor" not in vnf_descriptor["vnf"]: vnf_descriptor["vnf"]["descriptor"] = yaml.safe_dump(vnf_descriptor, indent=4, explicit_start=True, default_flow_style=False) @@ -744,10 +793,15 @@ def get_vnf_id(mydb, tenant_id, vnf_id): data={'vnf' : filtered_content} #GET VM content = mydb.get_rows(FROM='vnfs join vms on vnfs.uuid=vms.vnf_id', - SELECT=('vms.uuid as uuid','vms.name as name', 'vms.description as description'), + SELECT=('vms.uuid as uuid','vms.name as name', 'vms.description as description', 'boot_data'), WHERE={'vnfs.uuid': vnf_id} ) if len(content)==0: raise NfvoException("vnf '{}' not found".format(vnf_id), HTTP_Not_Found) + # change boot_data into boot-data + for vm in content: + if vm.get("boot_data"): + vm["boot-data"] = yaml.safe_load(vm["boot_data"]) + del vm["boot_data"] data['vnf']['VNFC'] = content #TODO: GET all the information from a VNFC and include it in the output. @@ -1395,7 +1449,7 @@ def start_scenario(mydb, tenant_id, scenario_id, instance_scenario_name, instanc i += 1 myVMDict = {} #myVMDict['name'] = "%s-%s-%s" % (scenarioDict['name'],sce_vnf['name'], vm['name']) - myVMDict['name'] = "%s.%s.%d" % (instance_scenario_name,sce_vnf['name'],i) + myVMDict['name'] = "{}.{}.{}".format(instance_scenario_name,sce_vnf['name'],chr(96+i)) #myVMDict['description'] = vm['description'] myVMDict['description'] = myVMDict['name'][0:99] if not startvms: @@ -1454,6 +1508,10 @@ def start_scenario(mydb, tenant_id, scenario_id, instance_scenario_name, instanc netDict['vpci'] = iface['vpci'] if "mac" in iface and iface["mac"] is not None: netDict['mac_address'] = iface['mac'] + if "port-security" in iface and iface["port-security"] is not None: + netDict['port_security'] = iface['port-security'] + if "floating-ip" in iface and iface["floating-ip"] is not None: + netDict['floating_ip'] = iface['floating-ip'] netDict['name'] = iface['internal_name'] if iface['net_id'] is None: for vnf_iface in sce_vnf["interfaces"]: @@ -1502,9 +1560,34 @@ def start_scenario(mydb, tenant_id, scenario_id, instance_scenario_name, instanc #logger.error("start_scenario %s", error_text) raise NfvoException(error_text, e.http_code) -def unify_cloud_config(cloud_config): +def unify_cloud_config(cloud_config_preserve, cloud_config): + ''' join the cloud config information into cloud_config_preserve. + In case of conflict cloud_config_preserve preserves + None is admited + ''' + if not cloud_config_preserve and not cloud_config: + return None + + new_cloud_config = {"key-pairs":[], "users":[]} + # key-pairs + if cloud_config_preserve: + for key in cloud_config_preserve.get("key-pairs", () ): + if key not in new_cloud_config["key-pairs"]: + new_cloud_config["key-pairs"].append(key) + if cloud_config: + for key in cloud_config.get("key-pairs", () ): + if key not in new_cloud_config["key-pairs"]: + new_cloud_config["key-pairs"].append(key) + if not new_cloud_config["key-pairs"]: + del new_cloud_config["key-pairs"] + + # users + if cloud_config: + new_cloud_config["users"] += cloud_config.get("users", () ) + if cloud_config_preserve: + new_cloud_config["users"] += cloud_config_preserve.get("users", () ) index_to_delete = [] - users = cloud_config.get("users", []) + users = new_cloud_config.get("users", []) for index0 in range(0,len(users)): if index0 in index_to_delete: continue @@ -1514,13 +1597,45 @@ def unify_cloud_config(cloud_config): if users[index0]["name"] == users[index1]["name"]: index_to_delete.append(index1) for key in users[index1].get("key-pairs",()): - if "key-pairs" not in users[index0]: + if "key-pairs" not in users[index0]: users[index0]["key-pairs"] = [key] elif key not in users[index0]["key-pairs"]: users[index0]["key-pairs"].append(key) index_to_delete.sort(reverse=True) for index in index_to_delete: del users[index] + if not new_cloud_config["users"]: + del new_cloud_config["users"] + + #boot-data-drive + if cloud_config and cloud_config.get("boot-data-drive") != None: + new_cloud_config["boot-data-drive"] = cloud_config["boot-data-drive"] + if cloud_config_preserve and cloud_config_preserve.get("boot-data-drive") != None: + new_cloud_config["boot-data-drive"] = cloud_config_preserve["boot-data-drive"] + + # user-data + if cloud_config and cloud_config.get("user-data") != None: + new_cloud_config["user-data"] = cloud_config["user-data"] + if cloud_config_preserve and cloud_config_preserve.get("user-data") != None: + new_cloud_config["user-data"] = cloud_config_preserve["user-data"] + + # config files + new_cloud_config["config-files"] = [] + if cloud_config and cloud_config.get("config-files") != None: + new_cloud_config["config-files"] += cloud_config["config-files"] + if cloud_config_preserve: + for file in cloud_config_preserve.get("config-files", ()): + for index in range(0, len(new_cloud_config["config-files"])): + if new_cloud_config["config-files"][index]["dest"] == file["dest"]: + new_cloud_config["config-files"][index] = file + break + else: + new_cloud_config["config-files"].append(file) + if not new_cloud_config["config-files"]: + del new_cloud_config["config-files"] + return new_cloud_config + + def get_datacenter_by_name_uuid(mydb, tenant_id, datacenter_id_name=None, **extra_filter): datacenter_id = None @@ -1734,15 +1849,9 @@ def create_instance(mydb, tenant_id, instance_dict): myvims[d] = v datacenter2tenant[d] = v['config']['datacenter_tenant_id'] scenario_vnf["datacenter"] = vnf_instance_desc["datacenter"] + #0.1 parse cloud-config parameters - cloud_config = scenarioDict.get("cloud-config", {}) - if instance_dict.get("cloud-config"): - cloud_config.update( instance_dict["cloud-config"]) - if not cloud_config: - cloud_config = None - else: - scenarioDict["cloud-config"] = cloud_config - unify_cloud_config(cloud_config) + cloud_config = unify_cloud_config(instance_dict.get("cloud-config"), scenarioDict.get("cloud-config")) #0.2 merge instance information into scenario #Ideally, the operation should be as simple as: update(scenarioDict,instance_dict) @@ -1897,21 +2006,42 @@ def create_instance(mydb, tenant_id, instance_dict): for vm in sce_vnf['vms']: i += 1 myVMDict = {} - myVMDict['name'] = "%s.%s.%d" % (instance_name,sce_vnf['name'],i) + myVMDict['name'] = "{}.{}.{}".format(instance_name,sce_vnf['name'],chr(96+i)) myVMDict['description'] = myVMDict['name'][0:99] # if not startvms: # myVMDict['start'] = "no" myVMDict['name'] = myVMDict['name'][0:255] #limit name length #create image at vim in case it not exist image_dict = mydb.get_table_by_uuid_name("images", vm['image_id']) - image_id = create_or_use_image(mydb, {datacenter_id: vim}, image_dict, [], True) + image_id = create_or_use_image(mydb, {datacenter_id: vim}, image_dict, [], True) vm['vim_image_id'] = image_id #create flavor at vim in case it not exist flavor_dict = mydb.get_table_by_uuid_name("flavors", vm['flavor_id']) if flavor_dict['extended']!=None: flavor_dict['extended']= yaml.load(flavor_dict['extended']) - flavor_id = create_or_use_flavor(mydb, {datacenter_id: vim}, flavor_dict, rollbackList, True) + flavor_id = create_or_use_flavor(mydb, {datacenter_id: vim}, flavor_dict, rollbackList, True) + + + + + #Obtain information for additional disks + extended_flavor_dict = mydb.get_rows(FROM='datacenters_flavors', SELECT=('extended',), WHERE={'vim_id': flavor_id}) + if not extended_flavor_dict: + raise NfvoException("flavor '{}' not found".format(flavor_id), HTTP_Not_Found) + return + + #extended_flavor_dict_yaml = yaml.load(extended_flavor_dict[0]) + myVMDict['disks'] = None + extended_info = extended_flavor_dict[0]['extended'] + if extended_info != None: + extended_flavor_dict_yaml = yaml.load(extended_info) + if 'disks' in extended_flavor_dict_yaml: + myVMDict['disks'] = extended_flavor_dict_yaml['disks'] + + + + vm['vim_flavor_id'] = flavor_id myVMDict['imageRef'] = vm['vim_image_id'] @@ -1953,6 +2083,10 @@ def create_instance(mydb, tenant_id, instance_dict): netDict['vpci'] = iface['vpci'] if "mac" in iface and iface["mac"] is not None: netDict['mac_address'] = iface['mac'] + if "port-security" in iface and iface["port-security"] is not None: + netDict['port_security'] = iface['port-security'] + if "floating-ip" in iface and iface["floating-ip"] is not None: + netDict['floating_ip'] = iface['floating-ip'] netDict['name'] = iface['internal_name'] if iface['net_id'] is None: for vnf_iface in sce_vnf["interfaces"]: @@ -1972,8 +2106,14 @@ def create_instance(mydb, tenant_id, instance_dict): #print "networks", yaml.safe_dump(myVMDict['networks'], indent=4, default_flow_style=False) #print "interfaces", yaml.safe_dump(vm['interfaces'], indent=4, default_flow_style=False) #print ">>>>>>>>>>>>>>>>>>>>>>>>>>>" + if vm.get("boot_data"): + cloud_config_vm = unify_cloud_config(vm["boot_data"], cloud_config) + else: + cloud_config_vm = cloud_config vm_id = vim.new_vminstance(myVMDict['name'],myVMDict['description'],myVMDict.get('start', None), - myVMDict['imageRef'],myVMDict['flavorRef'],myVMDict['networks'], cloud_config = cloud_config) + myVMDict['imageRef'],myVMDict['flavorRef'],myVMDict['networks'], cloud_config = cloud_config_vm, + disk_list = myVMDict['disks']) + vm['vim_id'] = vm_id rollbackList.append({'what':'vm','where':'vim','vim_id':datacenter_id,'uuid':vm_id}) #put interface uuid back to scenario[vnfs][vms[[interfaces] @@ -2161,6 +2301,8 @@ def refresh_instance(mydb, nfvo_tenant, instanceDict, datacenter=None, vim_tenan has_mgmt_iface = True if vm_dict[vm_id]['status'] == "ACTIVE:NoMgmtIP" and not has_mgmt_iface: vm_dict[vm_id]['status'] = "ACTIVE" + if vm_dict[vm_id].get('error_msg') and len(vm_dict[vm_id]['error_msg']) >= 1024: + vm_dict[vm_id]['error_msg'] = vm_dict[vm_id]['error_msg'][:516] + " ... " + vm_dict[vm_id]['error_msg'][-500:] if vm['status'] != vm_dict[vm_id]['status'] or vm.get('error_msg')!=vm_dict[vm_id].get('error_msg') or vm.get('vim_info')!=vm_dict[vm_id].get('vim_info'): vm['status'] = vm_dict[vm_id]['status'] vm['error_msg'] = vm_dict[vm_id].get('error_msg') @@ -2213,6 +2355,8 @@ def refresh_instance(mydb, nfvo_tenant, instanceDict, datacenter=None, vim_tenan # TODO: update nets inside a vnf for net in instanceDict['nets']: net_id = net['vim_net_id'] + if net_dict[net_id].get('error_msg') and len(net_dict[net_id]['error_msg']) >= 1024: + net_dict[net_id]['error_msg'] = net_dict[net_id]['error_msg'][:516] + " ... " + net_dict[vm_id]['error_msg'][-500:] if net['status'] != net_dict[net_id]['status'] or net.get('error_msg')!=net_dict[net_id].get('error_msg') or net.get('vim_info')!=net_dict[net_id].get('vim_info'): net['status'] = net_dict[net_id]['status'] net['error_msg'] = net_dict[net_id].get('error_msg') @@ -2401,7 +2545,7 @@ def delete_datacenter(mydb, datacenter): mydb.delete_row_by_id("datacenters", datacenter_dict['uuid']) return datacenter_dict['uuid'] + " " + datacenter_dict['name'] -def associate_datacenter_to_tenant(mydb, nfvo_tenant, datacenter, vim_tenant_id=None, vim_tenant_name=None, vim_username=None, vim_password=None): +def associate_datacenter_to_tenant(mydb, nfvo_tenant, datacenter, vim_tenant_id=None, vim_tenant_name=None, vim_username=None, vim_password=None, config=None): #get datacenter info datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, None, datacenter) datacenter_name=myvim["name"] @@ -2451,6 +2595,8 @@ def associate_datacenter_to_tenant(mydb, nfvo_tenant, datacenter, vim_tenant_id= datacenter_tenants_dict["user"] = vim_username datacenter_tenants_dict["passwd"] = vim_password datacenter_tenants_dict["datacenter_id"] = datacenter_id + if config: + datacenter_tenants_dict["config"] = yaml.safe_dump(config, default_flow_style=True, width=256) id_ = mydb.new_row('datacenter_tenants', datacenter_tenants_dict, add_uuid=True) datacenter_tenants_dict["uuid"] = id_ @@ -2613,6 +2759,8 @@ def vim_action_get(mydb, tenant_id, datacenter, item, name): content = myvim.get_network_list(filter_dict=filter_dict) elif item=="tenants": content = myvim.get_tenant_list(filter_dict=filter_dict) + elif item == "images": + content = myvim.get_image_list(filter_dict=filter_dict) else: raise NfvoException(item + "?", HTTP_Method_Not_Allowed) logger.debug("vim_action response %s", content) #update nets Change from VIM format to NFVO format @@ -2650,6 +2798,8 @@ def vim_action_delete(mydb, tenant_id, datacenter, item, name): content = myvim.delete_network(item_id) elif item=="tenants": content = myvim.delete_tenant(item_id) + elif item == "images": + content = myvim.delete_image(item_id) else: raise NfvoException(item + "?", HTTP_Method_Not_Allowed) except vimconn.vimconnException as e: