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
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')
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:
#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)
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_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:
#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})
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:
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"
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']
#print "interfaces", yaml.safe_dump(vm['interfaces'], indent=4, default_flow_style=False)
#print ">>>>>>>>>>>>>>>>>>>>>>>>>>>"
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,
+ 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]
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')
# 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')
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"]
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_
projects / osm / RO.git / blobdiff