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",() ):
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
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 = None
- logger.warn("Error creating image at VIM: %s", str(e))
+ logger.warn("Error creating image at VIM '%s': %s", vim["name"], str(e))
continue
except vimconn.vimconnException as e:
if return_on_error:
raise
logger.warn("Error contacting VIM to know if the image exists at VIM: %s", str(e))
image_vim_id = None
- continue
+ continue
#if we reach here, the image has been created or existed
if len(image_db)==0:
#add new vim_id at datacenters_images
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
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
#create flavor at vim
logger.debug("nfvo.create_or_use_flavor() adding flavor to VIM %s", vim["name"])
try:
- flavor_vim_id = vim.new_flavor(flavor_dict)
- rollback_list.append({"where":"vim", "vim_id": vim_id, "what":"flavor","uuid":flavor_vim_id})
- flavor_created="true"
+ flavor_vim_id = None
+ flavor_vim_id=vim.get_flavor_id_from_data(flavor_dict)
+ flavor_create="false"
+ except vimconn.vimconnException as e:
+ pass
+ try:
+ if not flavor_vim_id:
+ flavor_vim_id = vim.new_flavor(flavor_dict)
+ rollback_list.append({"where":"vim", "vim_id": vim_id, "what":"flavor","uuid":flavor_vim_id})
+ flavor_created="true"
except vimconn.vimconnException as e:
if return_on_error:
logger.error("Error creating flavor at VIM %s: %s.", vim["name"], str(e))
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
#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
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
#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)
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.
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"]:
#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
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
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)
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"]:
#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
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
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:
projects / osm / RO.git / blobdiff