diff --git a/nfvo.py b/nfvo.py
index e803206..9f360ce 100644
--- a/nfvo.py
+++ b/nfvo.py
@@ -92,7 +92,8 @@
         imageList.append(image['image_id'])
     return imageList
 
-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):
+def get_vim(mydb, nfvo_tenant=None, datacenter_id=None, datacenter_name=None, datacenter_tenant_id=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 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'
@@ -101,9 +102,11 @@
     WHERE_dict={}
     if nfvo_tenant     is not None:  WHERE_dict['nfvo_tenant_id'] = nfvo_tenant
     if datacenter_id   is not None:  WHERE_dict['d.uuid']  = datacenter_id
+    if datacenter_tenant_id is not None:  WHERE_dict['datacenter_tenant_id']  = datacenter_tenant_id
     if datacenter_name is not None:  WHERE_dict['d.name']  = datacenter_name
     if vim_tenant      is not None:  WHERE_dict['dt.vim_tenant_id']  = vim_tenant
-    if nfvo_tenant or vim_tenant:
+    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',
                    'dt.uuid as datacenter_tenant_id','dt.vim_tenant_name as vim_tenant_name','dt.vim_tenant_id as vim_tenant_id',
@@ -252,10 +255,12 @@
                                     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:
             images = mydb.get_rows(FROM="images", WHERE={'location':image_dict['location'], 'metadata':image_dict['metadata']})
@@ -303,12 +308,15 @@
                 if return_on_error:
                     logger.error("Error creating image at VIM: %s", str(e))
                     raise
-                image_vim_id = str(e)
+                image_vim_id = None
                 logger.warn("Error creating image at VIM: %s", 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)
+            image_vim_id = None
             continue    
         #if we reach here, the image has been created or existed
         if len(image_db)==0:
@@ -320,7 +328,7 @@
             
     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'),
@@ -333,6 +341,8 @@
     #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:
@@ -344,7 +354,7 @@
             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")
@@ -434,6 +444,7 @@
                 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:
@@ -1303,29 +1314,16 @@
 
 def start_scenario(mydb, tenant_id, scenario_id, instance_scenario_name, instance_scenario_description, datacenter=None,vim_tenant=None, startvms=True):
     #print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id"
-    datacenter_id = None
-    datacenter_name=None
-    if datacenter != None:
-        if utils.check_valid_uuid(datacenter): 
-            datacenter_id = datacenter
-        else:
-            datacenter_name = datacenter
-    vims = get_vim(mydb, tenant_id, datacenter_id, datacenter_name, vim_tenant)
-    if len(vims) == 0:
-        raise NfvoException("datacenter '{}' not found".format(datacenter), HTTP_Not_Found)
-    elif len(vims)>1:
-        #logger.error("nfvo.datacenter_new_netmap() error. Several datacenters found")
-        raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict)
-    myvim = vims.values()[0]
+    datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter, vim_tenant=vim_tenant)
+    vims = {datacenter_id: myvim}
     myvim_tenant = myvim['tenant_id']
-    datacenter_id = myvim['id']
     datacenter_name = myvim['name']
-    datacenter_tenant_id = myvim['config']['datacenter_tenant_id']
+
     rollbackList=[]
     try:
         #print "Checking that the scenario_id exists and getting the scenario dictionary"
         scenarioDict = mydb.get_scenario(scenario_id, tenant_id, datacenter_id)
-        scenarioDict['datacenter_tenant_id'] = datacenter_tenant_id
+        scenarioDict['datacenter2tenant'] = { datacenter_id: myvim['config']['datacenter_tenant_id'] }
         scenarioDict['datacenter_id'] = datacenter_id
         #print '================scenarioDict======================='
         #print json.dumps(scenarioDict, indent=4)
@@ -1532,7 +1530,7 @@
     for index in index_to_delete:
         del users[index]
 
-def get_datacenter_by_name_uuid(mydb, tenant_id, datacenter_id_name=None):
+def get_datacenter_by_name_uuid(mydb, tenant_id, datacenter_id_name=None, **extra_filter):
     datacenter_id = None
     datacenter_name = None
     if datacenter_id_name:
@@ -1540,7 +1538,7 @@
             datacenter_id = datacenter_id_name
         else:
             datacenter_name = datacenter_id_name
