cloud init parameters at VNFD, allow file tranfer, config-drive, userdata, users...
[osm/RO.git] / nfvo.py
diff --git a/nfvo.py b/nfvo.py
index 1229f4c..7537c75 100644 (file)
--- 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_