X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=nfvo.py;h=e8032064266026f8affce1445b97191e6375512d;hb=1f3a67138592443a8bd68ab936e071cb5bccda55;hp=13d5c9e2cbd31f28d7230555074c713caf90e448;hpb=688b255f3dbde6b78593d0778fb81497341d04f4;p=osm%2FRO.git diff --git a/nfvo.py b/nfvo.py index 13d5c9e2..e8032064 100644 --- a/nfvo.py +++ b/nfvo.py @@ -36,14 +36,16 @@ from db_base import HTTP_Unauthorized, HTTP_Bad_Request, HTTP_Internal_Server_Er import console_proxy_thread as cli import vimconn import logging +import collections from db_base import db_base_Exception global global_config global vimconn_imported +global logger vimconn_imported={} #dictionary with VIM type as key, loaded module as value -logger = logging.getLogger('mano.nfvo') +logger = logging.getLogger('openmano.nfvo') class NfvoException(Exception): def __init__(self, message, http_code): @@ -90,12 +92,11 @@ def get_imagelist(mydb, vnf_id, nfvo_tenant=None): imageList.append(image['image_id']) return imageList -def get_vim(mydb, nfvo_tenant=None, datacenter_id=None, datacenter_name=None, vim_tenant=None): +def get_vim(mydb, nfvo_tenant=None, datacenter_id=None, datacenter_name=None, vim_tenant=None, vim_tenant_name=None, vim_user=None, vim_passwd=None): '''Obtain a dictionary of VIM (datacenter) classes with some of the input parameters - return result, content: - <0, error_text upon error - NUMBER, dictionary with datacenter_id: vim_class with these keys: + return dictionary with {datacenter_id: vim_class, ... }. vim_class contain: 'nfvo_tenant_id','datacenter_id','vim_tenant_id','vim_url','vim_url_admin','datacenter_name','type','user','passwd' + raise exception upon error ''' WHERE_dict={} if nfvo_tenant is not None: WHERE_dict['nfvo_tenant_id'] = nfvo_tenant @@ -135,9 +136,9 @@ def get_vim(mydb, nfvo_tenant=None, datacenter_id=None, datacenter_name=None, vi # return -HTTP_Bad_Request, "You must provide a valid tenant name or uuid for VIM %s" % ( vim["type"]) vim_dict[ vim['datacenter_id'] ] = vimconn_imported[ vim["type"] ].vimconnector( uuid=vim['datacenter_id'], name=vim['datacenter_name'], - tenant_id=vim.get('vim_tenant_id'), tenant_name=vim.get('vim_tenant_name'), + tenant_id=vim.get('vim_tenant_id',vim_tenant), tenant_name=vim.get('vim_tenant_name',vim_tenant_name), url=vim['vim_url'], url_admin=vim['vim_url_admin'], - user=vim.get('user'), passwd=vim.get('passwd'), + user=vim.get('user',vim_user), passwd=vim.get('passwd',vim_passwd), config=extra ) except Exception as e: @@ -161,7 +162,7 @@ def rollback(mydb, vims, rollback_list): mydb.delete_row(FROM="datacenters_images", WHERE={"datacenter_id": vim["id"], "vim_id":item["uuid"]}) elif item["what"]=="flavor": vim.delete_flavor(item["uuid"]) - mydb.delete_row(FROM="datacenters_flavos", WHERE={"datacenter_id": vim["id"], "vim_id":item["uuid"]}) + mydb.delete_row(FROM="datacenters_flavors", WHERE={"datacenter_id": vim["id"], "vim_id":item["uuid"]}) elif item["what"]=="network": vim.delete_network(item["uuid"]) elif item["what"]=="vm": @@ -256,13 +257,17 @@ def create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vi if only_create_at_vim: image_mano_id = image_dict['uuid'] else: - images = mydb.get_rows(FROM="images", WHERE={'location':image_dict['location'], 'metadata':image_dict['metadata']}) + if image_dict['location'] is not None: + 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 temp_image_dict={'name':image_dict['name'], 'description':image_dict.get('description',None), - 'location':image_dict['location'], 'metadata':image_dict.get('metadata',None) + 'location':image_dict['location'], 'metadata':image_dict.get('metadata',None), + 'universal_name':image_dict['universal_name'] , 'checksum':image_dict['checksum'] } image_mano_id = mydb.new_row('images', temp_image_dict, add_uuid=True) rollback_list.append({"where":"mano", "what":"image","uuid":image_mano_id}) @@ -273,7 +278,21 @@ def create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vi image_db = mydb.get_rows(FROM="datacenters_images", WHERE={'datacenter_id':vim_id, 'image_id':image_mano_id}) #look at VIM if this image exist try: - image_vim_id = vim.get_image_id_from_path(image_dict['location']) + 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'] + #logger.debug('>>>>>>>> Filter dict: %s', str(filter_dict)) + vim_images = vim.get_image_list(filter_dict) + if len(vim_images) > 1: + raise NfvoException("More than one candidate VIM image found for filter: " + str(filter_dict), HTTP_Conflict) + elif len(vim_images) == 0: + raise NfvoException("Image not found at VIM with filter: '%s'", str(filter_dict)) + else: + image_vim_id = vim_images[0].id + except vimconn.vimconnNotFoundException as e: #Create the image in VIM try: @@ -288,10 +307,10 @@ def create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vi logger.warn("Error creating image at VIM: %s", str(e)) continue except vimconn.vimconnException as e: - logger.warn("Error contacting VIM to know if the image exist at VIM: %s", str(e)) + logger.warn("Error contacting VIM to know if the image exists at VIM: %s", str(e)) image_vim_id = str(e) continue - #if reach here the image has been create or exist + #if we reach here, the image has been created or existed if len(image_db)==0: #add new vim_id at datacenters_images mydb.new_row('datacenters_images', {'datacenter_id':vim_id, 'image_id':image_mano_id, 'vim_id': image_vim_id, 'created':image_created}) @@ -325,9 +344,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: + if "image" not in device or "image name" not in device: continue - image_dict={'location':device['image'], 'name':flavor_dict['name']+str(dev_nb)+"-img", 'description':flavor_dict.get('description')} + 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['checksum']=device.get('image checksum') image_metadata_dict = device.get('image metadata', None) image_metadata_str = None if image_metadata_dict != None: @@ -373,9 +397,14 @@ 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: + if "image" not in device or "image name" not in device: continue - image_dict={'location':device['image'], 'name':flavor_dict['name']+str(dev_nb)+"-img", 'description':flavor_dict.get('description')} + 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['checksum']=device.get('image checksum') image_metadata_dict = device.get('image metadata', None) image_metadata_str = None if image_metadata_dict != None: @@ -471,7 +500,7 @@ def new_vnf(mydb, tenant_id, vnf_descriptor): #print "Flavor name: %s. Description: %s" % (VNFCitem["name"]+"-flv", VNFCitem["description"]) myflavorDict = {} - myflavorDict["name"] = vnfc['name']+"-flv" + myflavorDict["name"] = vnfc['name']+"-flv" #Maybe we could rename the flavor by using the field "image name" if exists myflavorDict["description"] = VNFCitem["description"] myflavorDict["ram"] = vnfc.get("ram", 0) myflavorDict["vcpus"] = vnfc.get("vcpus", 0) @@ -519,7 +548,12 @@ def new_vnf(mydb, tenant_id, vnf_descriptor): #In case this integration is made, the VNFCDict might become a VNFClist. for vnfc in vnf_descriptor['vnf']['VNFC']: #print "Image name: %s. Description: %s" % (vnfc['name']+"-img", VNFCDict[vnfc['name']]['description']) - image_dict={'location':vnfc['VNFC image'], 'name':vnfc['name']+"-img", 'description':VNFCDict[vnfc['name']]['description']} + image_dict={} + image_dict['name']=vnfc.get('image name',vnf_name+"-"+vnfc['name']+"-img") + 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['checksum']=vnfc.get('image checksum') image_metadata_dict = vnfc.get('image metadata', None) image_metadata_str = None if image_metadata_dict is not None: @@ -529,7 +563,7 @@ def new_vnf(mydb, tenant_id, vnf_descriptor): image_id = create_or_use_image(mydb, vims, image_dict, rollback_list) #print "Image id for VNFC %s: %s" % (vnfc['name'],image_id) VNFCDict[vnfc['name']]["image_id"] = image_id - VNFCDict[vnfc['name']]["image_path"] = vnfc['VNFC image'] + VNFCDict[vnfc['name']]["image_path"] = vnfc.get('VNFC image') # Step 7. Storing the VNF descriptor in the repository @@ -552,6 +586,144 @@ def new_vnf(mydb, tenant_id, vnf_descriptor): #logger.error("start_scenario %s", error_text) raise NfvoException(error_text, e.http_code) +def new_vnf_v02(mydb, tenant_id, vnf_descriptor): + global global_config + + # Step 1. Check the VNF descriptor + check_vnf_descriptor(vnf_descriptor) + # Step 2. Check tenant exist + if tenant_id != "any": + check_tenant(mydb, tenant_id) + if "tenant_id" in vnf_descriptor["vnf"]: + if vnf_descriptor["vnf"]["tenant_id"] != tenant_id: + raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format(vnf_descriptor["vnf"]["tenant_id"], tenant_id), + HTTP_Unauthorized) + else: + vnf_descriptor['vnf']['tenant_id'] = tenant_id + # Step 3. Get the URL of the VIM from the nfvo_tenant and the datacenter + vims = get_vim(mydb, tenant_id) + else: + vims={} + + # Step 4. Review the descriptor and add missing fields + #print vnf_descriptor + #logger.debug("Refactoring VNF descriptor with fields: description, public (default: true)") + vnf_name = vnf_descriptor['vnf']['name'] + vnf_descriptor['vnf']['description'] = vnf_descriptor['vnf'].get("description", vnf_name) + if "physical" in vnf_descriptor['vnf']: + del vnf_descriptor['vnf']['physical'] + #print vnf_descriptor + # Step 5. Check internal connections + # TODO: to be moved to step 1???? + internal_connections=vnf_descriptor['vnf'].get('internal_connections',[]) + for ic in internal_connections: + if len(ic['elements'])>2 and ic['type']=='e-line': + raise NfvoException("Mismatch 'type':'e-line' with {} elements at 'vnf':'internal-conections'['name':'{}']. Change 'type' to 'e-lan'".format(len(ic), ic['name']), + HTTP_Bad_Request) + + # Step 6. For each VNFC in the descriptor, flavors and images are created in the VIM + logger.debug('BEGIN creation of VNF "%s"' % vnf_name) + logger.debug("VNF %s: consisting of %d VNFC(s)" % (vnf_name,len(vnf_descriptor['vnf']['VNFC']))) + + #For each VNFC, we add it to the VNFCDict and we create a flavor. + VNFCDict = {} # Dictionary, key: VNFC name, value: dict with the relevant information to create the VNF and VMs in the MANO database + rollback_list = [] # It will contain the new images created in mano. It is used for rollback + try: + logger.debug("Creating additional disk images and new flavors in the VIM for each VNFC") + for vnfc in vnf_descriptor['vnf']['VNFC']: + VNFCitem={} + VNFCitem["name"] = vnfc['name'] + VNFCitem["description"] = vnfc.get("description", 'VM %s of the VNF %s' %(vnfc['name'],vnf_name)) + + #print "Flavor name: %s. Description: %s" % (VNFCitem["name"]+"-flv", VNFCitem["description"]) + + myflavorDict = {} + myflavorDict["name"] = vnfc['name']+"-flv" #Maybe we could rename the flavor by using the field "image name" if exists + myflavorDict["description"] = VNFCitem["description"] + myflavorDict["ram"] = vnfc.get("ram", 0) + myflavorDict["vcpus"] = vnfc.get("vcpus", 0) + myflavorDict["disk"] = vnfc.get("disk", 1) + myflavorDict["extended"] = {} + + devices = vnfc.get("devices") + if devices != None: + myflavorDict["extended"]["devices"] = devices + + # TODO: + # Mapping from processor models to rankings should be available somehow in the NFVO. They could be taken from VIM or directly from a new database table + # Another option is that the processor in the VNF descriptor specifies directly the ranking of the host + + # Previous code has been commented + #if vnfc['processor']['model'] == "Intel(R) Xeon(R) CPU E5-4620 0 @ 2.20GHz" : + # myflavorDict["flavor"]['extended']['processor_ranking'] = 200 + #elif vnfc['processor']['model'] == "Intel(R) Xeon(R) CPU E5-2697 v2 @ 2.70GHz" : + # myflavorDict["flavor"]['extended']['processor_ranking'] = 300 + #else: + # result2, message = rollback(myvim, myvimURL, myvim_tenant, flavorList, imageList) + # if result2: + # print "Error creating flavor: unknown processor model. Rollback successful." + # return -HTTP_Bad_Request, "Error creating flavor: unknown processor model. Rollback successful." + # else: + # return -HTTP_Bad_Request, "Error creating flavor: unknown processor model. Rollback fail: you need to access VIM and delete the following %s" % message + myflavorDict['extended']['processor_ranking'] = 100 #Hardcoded value, while we decide when the mapping is done + + if 'numas' in vnfc and len(vnfc['numas'])>0: + myflavorDict['extended']['numas'] = vnfc['numas'] + + #print myflavorDict + + # Step 6.2 New flavors are created in the VIM + flavor_id = create_or_use_flavor(mydb, vims, myflavorDict, rollback_list) + + #print "Flavor id for VNFC %s: %s" % (vnfc['name'],flavor_id) + VNFCitem["flavor_id"] = flavor_id + VNFCDict[vnfc['name']] = VNFCitem + + logger.debug("Creating new images in the VIM for each VNFC") + # Step 6.3 New images are created in the VIM + #For each VNFC, we must create the appropriate image. + #This "for" loop might be integrated with the previous one + #In case this integration is made, the VNFCDict might become a VNFClist. + for vnfc in vnf_descriptor['vnf']['VNFC']: + #print "Image name: %s. Description: %s" % (vnfc['name']+"-img", VNFCDict[vnfc['name']]['description']) + image_dict={} + image_dict['name']=vnfc.get('image name',vnf_name+"-"+vnfc['name']+"-img") + 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['checksum']=vnfc.get('image checksum') + image_metadata_dict = vnfc.get('image metadata', None) + image_metadata_str = None + if image_metadata_dict is not None: + image_metadata_str = yaml.safe_dump(image_metadata_dict,default_flow_style=True,width=256) + image_dict['metadata']=image_metadata_str + #print "create_or_use_image", mydb, vims, image_dict, rollback_list + image_id = create_or_use_image(mydb, vims, image_dict, rollback_list) + #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') + + + # 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) + + # Step 8. Adding the VNF to the NFVO DB + vnf_id = mydb.new_vnf_as_a_whole2(tenant_id,vnf_name,vnf_descriptor,VNFCDict) + return vnf_id + except (db_base_Exception, vimconn.vimconnException, KeyError) as e: + _, message = rollback(mydb, vims, rollback_list) + if isinstance(e, db_base_Exception): + error_text = "Exception at database" + elif isinstance(e, KeyError): + error_text = "KeyError exception " + e.http_code = HTTP_Internal_Server_Error + else: + error_text = "Exception at VIM" + error_text += " {} {}. {}".format(type(e).__name__, str(e), message) + #logger.error("start_scenario %s", error_text) + raise NfvoException(error_text, e.http_code) + def get_vnf_id(mydb, tenant_id, vnf_id): #check valid tenant_id check_tenant(mydb, tenant_id) @@ -575,12 +747,28 @@ def get_vnf_id(mydb, tenant_id, vnf_id): raise NfvoException("vnf '{}' not found".format(vnf_id), HTTP_Not_Found) data['vnf']['VNFC'] = content + #TODO: GET all the information from a VNFC and include it in the output. + #GET NET content = mydb.get_rows(FROM='vnfs join nets on vnfs.uuid=nets.vnf_id', SELECT=('nets.uuid as uuid','nets.name as name','nets.description as description', 'nets.type as type', 'nets.multipoint as multipoint'), WHERE={'vnfs.uuid': vnf_id} ) data['vnf']['nets'] = content - #GET Interfaces + + #GET ip-profile for each net + for net in data['vnf']['nets']: + ipprofiles = mydb.get_rows(FROM='ip_profiles', + SELECT=('ip_version','subnet_address','gateway_address','dns_address','dhcp_enabled','dhcp_start_address','dhcp_count'), + WHERE={'net_id': net["uuid"]} ) + if len(ipprofiles)==1: + net["ip_profile"] = ipprofiles[0] + elif len(ipprofiles)>1: + raise NfvoException("More than one ip-profile found with this criteria: net_id='{}'".format(net['uuid']), HTTP_Bad_Request) + + + #TODO: For each net, GET its elements and relevant info per element (VNFC, iface, ip_address) and include them in the output. + + #GET External Interfaces content = mydb.get_rows(FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces on vms.uuid=interfaces.vm_id',\ SELECT=('interfaces.uuid as uuid','interfaces.external_name as external_name', 'vms.name as vm_name', 'interfaces.vm_id as vm_id', \ 'interfaces.internal_name as internal_name', 'interfaces.type as type', 'interfaces.vpci as vpci','interfaces.bw as bw'),\ @@ -588,6 +776,7 @@ def get_vnf_id(mydb, tenant_id, vnf_id): WHERE_NOT={'interfaces.external_name': None} ) #print content data['vnf']['external-connections'] = content + return data @@ -768,19 +957,24 @@ def new_scenario(mydb, tenant_id, topo): #1.2: Check that VNF are present at database table vnfs. Insert uuid, description and external interfaces for name,vnf in vnfs.items(): - WHERE_={} + where={} + where_or={"tenant_id": tenant_id, 'public': "true"} error_text = "" error_pos = "'topology':'nodes':'" + name + "'" if 'vnf_id' in vnf: error_text += " 'vnf_id' " + vnf['vnf_id'] - WHERE_['uuid'] = vnf['vnf_id'] + where['uuid'] = vnf['vnf_id'] if 'VNF model' in vnf: error_text += " 'VNF model' " + vnf['VNF model'] - WHERE_['name'] = vnf['VNF model'] - if len(WHERE_) == 0: + where['name'] = vnf['VNF model'] + if len(where) == 0: raise NfvoException("Descriptor need a 'vnf_id' or 'VNF model' field at " + error_pos, HTTP_Bad_Request) - vnf_db = mydb.get_rows(SELECT=('uuid','name','description'), FROM='vnfs', WHERE=WHERE_) + vnf_db = mydb.get_rows(SELECT=('uuid','name','description'), + FROM='vnfs', + WHERE=where, + WHERE_OR=where_or, + WHERE_AND_OR="AND") if len(vnf_db)==0: raise NfvoException("unknown" + error_text + " at " + error_pos, HTTP_Not_Found) elif len(vnf_db)>1: @@ -797,6 +991,7 @@ def new_scenario(mydb, tenant_id, topo): #1.4 get list of connections conections = topo['topology']['connections'] conections_list = [] + conections_list_name = [] for k in conections.keys(): if type(conections[k]['nodes'])==dict: #dict with node:iface pairs ifaces_list = conections[k]['nodes'].items() @@ -825,7 +1020,7 @@ def new_scenario(mydb, tenant_id, topo): if con_type == "dataplane_net" or con_type == "bridge_net": other_nets[k]["model"] = con_type - + conections_list_name.append(k) conections_list.append(set(ifaces_list)) #from list to set to operate as a set (this conversion removes elements that are repeated in a list) #print set(ifaces_list) #check valid VNF and iface names @@ -845,6 +1040,7 @@ def new_scenario(mydb, tenant_id, topo): if len(conections_list[index] & conections_list[index2])>0: #common interface, join nets conections_list[index] |= conections_list[index2] del conections_list[index2] + del conections_list_name[index2] else: index2 += 1 conections_list[index] = list(conections_list[index]) # from set to list again @@ -951,7 +1147,8 @@ def new_scenario(mydb, tenant_id, topo): net_type_bridge=False net_type_data=False net_target = "__-__net"+str(net_nb) - net_list[net_target] = {'name': "net-"+str(net_nb), 'description':"net-%s in scenario %s" %(net_nb,topo['name']), + net_list[net_target] = {'name': conections_list_name[net_nb], #"net-"+str(net_nb), + 'description':"net-%s in scenario %s" %(net_nb,topo['name']), 'external':False} for iface in con: vnfs[ iface[0] ]['ifaces'][ iface[1] ]['net_key'] = net_target @@ -1024,18 +1221,23 @@ def new_scenario_v02(mydb, tenant_id, scenario_dict): #1: Check that VNF are present at database table vnfs and update content into scenario dict for name,vnf in scenario["vnfs"].iteritems(): - WHERE_={} + where={} + where_or={"tenant_id": tenant_id, 'public': "true"} error_text = "" - error_pos = "'topology':'nodes':'" + name + "'" + error_pos = "'scenario':'vnfs':'" + name + "'" if 'vnf_id' in vnf: error_text += " 'vnf_id' " + vnf['vnf_id'] - WHERE_['uuid'] = vnf['vnf_id'] + where['uuid'] = vnf['vnf_id'] if 'vnf_name' in vnf: error_text += " 'vnf_name' " + vnf['vnf_name'] - WHERE_['name'] = vnf['vnf_name'] - if len(WHERE_) == 0: - raise NfvoException("Needed a 'vnf_id' or 'VNF model' at " + error_pos, HTTP_Bad_Request) - vnf_db = mydb.get_rows(SELECT=('uuid','name','description'), FROM='vnfs', WHERE=WHERE_) + where['name'] = vnf['vnf_name'] + if len(where) == 0: + raise NfvoException("Needed a 'vnf_id' or 'vnf_name' at " + error_pos, HTTP_Bad_Request) + vnf_db = mydb.get_rows(SELECT=('uuid','name','description'), + FROM='vnfs', + WHERE=where, + WHERE_OR=where_or, + WHERE_AND_OR="AND") if len(vnf_db)==0: raise NfvoException("Unknown" + error_text + " at " + error_pos, HTTP_Not_Found) elif len(vnf_db)>1: @@ -1146,15 +1348,17 @@ def start_scenario(mydb, tenant_id, scenario_id, instance_scenario_name, instanc myNetDict["name"] = myNetName myNetDict["type"] = myNetType myNetDict["tenant_id"] = myvim_tenant + myNetIPProfile = sce_net.get('ip_profile', None) #TODO: #We should use the dictionary as input parameter for new_network #print myNetDict if not sce_net["external"]: - network_id = myvim.new_network(myNetName, myNetType) + network_id = myvim.new_network(myNetName, myNetType, myNetIPProfile) #print "New VIM network created for scenario %s. Network id: %s" % (scenarioDict['name'],network_id) sce_net['vim_id'] = network_id auxNetDict['scenario'][sce_net['uuid']] = network_id rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':network_id}) + sce_net["created"] = True else: if sce_net['vim_id'] == None: error_text = "Error, datacenter '%s' does not have external network '%s'." % (datacenter_name, sce_net['name']) @@ -1177,16 +1381,18 @@ def start_scenario(mydb, tenant_id, scenario_id, instance_scenario_name, instanc myNetDict["name"] = myNetName myNetDict["type"] = myNetType myNetDict["tenant_id"] = myvim_tenant + myNetIPProfile = net.get('ip_profile', None) #print myNetDict #TODO: #We should use the dictionary as input parameter for new_network - network_id = myvim.new_network(myNetName, myNetType) + network_id = myvim.new_network(myNetName, myNetType, myNetIPProfile) #print "VIM network id for scenario %s: %s" % (scenarioDict['name'],network_id) net['vim_id'] = network_id if sce_vnf['uuid'] not in auxNetDict: auxNetDict[sce_vnf['uuid']] = {} auxNetDict[sce_vnf['uuid']][net['uuid']] = network_id rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':network_id}) + net["created"] = True #print "auxNetDict:" #print yaml.safe_dump(auxNetDict, indent=4, default_flow_style=False) @@ -1306,142 +1512,383 @@ 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 create_instance(mydb, tenant_id, instance_dict): - #print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id" - scenario = instance_dict["scenario"] +def unify_cloud_config(cloud_config): + index_to_delete = [] + users = cloud_config.get("users", []) + for index0 in range(0,len(users)): + if index0 in index_to_delete: + continue + for index1 in range(index0+1,len(users)): + if index1 in index_to_delete: + continue + 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]: + 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] + +def get_datacenter_by_name_uuid(mydb, tenant_id, datacenter_id_name=None): datacenter_id = None - datacenter_name=None - datacenter = instance_dict.get("datacenter") - if datacenter: - if utils.check_valid_uuid(datacenter): - datacenter_id = datacenter + datacenter_name = None + if datacenter_id_name: + if utils.check_valid_uuid(datacenter_id_name): + datacenter_id = datacenter_id_name else: - datacenter_name = datacenter + datacenter_name = datacenter_id_name vims = get_vim(mydb, tenant_id, datacenter_id, datacenter_name, vim_tenant=None) if len(vims) == 0: - raise NfvoException("datacenter '{}' not found".format(str(datacenter)), HTTP_Not_Found) + raise NfvoException("datacenter '{}' not found".format(str(datacenter_id_name)), HTTP_Not_Found) elif len(vims)>1: #print "nfvo.datacenter_action() error. Several datacenters found" raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict) - myvim = vims.values()[0] + return vims.keys()[0], vims.values()[0] + +def new_scenario_v03(mydb, tenant_id, scenario_dict): + scenario = scenario_dict["scenario"] + if tenant_id != "any": + check_tenant(mydb, tenant_id) + if "tenant_id" in scenario: + if scenario["tenant_id"] != tenant_id: + logger("Tenant '%s' not found", tenant_id) + raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format( + scenario["tenant_id"], tenant_id), HTTP_Unauthorized) + else: + tenant_id=None + +#1: Check that VNF are present at database table vnfs and update content into scenario dict + for name,vnf in scenario["vnfs"].iteritems(): + where={} + where_or={"tenant_id": tenant_id, 'public': "true"} + error_text = "" + error_pos = "'scenario':'vnfs':'" + name + "'" + if 'vnf_id' in vnf: + error_text += " 'vnf_id' " + vnf['vnf_id'] + where['uuid'] = vnf['vnf_id'] + if 'vnf_name' in vnf: + error_text += " 'vnf_name' " + vnf['vnf_name'] + where['name'] = vnf['vnf_name'] + if len(where) == 0: + raise NfvoException("Needed a 'vnf_id' or 'vnf_name' at " + error_pos, HTTP_Bad_Request) + vnf_db = mydb.get_rows(SELECT=('uuid','name','description'), + FROM='vnfs', + WHERE=where, + WHERE_OR=where_or, + WHERE_AND_OR="AND") + if len(vnf_db)==0: + raise NfvoException("Unknown" + error_text + " at " + error_pos, HTTP_Not_Found) + elif len(vnf_db)>1: + raise NfvoException("More than one" + error_text + " at " + error_pos + " Concrete with 'vnf_id'", HTTP_Conflict) + vnf['uuid']=vnf_db[0]['uuid'] + vnf['description']=vnf_db[0]['description'] + vnf['ifaces'] = {} + # get external interfaces + ext_ifaces = mydb.get_rows(SELECT=('external_name as name','i.uuid as iface_uuid', 'i.type as type'), + FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces as i on vms.uuid=i.vm_id', + WHERE={'vnfs.uuid':vnf['uuid']}, WHERE_NOT={'external_name':None} ) + for ext_iface in ext_ifaces: + vnf['ifaces'][ ext_iface['name'] ] = {'uuid':ext_iface['iface_uuid'], 'type':ext_iface['type']} + + # TODO? get internal-connections from db.nets and their profiles, and update scenario[vnfs][internal-connections] accordingly + +#2: Insert net_key and ip_address at every vnf interface + for net_name,net in scenario["networks"].iteritems(): + net_type_bridge=False + net_type_data=False + for iface_dict in net["interfaces"]: + logger.debug("Iface_dict %s", iface_dict) + vnf = iface_dict["vnf"] + iface = iface_dict["vnf_interface"] + if vnf not in scenario["vnfs"]: + error_text = "Error at 'networks':'%s':'interfaces' VNF '%s' not match any VNF at 'vnfs'" % (net_name, vnf) + #logger.debug(error_text) + raise NfvoException(error_text, HTTP_Not_Found) + if iface not in scenario["vnfs"][vnf]['ifaces']: + error_text = "Error at 'networks':'%s':'interfaces':'%s' interface not match any VNF interface" % (net_name, iface) + #logger.debug(error_text) + raise NfvoException(error_text, HTTP_Bad_Request) + if "net_key" in scenario["vnfs"][vnf]['ifaces'][iface]: + error_text = "Error at 'networks':'%s':'interfaces':'%s' interface already connected at network '%s'" \ + % (net_name, iface,scenario["vnfs"][vnf]['ifaces'][iface]['net_key']) + #logger.debug(error_text) + raise NfvoException(error_text, HTTP_Bad_Request) + scenario["vnfs"][vnf]['ifaces'][ iface ]['net_key'] = net_name + scenario["vnfs"][vnf]['ifaces'][ iface ]['ip_address'] = iface_dict.get('ip_address',None) + iface_type = scenario["vnfs"][vnf]['ifaces'][iface]['type'] + if iface_type=='mgmt' or iface_type=='bridge': + net_type_bridge = True + else: + net_type_data = True + if net_type_bridge and net_type_data: + error_text = "Error connection interfaces of bridge type and data type at 'networks':'%s':'interfaces'" % (net_name) + #logger.debug(error_text) + raise NfvoException(error_text, HTTP_Bad_Request) + elif net_type_bridge: + type_='bridge' + else: + type_='data' if len(net["interfaces"])>2 else 'ptp' + + if ("implementation" in net): + if (type_ == "bridge" and net["implementation"] == "underlay"): + error_text = "Error connecting interfaces of data type to a network declared as 'underlay' at 'network':'%s'" % (net_name) + #logger.debug(error_text) + raise NfvoException(error_text, HTTP_Bad_Request) + elif (type_ <> "bridge" and net["implementation"] == "overlay"): + error_text = "Error connecting interfaces of data type to a network declared as 'overlay' at 'network':'%s'" % (net_name) + #logger.debug(error_text) + raise NfvoException(error_text, HTTP_Bad_Request) + net.pop("implementation") + if ("type" in net): + if (type_ == "data" and net["type"] == "e-line"): + error_text = "Error connecting more than 2 interfaces of data type to a network declared as type 'e-line' at 'network':'%s'" % (net_name) + #logger.debug(error_text) + raise NfvoException(error_text, HTTP_Bad_Request) + elif (type_ == "ptp" and net["type"] == "e-lan"): + type_ = "data" + + net['type'] = type_ + net['name'] = net_name + net['external'] = net.get('external', False) + +#3: insert at database + scenario["nets"] = scenario["networks"] + scenario['tenant_id'] = tenant_id + scenario_id = mydb.new_scenario2(scenario) + return scenario_id + +def update(d, u): + '''Takes dict d and updates it with the values in dict u.''' + '''It merges all depth levels''' + for k, v in u.iteritems(): + if isinstance(v, collections.Mapping): + r = update(d.get(k, {}), v) + d[k] = r + else: + d[k] = u[k] + return d + +def create_instance(mydb, tenant_id, instance_dict): + #print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id" + #logger.debug("Creating instance...") + scenario = instance_dict["scenario"] + + #find main datacenter + myvims = {} + datacenter = instance_dict.get("datacenter") + default_datacenter_id, vim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter) + myvims[default_datacenter_id] = vim #myvim_tenant = myvim['tenant_id'] - datacenter_id = myvim['id'] - datacenter_name = myvim['name'] - datacenter_tenant_id = myvim['config']['datacenter_tenant_id'] +# default_datacenter_name = vim['name'] + default_datacenter_tenant_id = vim['config']['datacenter_tenant_id'] #TODO review rollbackList=[] #print "Checking that the scenario exists and getting the scenario dictionary" - scenarioDict = mydb.get_scenario(scenario, tenant_id, datacenter_id) - scenarioDict['datacenter_tenant_id'] = datacenter_tenant_id - scenarioDict['datacenter_id'] = datacenter_id - + scenarioDict = mydb.get_scenario(scenario, tenant_id, default_datacenter_id) + + #logger.debug(">>>>>>> Dictionaries before merging") + #logger.debug(">>>>>>> InstanceDict:\n{}".format(yaml.safe_dump(instance_dict,default_flow_style=False, width=256))) + #logger.debug(">>>>>>> ScenarioDict:\n{}".format(yaml.safe_dump(scenarioDict,default_flow_style=False, width=256))) + + scenarioDict['datacenter_tenant_id'] = default_datacenter_tenant_id + scenarioDict['datacenter_id'] = default_datacenter_id + auxNetDict = {} #Auxiliar dictionary. First key:'scenario' or sce_vnf uuid. Second Key: uuid of the net/sce_net. Value: vim_net_id auxNetDict['scenario'] = {} - #print "scenario dict: ",yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False) + logger.debug("Creating instance from scenario-dict:\n%s", yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False)) #TODO remove instance_name = instance_dict["name"] instance_description = instance_dict.get("description") try: #0 check correct parameters - for descriptor_net in instance_dict.get("networks",{}).keys(): + for net_name, net_instance_desc in instance_dict.get("networks",{}).iteritems(): found=False for scenario_net in scenarioDict['nets']: - if descriptor_net == scenario_net["name"]: + if net_name == scenario_net["name"]: found = True break if not found: - raise NfvoException("Invalid scenario network name '{}' at instance:networks".format(descriptor_net), HTTP_Bad_Request) - for descriptor_vnf in instance_dict.get("vnfs",{}).keys(): + raise NfvoException("Invalid scenario network name '{}' at instance:networks".format(net_name), HTTP_Bad_Request) + if "sites" not in net_instance_desc: + net_instance_desc["sites"] = [ {} ] + site_without_datacenter_field = False + for site in net_instance_desc["sites"]: + if site.get("datacenter"): + if site["datacenter"] not in myvims: + #Add this datacenter to myvims + d, v = get_datacenter_by_name_uuid(mydb, tenant_id, site["datacenter"]) + myvims[d] = v + site["datacenter"] = d #change name to id + else: + if site_without_datacenter_field: + raise NfvoException("Found more than one entries without datacenter field at instance:networks:{}:sites".format(net_name), HTTP_Bad_Request) + site_without_datacenter_field = True + site["datacenter"] = default_datacenter_id #change name to id + + for vnf_name, vnf_instance_desc in instance_dict.get("vnfs",{}).iteritems(): found=False for scenario_vnf in scenarioDict['vnfs']: - if descriptor_vnf == scenario_vnf['name']: + if vnf_name == scenario_vnf['name']: found = True break if not found: - raise NfvoException("Invalid vnf name '{}' at instance:vnfs".format(descriptor_vnf), HTTP_Bad_Request) + raise NfvoException("Invalid vnf name '{}' at instance:vnfs".format(vnf_instance_desc), HTTP_Bad_Request) + if "datacenter" in vnf_instance_desc: + #Add this datacenter to myvims + if vnf_instance_desc["datacenter"] not in myvims: + d, v = get_datacenter_by_name_uuid(mydb, tenant_id, vnf_instance_desc["datacenter"]) + myvims[d] = v + scenario_vnf["datacenter"] = d #change name to id + #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) + + #0.2 merge instance information into scenario + #Ideally, the operation should be as simple as: update(scenarioDict,instance_dict) + #However, this is not possible yet. + for net_name, net_instance_desc in instance_dict.get("networks",{}).iteritems(): + for scenario_net in scenarioDict['nets']: + if net_name == scenario_net["name"]: + if 'ip-profile' in net_instance_desc: + ipprofile = net_instance_desc['ip-profile'] + ipprofile['subnet_address'] = ipprofile.pop('subnet-address',None) + ipprofile['ip_version'] = ipprofile.pop('ip-version','IPv4') + ipprofile['gateway_address'] = ipprofile.pop('gateway-address',None) + ipprofile['dns_address'] = ipprofile.pop('dns-address',None) + if 'dhcp' in ipprofile: + ipprofile['dhcp_start_address'] = ipprofile['dhcp'].get('start-address',None) + ipprofile['dhcp_enabled'] = ipprofile['dhcp'].get('enabled',True) + ipprofile['dhcp_count'] = ipprofile['dhcp'].get('count',None) + del ipprofile['dhcp'] + if 'ip_profile' not in scenario_net: + scenario_net['ip_profile'] = ipprofile + else: + update(scenario_net['ip_profile'],ipprofile) + for interface in net_instance_desc.get('interfaces', () ): + if 'ip_address' in interface: + for vnf in scenarioDict['vnfs']: + if interface['vnf'] == vnf['name']: + for vnf_interface in vnf['interfaces']: + if interface['vnf_interface'] == vnf_interface['external_name']: + vnf_interface['ip_address']=interface['ip_address'] + + #logger.debug(">>>>>>>> Merged dictionary") + logger.debug("Creating instance scenario-dict MERGED:\n%s", yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False)) + #1. Creating new nets (sce_nets) in the VIM" for sce_net in scenarioDict['nets']: + sce_net["vim_id_sites"]={} descriptor_net = instance_dict.get("networks",{}).get(sce_net["name"],{}) - net_name = descriptor_net.get("name") - net_type = sce_net['type'] - lookfor_filter = {'admin_state_up': True, 'status': 'ACTIVE'} #'shared': True - if sce_net["external"]: - if not net_name: - net_name = sce_net["name"] - if "netmap-use" in descriptor_net or "netmap-create" in descriptor_net: - create_network = False - lookfor_network = False - if "netmap-use" in descriptor_net: + net_name = descriptor_net.get("vim-network-name") + auxNetDict['scenario'][sce_net['uuid']] = {} + + sites = descriptor_net.get("sites", [ {} ]) + for site in sites: + if site.get("datacenter"): + vim = myvims[ site["datacenter"] ] + datacenter_id = site["datacenter"] + else: + vim = myvims[ default_datacenter_id ] + datacenter_id = default_datacenter_id + + net_type = sce_net['type'] + lookfor_filter = {'admin_state_up': True, 'status': 'ACTIVE'} #'shared': True + if sce_net["external"]: + if not net_name: + net_name = sce_net["name"] + if "netmap-use" in site or "netmap-create" in site: + create_network = False + lookfor_network = False + if "netmap-use" in site: + lookfor_network = True + if utils.check_valid_uuid(site["netmap-use"]): + filter_text = "scenario id '%s'" % site["netmap-use"] + lookfor_filter["id"] = site["netmap-use"] + else: + filter_text = "scenario name '%s'" % site["netmap-use"] + lookfor_filter["name"] = site["netmap-use"] + if "netmap-create" in site: + create_network = True + net_vim_name = net_name + if site["netmap-create"]: + net_vim_name = site["netmap-create"] + + elif sce_net['vim_id'] != None: + #there is a netmap at datacenter_nets database #TODO REVISE!!!! + create_network = False lookfor_network = True - if utils.check_valid_uuid(descriptor_net["netmap-use"]): - filter_text = "scenario id '%s'" % descriptor_net["netmap-use"] - lookfor_filter["id"] = descriptor_net["netmap-use"] - else: - filter_text = "scenario name '%s'" % descriptor_net["netmap-use"] - lookfor_filter["name"] = descriptor_net["netmap-use"] - if "netmap-create" in descriptor_net: + lookfor_filter["id"] = sce_net['vim_id'] + filter_text = "vim_id '%s' datacenter_netmap name '%s'. Try to reload vims with datacenter-net-update" % (sce_net['vim_id'], sce_net["name"]) + #look for network at datacenter and return error + else: + #There is not a netmap, look at datacenter for a net with this name and create if not found create_network = True - net_vim_name = net_name - if descriptor_net["netmap-create"]: - net_vim_name= descriptor_net["netmap-create"] - - elif sce_net['vim_id'] != None: - #there is a netmap at datacenter_nets database - create_network = False - lookfor_network = True - lookfor_filter["id"] = sce_net['vim_id'] - filter_text = "vim_id '%s' datacenter_netmap name '%s'. Try to reload vims with datacenter-net-update" % (sce_net['vim_id'], sce_net["name"]) - #look for network at datacenter and return error + lookfor_network = True + lookfor_filter["name"] = sce_net["name"] + net_vim_name = sce_net["name"] + filter_text = "scenario name '%s'" % sce_net["name"] else: - #There is not a netmap, look at datacenter for a net with this name and create if not found + if not net_name: + net_name = "%s.%s" %(instance_name, sce_net["name"]) + net_name = net_name[:255] #limit length + net_vim_name = net_name create_network = True - lookfor_network = True - lookfor_filter["name"] = sce_net["name"] - net_vim_name = sce_net["name"] - filter_text = "scenario name '%s'" % sce_net["name"] - else: - if not net_name: - net_name = "%s.%s" %(instance_name, sce_net["name"]) - net_name = net_name[:255] #limit length - net_vim_name = net_name - create_network = True - lookfor_network = False - - if lookfor_network: - vim_nets = myvim.get_network_list(filter_dict=lookfor_filter) - if len(vim_nets) > 1: - raise NfvoException("More than one candidate VIM network found for " + filter_text, HTTP_Bad_Request ) - elif len(vim_nets) == 0: - if not create_network: - raise NfvoException("No candidate VIM network found for " + filter_text, HTTP_Bad_Request ) - else: - sce_net['vim_id'] = vim_nets[0]['id'] - auxNetDict['scenario'][sce_net['uuid']] = vim_nets[0]['id'] - create_network = False - if create_network: - #if network is not external - network_id = myvim.new_network(net_vim_name, net_type) - sce_net['vim_id'] = network_id - auxNetDict['scenario'][sce_net['uuid']] = network_id - rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':network_id}) + lookfor_network = False + + if lookfor_network: + vim_nets = vim.get_network_list(filter_dict=lookfor_filter) + if len(vim_nets) > 1: + raise NfvoException("More than one candidate VIM network found for " + filter_text, HTTP_Bad_Request ) + elif len(vim_nets) == 0: + if not create_network: + raise NfvoException("No candidate VIM network found for " + filter_text, HTTP_Bad_Request ) + else: + sce_net["vim_id_sites"][datacenter_id] = vim_nets[0]['id'] + + auxNetDict['scenario'][sce_net['uuid']][datacenter_id] = vim_nets[0]['id'] + create_network = False + if create_network: + #if network is not external + network_id = vim.new_network(net_vim_name, net_type, sce_net.get('ip_profile',None)) + sce_net["vim_id_sites"][datacenter_id] = network_id + auxNetDict['scenario'][sce_net['uuid']][datacenter_id] = network_id + rollbackList.append({'what':'network', 'where':'vim', 'vim_id':datacenter_id, 'uuid':network_id}) + sce_net["created"] = True #2. Creating new nets (vnf internal nets) in the VIM" #For each vnf net, we create it and we add it to instanceNetlist. for sce_vnf in scenarioDict['vnfs']: for net in sce_vnf['nets']: + if sce_vnf.get("datacenter"): + vim = myvims[ sce_vnf["datacenter"] ] + datacenter_id = sce_vnf["datacenter"] + else: + vim = myvims[ default_datacenter_id ] + datacenter_id = default_datacenter_id descriptor_net = instance_dict.get("vnfs",{}).get(sce_vnf["name"],{}) net_name = descriptor_net.get("name") if not net_name: net_name = "%s.%s" %(instance_name, net["name"]) net_name = net_name[:255] #limit length net_type = net['type'] - network_id = myvim.new_network(net_name, net_type) + network_id = vim.new_network(net_name, net_type, net.get('ip_profile',None)) net['vim_id'] = network_id if sce_vnf['uuid'] not in auxNetDict: auxNetDict[sce_vnf['uuid']] = {} auxNetDict[sce_vnf['uuid']][net['uuid']] = network_id rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':network_id}) + net["created"] = True + #print "auxNetDict:" #print yaml.safe_dump(auxNetDict, indent=4, default_flow_style=False) @@ -1449,6 +1896,14 @@ def create_instance(mydb, tenant_id, instance_dict): #3. Creating new vm instances in the VIM #myvim.new_vminstance(self,vimURI,tenant_id,name,description,image_id,flavor_id,net_dict) for sce_vnf in scenarioDict['vnfs']: + if sce_vnf.get("datacenter"): + vim = myvims[ sce_vnf["datacenter"] ] + datacenter_id = sce_vnf["datacenter"] + else: + vim = myvims[ default_datacenter_id ] + datacenter_id = default_datacenter_id + sce_vnf["datacenter_id"] = datacenter_id + sce_vnf["datacenter_tenant_id"] = vim['config']['datacenter_tenant_id'] i = 0 for vm in sce_vnf['vms']: i += 1 @@ -1460,14 +1915,14 @@ def create_instance(mydb, tenant_id, instance_dict): 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, vims, 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, vims, flavor_dict, rollbackList, True) + flavor_id = create_or_use_flavor(mydb, {datacenter_id: vim}, flavor_dict, rollbackList, True) vm['vim_flavor_id'] = flavor_id myVMDict['imageRef'] = vm['vim_image_id'] @@ -1515,7 +1970,7 @@ def create_instance(mydb, tenant_id, instance_dict): #print iface #print vnf_iface if vnf_iface['interface_id']==iface['uuid']: - netDict['net_id'] = auxNetDict['scenario'][ vnf_iface['sce_net_id'] ] + netDict['net_id'] = auxNetDict['scenario'][ vnf_iface['sce_net_id'] ][datacenter_id] break else: netDict['net_id'] = auxNetDict[ sce_vnf['uuid'] ][ iface['net_id'] ] @@ -1528,8 +1983,8 @@ 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 ">>>>>>>>>>>>>>>>>>>>>>>>>>>" - vm_id = myvim.new_vminstance(myVMDict['name'],myVMDict['description'],myVMDict.get('start', None), - myVMDict['imageRef'],myVMDict['flavorRef'],myVMDict['networks']) + vm_id = vim.new_vminstance(myVMDict['name'],myVMDict['description'],myVMDict.get('start', None), + myVMDict['imageRef'],myVMDict['flavorRef'],myVMDict['networks'], cloud_config = cloud_config) 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] @@ -1540,12 +1995,12 @@ def create_instance(mydb, tenant_id, instance_dict): iface["vim_id"]=net["vim_id"] break logger.debug("create_instance Deployment done") - #print yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False) + print yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False) #r,c = mydb.new_instance_scenario_as_a_whole(nfvo_tenant,scenarioDict['name'],scenarioDict) instance_id = mydb.new_instance_scenario_as_a_whole(tenant_id,instance_name, instance_description, scenarioDict) return mydb.get_instance_scenario(instance_id) except (NfvoException, vimconn.vimconnException,db_base_Exception) as e: - message = rollback(mydb, vims, rollbackList) + message = rollback(mydb, myvims, rollbackList) if isinstance(e, db_base_Exception): error_text = "database Exception" elif isinstance(e, vimconn.vimconnException): @@ -1605,7 +2060,7 @@ def delete_instance(mydb, tenant_id, instance_id): #2.2 deleting NETS #net_fail_list=[] for net in instanceDict['nets']: - if net['external']: + if not net['created']: continue #skip not created nets if not myvim: continue @@ -1614,7 +2069,7 @@ def delete_instance(mydb, tenant_id, instance_id): except vimconn.vimconnNotFoundException as e: error_msg+="\n NET id={} not found at VIM".format(net['vim_net_id']) logger.warn("NET '%s', VIM id '%s', from VNF_id '%s' not found", - net['uuid'], vm['vim_net_id'], sce_vnf['vnf_id']) + net['uuid'], net['vim_net_id'], sce_vnf['vnf_id']) except vimconn.vimconnException as e: error_msg+="\n Error: " + e.http_code + " Net id=" + net['vim_vm_id'] logger.error("Error %d deleting NET '%s', VIM id '%s', from VNF_id '%s': %s", @@ -1671,7 +2126,7 @@ def refresh_instance(mydb, nfvo_tenant, instanceDict, datacenter=None, vim_tenan if iface["type"]=="mgmt": has_mgmt_iface = True if vm_dict[vm_id]['status'] == "ACTIVE:NoMgmtIP" and not has_mgmt_iface: - vm_dict[vm_id]['status'] = "ACTIVE" + vm_dict[vm_id]['status'] = "ACTIVE" 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') @@ -1687,16 +2142,16 @@ def refresh_instance(mydb, nfvo_tenant, instanceDict, datacenter=None, vim_tenan # 2.2. Update in openmano DB the interface VMs for interface in interfaces: #translate from vim_net_id to instance_net_id - network_id=None + network_id_list=[] for net in instanceDict['nets']: if net["vim_net_id"] == interface["vim_net_id"]: - network_id = net["uuid"] - break - if not network_id: + network_id_list.append(net["uuid"]) + if not network_id_list: continue del interface["vim_net_id"] - try: - mydb.update_rows('instance_interfaces', UPDATE=interface, WHERE={'instance_vm_id':vm["uuid"], "instance_net_id":network_id}) + try: + for network_id in network_id_list: + mydb.update_rows('instance_interfaces', UPDATE=interface, WHERE={'instance_vm_id':vm["uuid"], "instance_net_id":network_id}) except db_base_Exception as e: logger.error( "nfvo.refresh_instance error with vm=%s, interface_net_id=%s", vm["uuid"], network_id) @@ -1761,23 +2216,39 @@ def instance_action(mydb,nfvo_tenant,instance_id, action_dict): try: data = myvim.action_vminstance(vm['vim_vm_id'], action_dict) if "console" in action_dict: - if data["server"]=="127.0.0.1" or data["server"]=="localhost": + if not global_config["http_console_proxy"]: + vm_result[ vm['uuid'] ] = {"vim_result": 200, + "description": "{protocol}//{ip}:{port}/{suffix}".format( + protocol=data["protocol"], + ip = data["server"], + port = data["port"], + suffix = data["suffix"]), + "name":vm['name'] + } + vm_ok +=1 + elif data["server"]=="127.0.0.1" or data["server"]=="localhost": vm_result[ vm['uuid'] ] = {"vim_result": -HTTP_Unauthorized, "description": "this console is only reachable by local interface", "name":vm['name'] } vm_error+=1 - continue + else: #print "console data", data - try: - console_thread = create_or_use_console_proxy_thread(data["server"], data["port"]) - vm_result[ vm['uuid'] ] = {"vim_result": 200, - "description": "%s//%s:%d/%s" %(data["protocol"], console_thread.host, console_thread.port, data["suffix"]), - "name":vm['name'] - } - vm_ok +=1 - except NfvoException as e: - vm_result[ vm['uuid'] ] = {"vim_result": e.http_code, "name":vm['name'], "description": str(e)} + try: + console_thread = create_or_use_console_proxy_thread(data["server"], data["port"]) + vm_result[ vm['uuid'] ] = {"vim_result": 200, + "description": "{protocol}//{ip}:{port}/{suffix}".format( + protocol=data["protocol"], + ip = global_config["http_console_host"], + port = console_thread.port, + suffix = data["suffix"]), + "name":vm['name'] + } + vm_ok +=1 + except NfvoException as e: + vm_result[ vm['uuid'] ] = {"vim_result": e.http_code, "name":vm['name'], "description": str(e)} + vm_error+=1 + else: vm_result[ vm['uuid'] ] = {"vim_result": 200, "description": "ok", "name":vm['name']} vm_ok +=1 @@ -1786,9 +2257,9 @@ def instance_action(mydb,nfvo_tenant,instance_id, action_dict): vm_error+=1 if vm_ok==0: #all goes wrong - return 1, vm_result + return vm_result else: - return 1, vm_result + return vm_result def create_or_use_console_proxy_thread(console_server, console_port): #look for a non-used port @@ -1798,7 +2269,7 @@ def create_or_use_console_proxy_thread(console_server, console_port): return global_config["console_thread"][console_thread_key] for port in global_config["console_port_iterator"](): - print "create_or_use_console_proxy_thread() port:", port + #print "create_or_use_console_proxy_thread() port:", port if port in global_config["console_ports"]: continue try: @@ -1835,6 +2306,17 @@ def delete_tenant(mydb, tenant): def new_datacenter(mydb, datacenter_descriptor): if "config" in datacenter_descriptor: datacenter_descriptor["config"]=yaml.safe_dump(datacenter_descriptor["config"],default_flow_style=True,width=256) + #Check that datacenter-type is correct + datacenter_type = datacenter_descriptor.get("type", "openvim"); + module_info = None + try: + module = "vimconn_" + datacenter_type + module_info = imp.find_module(module) + except (IOError, ImportError): + if module_info and module_info[0]: + file.close(module_info[0]) + raise NfvoException("Incorrect datacenter type '{}'. Plugin '{}'.py not installed".format(datacenter_type, module), HTTP_Bad_Request) + datacenter_id = mydb.new_row("datacenters", datacenter_descriptor, add_uuid=True) return datacenter_id @@ -1874,9 +2356,9 @@ def delete_datacenter(mydb, datacenter): def associate_datacenter_to_tenant(mydb, nfvo_tenant, datacenter, vim_tenant_id=None, vim_tenant_name=None, vim_username=None, vim_password=None): #get datacenter info if utils.check_valid_uuid(datacenter): - vims = get_vim(mydb, datacenter_id=datacenter) + vims = get_vim(mydb, datacenter_id=datacenter, vim_tenant_name=vim_tenant_name, vim_user=vim_username, vim_passwd=vim_password) else: - vims = get_vim(mydb, datacenter_name=datacenter) + vims = get_vim(mydb, datacenter_name=datacenter, vim_tenant_name=vim_tenant_name, vim_user=vim_username, vim_passwd=vim_password) if len(vims) == 0: raise NfvoException("datacenter '{}' not found".format(str(datacenter)), HTTP_Not_Found) elif len(vims)>1: @@ -2145,12 +2627,12 @@ def vim_action_get(mydb, tenant_id, datacenter, item, name): content = myvim.get_tenant_list(filter_dict=filter_dict) else: raise NfvoException(item + "?", HTTP_Method_Not_Allowed) - logger.debug("vim_action response ", content) #update nets Change from VIM format to NFVO format + logger.debug("vim_action response %s", content) #update nets Change from VIM format to NFVO format if name and len(content)==1: return {item[:-1]: content[0]} elif name and len(content)==0: raise NfvoException("No {} found with ".format(item[:-1]) + " and ".join(map(lambda x: str(x[0])+": "+str(x[1]), filter_dict.iteritems())), - -HTTP_Not_Found) + datacenter) else: return {item: content} except vimconn.vimconnException as e: @@ -2221,8 +2703,9 @@ def vim_action_create(mydb, tenant_id, datacenter, item, descriptor): net = descriptor["network"] net_name = net.pop("name") net_type = net.pop("type", "bridge") - net_public=net.pop("shared", False) - content = myvim.new_network(net_name, net_type, net_public, **net) + net_public = net.pop("shared", False) + net_ipprofile = net.pop("ip_profile", None) + content = myvim.new_network(net_name, net_type, net_ipprofile, shared=net_public, **net) elif item=="tenants": tenant = descriptor["tenant"] content = myvim.new_tenant(tenant["name"], tenant.get("description"))