-    vims = get_vim(mydb, tenant_id, datacenter_id, datacenter_name, vim_tenant=None)
+    vims = get_vim(mydb, tenant_id, datacenter_id, datacenter_name, **extra_filter)
     if len(vims) == 0:
         raise NfvoException("datacenter '{}' not found".format(str(datacenter_id_name)), HTTP_Not_Found)
     elif len(vims)>1:
@@ -1678,12 +1676,13 @@
     
     #find main datacenter
     myvims = {}
+    datacenter2tenant = {}
     datacenter = instance_dict.get("datacenter")
     default_datacenter_id, vim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
     myvims[default_datacenter_id] = vim
+    datacenter2tenant[default_datacenter_id] = vim['config']['datacenter_tenant_id']
     #myvim_tenant = myvim['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"
@@ -1693,7 +1692,6 @@
     #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
@@ -1721,6 +1719,7 @@
                         #Add this datacenter to myvims
                         d, v = get_datacenter_by_name_uuid(mydb, tenant_id, site["datacenter"])
                         myvims[d] = v
+                        datacenter2tenant[d] = v['config']['datacenter_tenant_id']
                         site["datacenter"]  = d #change name to id
                 else:
                     if site_without_datacenter_field:
@@ -1741,7 +1740,8 @@
                 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
+                    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"):
@@ -1800,7 +1800,6 @@
                 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"]:
@@ -1854,7 +1853,6 @@
                             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:
@@ -1903,7 +1901,6 @@
                 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
@@ -1915,7 +1912,7 @@
                 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
@@ -1928,7 +1925,7 @@
                 myVMDict['imageRef'] = vm['vim_image_id']
                 myVMDict['flavorRef'] = vm['vim_flavor_id']
                 myVMDict['networks'] = []
-#TODO ALF. connect_mgmt_interfaces. Connect management interfaces if this is true
+                #TODO ALF. connect_mgmt_interfaces. Connect management interfaces if this is true
                 for iface in vm['interfaces']:
                     netDict = {}
                     if iface['type']=="data":
@@ -1994,9 +1991,9 @@
                             if net["name"]==iface["internal_name"]:
                                 iface["vim_id"]=net["vim_id"]
                                 break
-        logger.debug("create_instance Deployment done")
-        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)
+        scenarioDict["datacenter2tenant"] = datacenter2tenant
+        logger.debug("create_instance Deployment done scenarioDict: %s",
+                    yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False) )
         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:
@@ -2017,44 +2014,41 @@
     #print yaml.safe_dump(instanceDict, indent=4, default_flow_style=False)
     tenant_id = instanceDict["tenant_id"]
     #print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id"
-    try: 
-        vims = get_vim(mydb, tenant_id, instanceDict['datacenter_id'])
-        if len(vims) == 0:
-            logger.error("!!!!!! nfvo.delete_instance() datacenter not found!!!!")
-            myvim = None
-        else:
-            myvim = vims.values()[0]
-    except NfvoException as e:
-        logger.error("!!!!!! nfvo.delete_instance() datacenter Exception!!!! " + str(e))
-        myvim = None
-    
-    
-    #1. Delete from Database
 
-    #result,c = mydb.delete_row_by_id('instance_scenarios', instance_id, nfvo_tenant)
+    #1. Delete from Database
     message = mydb.delete_instance_scenario(instance_id, tenant_id)
 
     #2. delete from VIM
-    if not myvim:
-        error_msg = "Not possible to delete VIM VMs and networks. Datacenter not found at database!!!"
-    else:
-        error_msg = ""
+    error_msg = ""
+    myvims={}
 
     #2.1 deleting VMs
     #vm_fail_list=[]
     for sce_vnf in instanceDict['vnfs']:
-        if not myvim:
-            continue
+        datacenter_key = (sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"])
+        if datacenter_key not in myvims:
+            vims = get_vim(mydb, tenant_id, datacenter_id=sce_vnf["datacenter_id"],
+                       datacenter_tenant_id=sce_vnf["datacenter_tenant_id"])
+            if len(vims) == 0:
+                logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(sce_vnf["datacenter_id"],
+                                                                                        sce_vnf["datacenter_tenant_id"]))
+                myvims[datacenter_key] = None
+            else:
+                myvims[datacenter_key] = vims.values()[0]
+        myvim = myvims[datacenter_key]
         for vm in sce_vnf['vms']:
+            if not myvim:
+                error_msg += "\n    VM id={} cannot be deleted because datacenter={} not found".format(vm['vim_vm_id'], sce_vnf["datacenter_id"])
+                continue
             try:
                 myvim.delete_vminstance(vm['vim_vm_id'])
             except vimconn.vimconnNotFoundException as e:
-                error_msg+="\n    VM id={} not found at VIM".format(vm['vim_vm_id'])
+                error_msg+="\n    VM VIM_id={} not found at datacenter={}".format(vm['vim_vm_id'], sce_vnf["datacenter_id"])
                 logger.warn("VM instance '%s'uuid '%s', VIM id '%s', from VNF_id '%s' not found",
                     vm['name'], vm['uuid'], vm['vim_vm_id'], sce_vnf['vnf_id'])
             except vimconn.vimconnException as e:
-                error_msg+="\n    Error: " + e.http_code + " VM id=" + vm['vim_vm_id']
-                logger.error("Error %d deleting VM instance '%s'uuid '%s', VIM id '%s', from VNF_id '%s': %s",
+                error_msg+="\n    VM VIM_id={} at datacenter={} Error: {} {}".format(vm['vim_vm_id'], sce_vnf["datacenter_id"], e.http_code, str(e))
+                logger.error("Error %d deleting VM instance '%s'uuid '%s', VIM_id '%s', from VNF_id '%s': %s",
                     e.http_code, vm['name'], vm['uuid'], vm['vim_vm_id'], sce_vnf['vnf_id'], str(e))
     
     #2.2 deleting NETS
@@ -2062,18 +2056,30 @@
     for net in instanceDict['nets']:
         if not net['created']:
             continue #skip not created nets
+        datacenter_key = (net["datacenter_id"], net["datacenter_tenant_id"])
+        if datacenter_key not in myvims:
+            vims = get_vim(mydb, tenant_id, datacenter_id=net["datacenter_id"],
+                           datacenter_tenant_id=net["datacenter_tenant_id"])
+            if len(vims) == 0:
+                logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"]))
+                myvims[datacenter_key] = None
+            else:
+                myvims[datacenter_key] = vims.values()[0]
+        myvim = myvims[datacenter_key]
+
         if not myvim:
+            error_msg += "\n    Net VIM_id={} cannot be deleted because datacenter={} not found".format(net['vim_net_id'], net["datacenter_id"])
             continue
         try:
             myvim.delete_network(net['vim_net_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'], net['vim_net_id'], sce_vnf['vnf_id'])
+            error_msg+="\n    NET VIM_id={} not found at datacenter={}".format(net['vim_net_id'], net["datacenter_id"])
+            logger.warn("NET '%s', VIM_id '%s', from VNF_net_id '%s' not found",
+                net['uuid'], net['vim_net_id'], str(net['vnf_net_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",
-                e.http_code, net['uuid'], net['vim_net_id'], sce_vnf['vnf_id'], str(e))
+            error_msg+="\n    NET VIM_id={} at datacenter={} Error: {} {}".format(net['vim_net_id'], net["datacenter_id"], e.http_code, str(e))
+            logger.error("Error %d deleting NET '%s', VIM_id '%s', from VNF_net_id '%s': %s",
+                e.http_code, net['uuid'], net['vim_net_id'], str(net['vnf_net_id']), str(e))
     if len(error_msg)>0:
         return 'instance ' + message + ' deleted but some elements could not be deleted, or already deleted (error: 404) from VIM: ' + error_msg
     else:
@@ -2090,93 +2096,143 @@
     #print json.dumps(instanceDict, indent=4)
     
     #print "Getting the VIM URL and the VIM tenant_id"
-    vims = get_vim(mydb, nfvo_tenant, instanceDict['datacenter_id'])
-    if len(vims) == 0:
-        raise NfvoException("datacenter '{}' not found".format(str(instanceDict['datacenter_id'])), HTTP_Not_Found)
-    myvim = vims.values()[0]
-     
+    myvims={}
+
     # 1. Getting VIM vm and net list
     vms_updated = [] #List of VM instance uuids in openmano that were updated
     vms_notupdated=[]
-    vm_list = []
+    vm_list = {}
     for sce_vnf in instanceDict['vnfs']:
+        datacenter_key = (sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"])
+        if datacenter_key not in vm_list:
+            vm_list[datacenter_key] = []
+        if datacenter_key not in myvims:
+            vims = get_vim(mydb, nfvo_tenant, datacenter_id=sce_vnf["datacenter_id"],
+                           datacenter_tenant_id=sce_vnf["datacenter_tenant_id"])
+            if len(vims) == 0:
+                logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"]))
+                myvims[datacenter_key] = None
+            else:
+                myvims[datacenter_key] = vims.values()[0]
         for vm in sce_vnf['vms']:
-            vm_list.append(vm['vim_vm_id'])
+            vm_list[datacenter_key].append(vm['vim_vm_id'])
             vms_notupdated.append(vm["uuid"])
 
     nets_updated = [] #List of VM instance uuids in openmano that were updated
     nets_notupdated=[]
-    net_list=[]
+    net_list = {}
     for net in instanceDict['nets']:
-        net_list.append(net['vim_net_id'])
+        datacenter_key = (net["datacenter_id"], net["datacenter_tenant_id"])
+        if datacenter_key not in net_list:
+            net_list[datacenter_key] = []
+        if datacenter_key not in myvims:
+            vims = get_vim(mydb, nfvo_tenant, datacenter_id=net["datacenter_id"],
+                           datacenter_tenant_id=net["datacenter_tenant_id"])
+            if len(vims) == 0:
+                logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"]))
+                myvims[datacenter_key] = None
+            else:
+                myvims[datacenter_key] = vims.values()[0]
+
+        net_list[datacenter_key].append(net['vim_net_id'])
         nets_notupdated.append(net["uuid"])
 
-    try:
-        # 1. Getting the status of all VMs
-        vm_dict = myvim.refresh_vms_status(vm_list)
+    # 1. Getting the status of all VMs
+    vm_dict={}
+    for datacenter_key in myvims:
+        if not vm_list.get(datacenter_key):
+            continue
+        failed = True
+        failed_message=""
+        if not myvims[datacenter_key]:
+            failed_message = "datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"])
+        else:
+            try:
+                vm_dict.update(myvims[datacenter_key].refresh_vms_status(vm_list[datacenter_key]) )
+                failed = False
+            except vimconn.vimconnException as e:
+                logger.error("VIM exception %s %s", type(e).__name__, str(e))
+                failed_message = str(e)
+        if failed:
+            for vm in vm_list[datacenter_key]:
+                vm_dict[vm] = {'status': "VIM_ERROR", 'error_msg': failed_message}
 
-        # 2. Update the status of VMs in the instanceDict, while collects the VMs whose status changed     
-        for sce_vnf in instanceDict['vnfs']:
-            for vm in sce_vnf['vms']:
-                vm_id = vm['vim_vm_id']
-                interfaces = vm_dict[vm_id].pop('interfaces', [])
-                #2.0 look if contain manamgement interface, and if not change status from ACTIVE:NoMgmtIP to ACTIVE
-                has_mgmt_iface = False
-                for iface in vm["interfaces"]:
-                    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"
-                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')
-                    vm['vim_info']  = vm_dict[vm_id].get('vim_info')
-                    # 2.1. Update in openmano DB the VMs whose status changed
-                    try: 
-                        updates = mydb.update_rows('instance_vms', UPDATE=vm_dict[vm_id], WHERE={'uuid':vm["uuid"]})
-                        vms_notupdated.remove(vm["uuid"])
-                        if updates>0:
-                            vms_updated.append(vm["uuid"])  
-                    except db_base_Exception as e:
-                        logger.error("nfvo.refresh_instance error database update: %s", str(e))
-                # 2.2. Update in openmano DB the interface VMs
-                for interface in interfaces:
-                    #translate from vim_net_id to instance_net_id
-                    network_id_list=[]
-                    for net in instanceDict['nets']:
-                        if net["vim_net_id"] == interface["vim_net_id"]:
-                            network_id_list.append(net["uuid"])
-                    if not network_id_list:
-                        continue
-                    del interface["vim_net_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)        
-        
-        # 3. Getting the status of all nets
-        net_dict = myvim.refresh_nets_status(net_list)
-
-        # 4. Update the status of nets in the instanceDict, while collects the nets whose status changed     
-        # TODO: update nets inside a vnf  
-        for net in instanceDict['nets']:
-            net_id = net['vim_net_id']
-            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')
-                net['vim_info']  = net_dict[net_id].get('vim_info')
-                # 5.1. Update in openmano DB the nets whose status changed
+    # 2. Update the status of VMs in the instanceDict, while collects the VMs whose status changed
+    for sce_vnf in instanceDict['vnfs']:
+        for vm in sce_vnf['vms']:
+            vm_id = vm['vim_vm_id']
+            interfaces = vm_dict[vm_id].pop('interfaces', [])
+            #2.0 look if contain manamgement interface, and if not change status from ACTIVE:NoMgmtIP to ACTIVE
+            has_mgmt_iface = False
+            for iface in vm["interfaces"]:
+                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"
+            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')
+                vm['vim_info']  = vm_dict[vm_id].get('vim_info')
+                # 2.1. Update in openmano DB the VMs whose status changed
                 try:
-                    updated = mydb.update_rows('instance_nets', UPDATE=net_dict[net_id], WHERE={'uuid':net["uuid"]})
-                    nets_notupdated.remove(net["uuid"])
-                    if updated>0:
-                        nets_updated.append(net["uuid"])  
+                    updates = mydb.update_rows('instance_vms', UPDATE=vm_dict[vm_id], WHERE={'uuid':vm["uuid"]})
+                    vms_notupdated.remove(vm["uuid"])
+                    if updates>0:
+                        vms_updated.append(vm["uuid"])
                 except db_base_Exception as e:
                     logger.error("nfvo.refresh_instance error database update: %s", str(e))
-    except vimconn.vimconnException as e:
-        #logger.error("VIM exception %s %s", type(e).__name__, str(e))
-        raise NfvoException(str(e), e.http_code)
+            # 2.2. Update in openmano DB the interface VMs
+            for interface in interfaces:
+                #translate from vim_net_id to instance_net_id
+                network_id_list=[]
+                for net in instanceDict['nets']:
+                    if net["vim_net_id"] == interface["vim_net_id"]:
+                        network_id_list.append(net["uuid"])
+                if not network_id_list:
+                    continue
+                del interface["vim_net_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)
+
+    # 3. Getting the status of all nets
+    net_dict = {}
+    for datacenter_key in myvims:
+        if not net_list.get(datacenter_key):
+            continue
+        failed = True
+        failed_message = ""
+        if not myvims[datacenter_key]:
+            failed_message = "datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"])
+        else:
+            try:
+                net_dict.update(myvims[datacenter_key].refresh_nets_status(net_list[datacenter_key]) )
+                failed = False
+            except vimconn.vimconnException as e:
+                logger.error("VIM exception %s %s", type(e).__name__, str(e))
+                failed_message = str(e)
+        if failed:
+            for net in net_list[datacenter_key]:
+                net_dict[net] = {'status': "VIM_ERROR", 'error_msg': failed_message}
+
+    # 4. Update the status of nets in the instanceDict, while collects the nets whose status changed
+    # TODO: update nets inside a vnf
+    for net in instanceDict['nets']:
+        net_id = net['vim_net_id']
+        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')
+            net['vim_info']  = net_dict[net_id].get('vim_info')
+            # 5.1. Update in openmano DB the nets whose status changed
+            try:
+                updated = mydb.update_rows('instance_nets', UPDATE=net_dict[net_id], WHERE={'uuid':net["uuid"]})
+                nets_notupdated.remove(net["uuid"])
+                if updated>0:
+                    nets_updated.append(net["uuid"])
+            except db_base_Exception as e:
+                logger.error("nfvo.refresh_instance error database update: %s", str(e))
 
     # Returns appropriate output
     #print "nfvo.refresh_instance finishes"
@@ -2355,18 +2411,7 @@
 
 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, vim_tenant_name=vim_tenant_name, vim_user=vim_username, vim_passwd=vim_password)
-    else:
-        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:
-        #print "nfvo.datacenter_action() error. Several datacenters found"
-        raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict)
-
-    datacenter_id=vims.keys()[0]
-    myvim=vims[datacenter_id]
+    datacenter_id, myvim  = get_datacenter_by_name_uuid(mydb, None, datacenter)
     datacenter_name=myvim["name"]
     
     create_vim_tenant=True if vim_tenant_id==None and vim_tenant_name==None else False
@@ -2424,17 +2469,7 @@
 
 def deassociate_datacenter_to_tenant(mydb, tenant_id, datacenter, vim_tenant_id=None):
     #get datacenter info
-    if utils.check_valid_uuid(datacenter): 
-        vims = get_vim(mydb, datacenter_id=datacenter)
-    else:
-        vims = get_vim(mydb, datacenter_name=datacenter)
-    if len(vims) == 0:
-        raise NfvoException("datacenter '{}' not found".format(str(datacenter)), 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)
-    datacenter_id=vims.keys()[0]
-    myvim=vims[datacenter_id]
+    datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, None, datacenter)
 
     #get nfvo_tenant info
     if not tenant_id or tenant_id=="any":
@@ -2477,17 +2512,7 @@
 def datacenter_action(mydb, tenant_id, datacenter, action_dict):
     #DEPRECATED
     #get datacenter info    
-    if utils.check_valid_uuid(datacenter): 
-        vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_id=datacenter)
-    else:
-        vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_name=datacenter)
-    if len(vims) == 0:
-        raise NfvoException("datacenter '{}' not found".format(str(datacenter)), 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)
-    datacenter_id=vims.keys()[0]
-    myvim=vims[datacenter_id]
+    datacenter_id, myvim  = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
 
     if 'net-update' in action_dict:
         try:
@@ -2528,16 +2553,7 @@
 
 def datacenter_edit_netmap(mydb, tenant_id, datacenter, netmap, action_dict):
     #get datacenter info
-    if utils.check_valid_uuid(datacenter): 
-        vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_id=datacenter)
-    else:
-        vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_name=datacenter)
-    if len(vims) == 0:
-        raise NfvoException("datacenter '{}' not found".format(str(datacenter)), 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)
-    datacenter_id=vims.keys()[0]
+    datacenter_id, _  = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
 
     what = 'uuid' if utils.check_valid_uuid(netmap) else 'name'
     result = mydb.update_rows('datacenter_nets', action_dict['netmap'], 
@@ -2546,17 +2562,7 @@
 
 def datacenter_new_netmap(mydb, tenant_id, datacenter, action_dict=None):
     #get datacenter info
-    if utils.check_valid_uuid(datacenter): 
-        vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_id=datacenter)
-    else:
-        vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_name=datacenter)
-    if len(vims) == 0:
-        raise NfvoException("datacenter '{}' not found".format(datacenter), HTTP_Not_Found)
-    elif len(vims)>1:
-        #logger.error("nfvo.datacenter_new_netmap() error. Several datacenters found")
-        raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict)
-    datacenter_id=vims.keys()[0]
-    myvim=vims[datacenter_id]
+    datacenter_id, myvim  = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
     filter_dict={}
     if action_dict:
         action_dict = action_dict["netmap"]
@@ -2602,17 +2608,7 @@
 
 def vim_action_get(mydb, tenant_id, datacenter, item, name):
     #get datacenter info
-    if utils.check_valid_uuid(datacenter): 
-        vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_id=datacenter)
-    else:
-        vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_name=datacenter)
-    if len(vims) == 0:
-        raise NfvoException("datacenter '{}' not found".format(datacenter), HTTP_Not_Found)
-    elif len(vims)>1:
-        #logger.error("nfvo.datacenter_new_netmap() error. Several datacenters found")
-        raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict)
-    datacenter_id=vims.keys()[0]
-    myvim=vims[datacenter_id]
+    datacenter_id, myvim  = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
     filter_dict={}
     if name:
         if utils.check_valid_uuid(name):
@@ -2644,17 +2640,7 @@
     if tenant_id == "any":
         tenant_id=None
 
-    if utils.check_valid_uuid(datacenter): 
-        vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_id=datacenter)
-    else:
-        vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_name=datacenter)
-    if len(vims) == 0:
-        raise NfvoException("datacenter '{}' not found".format(datacenter), HTTP_Not_Found)
-    elif len(vims)>1:
-        #logger.error("nfvo.datacenter_new_netmap() error. Several datacenters found")
-        raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict)
-    datacenter_id=vims.keys()[0]
-    myvim=vims[datacenter_id]
+    datacenter_id, myvim  = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
     #get uuid name
     content = vim_action_get(mydb, tenant_id, datacenter, item, name)
     logger.debug("vim_action_delete vim response: " + str(content))
@@ -2682,22 +2668,10 @@
     
 def vim_action_create(mydb, tenant_id, datacenter, item, descriptor):
     #get datacenter info
-    print "vim_action_create descriptor", descriptor
+    logger.debug("vim_action_create descriptor %s", str(descriptor))
     if tenant_id == "any":
         tenant_id=None
-
-    if utils.check_valid_uuid(datacenter): 
-        vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_id=datacenter)
-    else:
-        vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_name=datacenter)
-    if len(vims) == 0:
-        raise NfvoException("datacenter '{}' not found".format(datacenter), HTTP_Not_Found)
-    elif len(vims)>1:
-        #logger.error("nfvo.datacenter_new_netmap() error. Several datacenters found")
-        raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict)
-    datacenter_id=vims.keys()[0]
-    myvim=vims[datacenter_id]
-    
+    datacenter_id, myvim  = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
     try:
         if item=="networks":
             net = descriptor["network"]
diff --git a/nfvo_db.py b/nfvo_db.py
index 9d3b648..1fa5d72 100644
--- a/nfvo_db.py
+++ b/nfvo_db.py
@@ -44,7 +44,6 @@
         db_base.db_base.tables_with_created_field=tables_with_createdat_field
         return
 
-
     def new_vnf_as_a_whole(self,nfvo_tenant,vnf_name,vnf_descriptor,VNFCDict):
         self.logger.debug("Adding new vnf to the NFVO database")
         tries = 2
@@ -707,7 +706,6 @@
                 self._format_error(e, tries)
             tries -= 1
 
-
     def delete_scenario(self, scenario_id, tenant_id=None):
         '''Deletes a scenario, filtering by one or several of the tenant, uuid or name
         scenario_id is the uuid or the name if it is not a valid uuid format
@@ -752,10 +750,9 @@
                 with self.con:
                     self.cur = self.con.cursor()
                     #instance_scenarios
-                    datacenter_tenant_id = scenarioDict['datacenter_tenant_id']
                     datacenter_id = scenarioDict['datacenter_id']
                     INSERT_={'tenant_id': tenant_id,
-                        'datacenter_tenant_id': datacenter_tenant_id,
+                        'datacenter_tenant_id': scenarioDict["datacenter2tenant"][datacenter_id],
                         'name': instance_scenario_name,
                         'description': instance_scenario_description,
                         'scenario_id' : scenarioDict['uuid'],
@@ -773,12 +770,13 @@
                         datacenter_site_id = net.get('datacenter_id', datacenter_id)
                         if not "vim_id_sites" in net:
                             net["vim_id_sites"] ={datacenter_site_id: net['vim_id']}
+                            net["vim_id_sites"]["datacenter_site_id"] = {datacenter_site_id: net['vim_id']}
                         sce_net_id = net.get("uuid")
                         
                         for datacenter_site_id,vim_id in net["vim_id_sites"].iteritems():
                             INSERT_={'vim_net_id': vim_id, 'created': net.get('created', False), 'instance_scenario_id':instance_uuid } #,  'type': net['type']
                             INSERT_['datacenter_id'] = datacenter_site_id 
-                            INSERT_['datacenter_tenant_id'] = net.get('datacenter_tenant_id', datacenter_tenant_id) #TODO revise
+                            INSERT_['datacenter_tenant_id'] = scenarioDict["datacenter2tenant"][datacenter_site_id]
                             if sce_net_id:
                                 INSERT_['sce_net_id'] = sce_net_id
                             created_time += 0.00001
@@ -796,10 +794,9 @@
                     #instance_vnfs
                     for vnf in scenarioDict['vnfs']:
                         datacenter_site_id = vnf.get('datacenter_id', datacenter_id)
-                        datacenter_site_tenant_id = vnf.get('datacenter_tenant_id', datacenter_id)
                         INSERT_={'instance_scenario_id': instance_uuid,  'vnf_id': vnf['vnf_id']  }
                         INSERT_['datacenter_id'] = datacenter_site_id 
-                        INSERT_['datacenter_tenant_id'] = datacenter_site_tenant_id #TODO revise
+                        INSERT_['datacenter_tenant_id'] = scenarioDict["datacenter2tenant"][datacenter_site_id]
                         if vnf.get("uuid"):
                             INSERT_['sce_vnf_id'] = vnf['uuid']
                         created_time += 0.00001
@@ -811,7 +808,7 @@
                             net_scene2instance[ net['uuid'] ] = {}
                             INSERT_={'vim_net_id': net['vim_id'], 'created': net.get('created', False), 'instance_scenario_id':instance_uuid  } #,  'type': net['type']
                             INSERT_['datacenter_id'] = net.get('datacenter_id', datacenter_site_id) 
-                            INSERT_['datacenter_tenant_id'] = net.get('datacenter_tenant_id', datacenter_site_tenant_id)
+                            INSERT_['datacenter_tenant_id'] = scenarioDict["datacenter2tenant"][datacenter_id]
                             if net.get("uuid"):
                                 INSERT_['net_id'] = net['uuid']
                             created_time += 0.00001
diff --git a/openmanod.py b/openmanod.py
index 6df29d1..7d183eb 100755
--- a/openmanod.py
+++ b/openmanod.py
@@ -33,8 +33,8 @@
 '''
 __author__="Alfonso Tierno, Gerardo Garcia, Pablo Montes"
 __date__ ="$26-aug-2014 11:09:29$"
-__version__="0.4.60-r503"
-version_date="Sep 2016"
+__version__="0.5.0-r507"
+version_date="Oct 2016"
 database_version="0.15"      #expected database schema version
 
 import httpserver
diff --git a/scripts/install-openmano.sh b/scripts/install-openmano.sh
index 9aaf028..85d3293 100755
--- a/scripts/install-openmano.sh
+++ b/scripts/install-openmano.sh
@@ -264,7 +264,8 @@
 #####        DOWNLOAD SOURCE                                #####
 #################################################################'
     su $SUDO_USER -c 'git clone '"${GIT_URL}"' openmano'
-    #[[ -z $DEVELOP ]] && su $SUDO_USER -c 'git checkout <tag version>'
+    su $SUDO_USER -c 'cp openmano/.gitignore-common openmano/.gitignore'
+    [[ -z $DEVELOP ]] && su $SUDO_USER -c 'git checkout tags/v1.0' 
 fi
 
 echo '
diff --git a/test/basictest.sh b/test/basictest.sh
index 5fff3c5..5b7dca5 100755
--- a/test/basictest.sh
+++ b/test/basictest.sh
@@ -167,7 +167,7 @@
     [[ -z $OPENVIM_HOST ]] && OPENVIM_HOST=localhost
     [[ -z $OPENVIM_PORT ]] && OPENVIM_PORT=9080
     URL_ADMIN_PARAM=""
-    [[ -n $OPENVIM_ADMIN_PORT ]] && URL_ADMIN_PARAM="--url_admin=http://${$OPENVIM_HOST}:${OPENVIM_ADMIN_PORT}/openvim"
+    [[ -n $OPENVIM_ADMIN_PORT ]] && URL_ADMIN_PARAM="--url_admin=http://${OPENVIM_HOST}:${OPENVIM_ADMIN_PORT}/openvim"
     result=`${DIRmano}/openmano datacenter-create TEST-dc "http://${OPENVIM_HOST}:${OPENVIM_PORT}/openvim" --type=openvim $URL_ADMIN_PARAM`
     datacenter=`echo $result |gawk '{print $1}'`
     #check a valid uuid is obtained
diff --git a/test/test_vimconn.sh b/test/test_vimconn.sh
index aedf20a..7542d6c 100755
--- a/test/test_vimconn.sh
+++ b/test/test_vimconn.sh
@@ -268,13 +268,8 @@
     #USER_KEY=""
     key_param1=""
     key_param2=""
-    #for file_key in ${HOME}/.ssh/*.pub
-    #do
-    #    [[ -n ${USER_KEY} ]] && USER_KEY="${USER_KEY},"
-    #    USER_KEY="${USER_KEY}$(cat $file_key)"
-    #done
-    #[[  -n ${USER_KEY} ]] && key_param1="--keypair=${USER}:${USER_KEY}" && key_param2="--keypair=${USER_KEY}"
-    key_param1=--keypair-auto
+    #add user keys if present at .ssh    
+    ls ${HOME}/.ssh/*.pub > /dev/null 2>&1 && key_param1=--keypair-auto
 
     for sce in simple complex2
     do