X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=nfvo.py;h=3ea510773a65d75ee44a266db4ee012c8130c9ed;hb=b12711fda02f2bac40a2cc1adfb5a27675bbad61;hp=4565f00a164c2d036ce8905600d5000a0285e206;hpb=5bb59dc875caf2d71aad5e5e38ab3f63f4c73607;p=osm%2FRO.git diff --git a/nfvo.py b/nfvo.py index 4565f00a..3ea51077 100644 --- a/nfvo.py +++ b/nfvo.py @@ -40,16 +40,29 @@ import logging import collections from db_base import db_base_Exception +import nfvo_db +from threading import Lock +from time import time +import ovim as ovim_module + global global_config global vimconn_imported global logger global default_volume_size default_volume_size = '5' #size in GB - +global ovim +ovim = None +global_config = None vimconn_imported = {} # dictionary with VIM type as key, loaded module as value vim_threads = {"running":{}, "deleting": {}, "names": []} # threads running for attached-VIMs +vim_persistent_info = {} logger = logging.getLogger('openmano.nfvo') +task_lock = Lock() +global_instance_tasks = {} +last_task_id = 0.0 +db=None +db_lock=Lock() class NfvoException(Exception): def __init__(self, message, http_code): @@ -57,12 +70,33 @@ class NfvoException(Exception): Exception.__init__(self, message) +def get_task_id(): + global last_task_id + task_id = time() + if task_id <= last_task_id: + task_id = last_task_id + 0.000001 + last_task_id = task_id + return "TASK.{:.6f}".format(task_id) + + +def new_task(name, params, depends=None): + task_id = get_task_id() + task = {"status": "enqueued", "id": task_id, "name": name, "params": params} + if depends: + task["depends"] = depends + return task + + +def is_task_id(id): + return True if id[:5] == "TASK." else False + + def get_non_used_vim_name(datacenter_name, datacenter_id, tenant_name, tenant_id): name = datacenter_name[:16] if name not in vim_threads["names"]: vim_threads["names"].append(name) return name - name = datatacenter_name[:16] + "." + tenant_name[:16] + name = datacenter_name[:16] + "." + tenant_name[:16] if name not in vim_threads["names"]: vim_threads["names"].append(name) return name @@ -72,6 +106,31 @@ def get_non_used_vim_name(datacenter_name, datacenter_id, tenant_name, tenant_id def start_service(mydb): + global db, global_config + db = nfvo_db.nfvo_db() + db.connect(global_config['db_host'], global_config['db_user'], global_config['db_passwd'], global_config['db_name']) + global ovim + + # Initialize openvim for SDN control + # TODO: Avoid static configuration by adding new parameters to openmanod.cfg + # TODO: review ovim.py to delete not needed configuration + ovim_configuration = { + 'logger_name': 'openmano.ovim', + 'network_vlan_range_start': 1000, + 'network_vlan_range_end': 4096, + 'db_name': global_config["db_ovim_name"], + 'db_host': global_config["db_ovim_host"], + 'db_user': global_config["db_ovim_user"], + 'db_passwd': global_config["db_ovim_passwd"], + 'bridge_ifaces': {}, + 'mode': 'normal', + 'network_type': 'bridge', + #TODO: log_level_of should not be needed. To be modified in ovim + 'log_level_of': 'DEBUG' + } + ovim = ovim_module.ovim(ovim_configuration) + ovim.start_service() + 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','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', @@ -79,7 +138,8 @@ def start_service(mydb): try: vims = mydb.get_rows(FROM=from_, SELECT=select_) for vim in vims: - extra={'datacenter_tenant_id': vim.get('datacenter_tenant_id')} + extra={'datacenter_tenant_id': vim.get('datacenter_tenant_id'), + 'datacenter_id': vim.get('datacenter_id')} if vim["config"]: extra.update(yaml.load(vim["config"])) if vim.get('dt_config'): @@ -95,33 +155,43 @@ def start_service(mydb): if module_info and module_info[0]: file.close(module_info[0]) raise NfvoException("Unknown vim type '{}'. Can not open file '{}.py'; {}: {}".format( - vim["type"], module, type(e).__name__, str(e)), HTTP_Bad_Request) + vim["type"], module, type(e).__name__, str(e)), HTTP_Bad_Request) + thread_id = vim['datacenter_tenant_id'] + vim_persistent_info[thread_id] = {} try: #if not tenant: # return -HTTP_Bad_Request, "You must provide a valid tenant name or uuid for VIM %s" % ( vim["type"]) myvim = vimconn_imported[ vim["type"] ].vimconnector( - uuid=vim['datacenter_id'], name=vim['datacenter_name'], - tenant_id=vim['vim_tenant_id'], tenant_name=vim['vim_tenant_name'], - url=vim['vim_url'], url_admin=vim['vim_url_admin'], - user=vim['user'], passwd=vim['passwd'], - config=extra - ) + uuid=vim['datacenter_id'], name=vim['datacenter_name'], + tenant_id=vim['vim_tenant_id'], tenant_name=vim['vim_tenant_name'], + url=vim['vim_url'], url_admin=vim['vim_url_admin'], + user=vim['user'], passwd=vim['passwd'], + config=extra, persistent_info=vim_persistent_info[thread_id] + ) except Exception as e: raise NfvoException("Error at VIM {}; {}: {}".format(vim["type"], type(e).__name__, str(e)), HTTP_Internal_Server_Error) thread_name = get_non_used_vim_name(vim['datacenter_name'], vim['vim_tenant_id'], vim['vim_tenant_name'], vim['vim_tenant_id']) - new_thread = vim_thread.vim_thread(myvim, thread_name) + new_thread = vim_thread.vim_thread(myvim, task_lock, thread_name, vim['datacenter_name'], + vim['datacenter_tenant_id'], db=db, db_lock=db_lock, ovim=ovim) new_thread.start() - thread_id = vim["datacenter_id"] + "-" + vim['nfvo_tenant_id'] vim_threads["running"][thread_id] = new_thread except db_base_Exception as e: raise NfvoException(str(e) + " at nfvo.get_vim", e.http_code) + def stop_service(): + global ovim, global_config + if ovim: + ovim.stop_service() for thread_id,thread in vim_threads["running"].items(): - thread.insert_task("exit") + thread.insert_task(new_task("exit", None)) vim_threads["deleting"][thread_id] = thread - vim_threads["running"]={} + vim_threads["running"] = {} + if global_config and global_config.get("console_thread"): + for thread in global_config["console_thread"]: + thread.terminate = True + def get_flavorlist(mydb, vnf_id, nfvo_tenant=None): '''Obtain flavorList @@ -144,6 +214,7 @@ def get_flavorlist(mydb, vnf_id, nfvo_tenant=None): flavorList.append(flavor['flavor_id']) return flavorList + def get_imagelist(mydb, vnf_id, nfvo_tenant=None): '''Obtain imageList return result, content: @@ -162,6 +233,7 @@ def get_imagelist(mydb, vnf_id, nfvo_tenant=None): imageList.append(image['image_id']) return imageList + def get_vim(mydb, nfvo_tenant=None, datacenter_id=None, datacenter_name=None, 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 @@ -188,7 +260,8 @@ def get_vim(mydb, nfvo_tenant=None, datacenter_id=None, datacenter_name=None, da vims = mydb.get_rows(FROM=from_, SELECT=select_, WHERE=WHERE_dict ) vim_dict={} for vim in vims: - extra={'datacenter_tenant_id': vim.get('datacenter_tenant_id')} + extra={'datacenter_tenant_id': vim.get('datacenter_tenant_id'), + 'datacenter_id': vim.get('datacenter_id')} if vim["config"]: extra.update(yaml.load(vim["config"])) if vim.get('dt_config'): @@ -207,14 +280,22 @@ def get_vim(mydb, nfvo_tenant=None, datacenter_id=None, datacenter_name=None, da vim["type"], module, type(e).__name__, str(e)), HTTP_Bad_Request) try: + if 'datacenter_tenant_id' in vim: + thread_id = vim["datacenter_tenant_id"] + if thread_id not in vim_persistent_info: + vim_persistent_info[thread_id] = {} + persistent_info = vim_persistent_info[thread_id] + else: + persistent_info = {} #if not tenant: # return -HTTP_Bad_Request, "You must provide a valid tenant name or uuid for VIM %s" % ( vim["type"]) vim_dict[ vim['datacenter_id'] ] = vimconn_imported[ vim["type"] ].vimconnector( uuid=vim['datacenter_id'], name=vim['datacenter_name'], - tenant_id=vim.get('vim_tenant_id',vim_tenant), tenant_name=vim.get('vim_tenant_name',vim_tenant_name), + tenant_id=vim.get('vim_tenant_id',vim_tenant), + tenant_name=vim.get('vim_tenant_name',vim_tenant_name), url=vim['vim_url'], url_admin=vim['vim_url_admin'], user=vim.get('user',vim_user), passwd=vim.get('passwd',vim_passwd), - config=extra + config=extra, persistent_info=persistent_info ) except Exception as e: raise NfvoException("Error at VIM {}; {}: {}".format(vim["type"], type(e).__name__, str(e)), HTTP_Internal_Server_Error) @@ -222,6 +303,7 @@ def get_vim(mydb, nfvo_tenant=None, datacenter_id=None, datacenter_name=None, da except db_base_Exception as e: raise NfvoException(str(e) + " at nfvo.get_vim", e.http_code) + def rollback(mydb, vims, rollback_list): undeleted_items=[] #delete things by reverse order @@ -262,6 +344,7 @@ def rollback(mydb, vims, rollback_list): else: return False," Rollback fails to delete: " + str(undeleted_items) + def check_vnf_descriptor(vnf_descriptor, vnf_descriptor_version=1): global global_config #create a dictionary with vnfc-name: vnfc:interface-list key:values pairs @@ -458,6 +541,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 = None): temp_flavor_dict= {'disk':flavor_dict.get('disk',1), 'ram':flavor_dict.get('ram'), @@ -610,6 +694,7 @@ def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_ return flavor_vim_id if only_create_at_vim else flavor_mano_id + def new_vnf(mydb, tenant_id, vnf_descriptor): global global_config @@ -744,6 +829,7 @@ def new_vnf(mydb, tenant_id, vnf_descriptor): #logger.error("start_scenario %s", error_text) raise NfvoException(error_text, e.http_code) + def new_vnf_v02(mydb, tenant_id, vnf_descriptor): global global_config @@ -877,6 +963,7 @@ def new_vnf_v02(mydb, tenant_id, vnf_descriptor): #logger.error("start_scenario %s", error_text) raise NfvoException(error_text, e.http_code) + def get_vnf_id(mydb, tenant_id, vnf_id): #check valid tenant_id check_tenant(mydb, tenant_id) @@ -1034,6 +1121,7 @@ def delete_vnf(mydb,tenant_id,vnf_id,datacenter=None,vim_tenant=None): #if undeletedItems: # return "delete_vnf. Undeleted: %s" %(undeletedItems) + def get_hosts_info(mydb, nfvo_tenant_id, datacenter_name=None): result, vims = get_vim(mydb, nfvo_tenant_id, None, datacenter_name) if result < 0: @@ -1047,6 +1135,7 @@ def get_hosts_info(mydb, nfvo_tenant_id, datacenter_name=None): topology = {'name':myvim['name'] , 'servers': servers} return result, topology + def get_hosts(mydb, nfvo_tenant_id): vims = get_vim(mydb, nfvo_tenant_id) if len(vims) == 0: @@ -1082,6 +1171,7 @@ def get_hosts(mydb, nfvo_tenant_id): except vimconn.vimconnException as e: raise NfvoException("Not possible to get_host_list from VIM: {}".format(str(e)), e.http_code) + def new_scenario(mydb, tenant_id, topo): # result, vims = get_vim(mydb, tenant_id) @@ -1365,6 +1455,7 @@ def new_scenario(mydb, tenant_id, topo): return c + def new_scenario_v02(mydb, tenant_id, scenario_dict, version): """ This creates a new scenario for version 0.2 and 0.3""" scenario = scenario_dict["scenario"] @@ -1488,12 +1579,14 @@ def new_scenario_v02(mydb, tenant_id, scenario_dict, version): scenario_id = mydb.new_scenario(scenario) return scenario_id + def edit_scenario(mydb, tenant_id, scenario_id, data): data["uuid"] = scenario_id data["tenant_id"] = tenant_id c = mydb.edit_scenario( data ) return c + 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, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter, vim_tenant=vim_tenant) @@ -1696,6 +1789,7 @@ 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_preserve, cloud_config): ''' join the cloud config information into cloud_config_preserve. In case of conflict cloud_config_preserve preserves @@ -1772,6 +1866,40 @@ def unify_cloud_config(cloud_config_preserve, cloud_config): return new_cloud_config +def get_vim_thread(mydb, tenant_id, datacenter_id_name=None, datacenter_tenant_id=None): + datacenter_id = None + datacenter_name = None + thread = None + try: + if datacenter_tenant_id: + thread_id = datacenter_tenant_id + thread = vim_threads["running"].get(datacenter_tenant_id) + else: + where_={"td.nfvo_tenant_id": tenant_id} + if datacenter_id_name: + if utils.check_valid_uuid(datacenter_id_name): + datacenter_id = datacenter_id_name + where_["dt.datacenter_id"] = datacenter_id + else: + datacenter_name = datacenter_id_name + where_["d.name"] = datacenter_name + if datacenter_tenant_id: + where_["dt.uuid"] = datacenter_tenant_id + datacenters = mydb.get_rows( + SELECT=("dt.uuid as datacenter_tenant_id",), + FROM="datacenter_tenants as dt join tenants_datacenters as td on dt.uuid=td.datacenter_tenant_id " + "join datacenters as d on d.uuid=dt.datacenter_id", + WHERE=where_) + if len(datacenters) > 1: + raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict) + elif datacenters: + thread_id = datacenters[0]["datacenter_tenant_id"] + thread = vim_threads["running"].get(thread_id) + if not thread: + raise NfvoException("datacenter '{}' not found".format(str(datacenter_id_name)), HTTP_Not_Found) + return thread_id, thread + except db_base_Exception as e: + raise NfvoException("{} {}".format(type(e).__name__ , str(e)), e.http_code) def get_datacenter_by_name_uuid(mydb, tenant_id, datacenter_id_name=None, **extra_filter): datacenter_id = None @@ -1789,6 +1917,7 @@ def get_datacenter_by_name_uuid(mydb, tenant_id, datacenter_id_name=None, **extr raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict) return vims.keys()[0], vims.values()[0] + def update(d, u): '''Takes dict d and updates it with the values in dict u.''' '''It merges all depth levels''' @@ -1800,18 +1929,22 @@ def update(d, u): d[k] = u[k] return d + def create_instance(mydb, tenant_id, instance_dict): - #print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id" - #logger.debug("Creating instance...") + # print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id" + # logger.debug("Creating instance...") scenario = instance_dict["scenario"] #find main datacenter myvims = {} - datacenter2tenant = {} + myvim_threads_id = {} + instance_tasks={} + tasks_to_launch={} 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_threads_id[default_datacenter_id], _ = get_vim_thread(mydb, tenant_id, default_datacenter_id) + tasks_to_launch[myvim_threads_id[default_datacenter_id]] = [] #myvim_tenant = myvim['tenant_id'] # default_datacenter_name = vim['name'] rollbackList=[] @@ -1832,9 +1965,9 @@ def create_instance(mydb, tenant_id, instance_dict): instance_name = instance_dict["name"] instance_description = instance_dict.get("description") try: - #0 check correct parameters + # 0 check correct parameters for net_name, net_instance_desc in instance_dict.get("networks",{}).iteritems(): - found=False + found = False for scenario_net in scenarioDict['nets']: if net_name == scenario_net["name"]: found = True @@ -1850,13 +1983,14 @@ def create_instance(mydb, tenant_id, instance_dict): #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 + myvim_threads_id[d],_ = get_vim_thread(mydb, tenant_id, site["datacenter"]) + tasks_to_launch[myvim_threads_id[d]] = [] + site["datacenter"] = d #change name to id else: if site_without_datacenter_field: raise NfvoException("Found more than one entries without datacenter field at instance:networks:{}:sites".format(net_name), HTTP_Bad_Request) site_without_datacenter_field = True - site["datacenter"] = default_datacenter_id #change name to id + site["datacenter"] = default_datacenter_id #change name to id for vnf_name, vnf_instance_desc in instance_dict.get("vnfs",{}).iteritems(): found=False @@ -1867,11 +2001,12 @@ def create_instance(mydb, tenant_id, instance_dict): if not found: raise NfvoException("Invalid vnf name '{}' at instance:vnfs".format(vnf_instance_desc), HTTP_Bad_Request) if "datacenter" in vnf_instance_desc: - #Add this datacenter to myvims + # Add this datacenter to myvims if vnf_instance_desc["datacenter"] not in myvims: d, v = get_datacenter_by_name_uuid(mydb, tenant_id, vnf_instance_desc["datacenter"]) myvims[d] = v - datacenter2tenant[d] = v['config']['datacenter_tenant_id'] + myvim_threads_id[d],_ = get_vim_thread(mydb, tenant_id, vnf_instance_desc["datacenter"]) + tasks_to_launch[myvim_threads_id[d]] = [] scenario_vnf["datacenter"] = vnf_instance_desc["datacenter"] #0.1 parse cloud-config parameters @@ -1910,7 +2045,7 @@ def create_instance(mydb, tenant_id, instance_dict): logger.debug("Creating instance scenario-dict MERGED:\n%s", yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False)) - #1. Creating new nets (sce_nets) in the VIM" + # 1. Creating new nets (sce_nets) in the VIM" for sce_net in scenarioDict['nets']: sce_net["vim_id_sites"]={} descriptor_net = instance_dict.get("networks",{}).get(sce_net["name"],{}) @@ -1922,9 +2057,11 @@ def create_instance(mydb, tenant_id, instance_dict): if site.get("datacenter"): vim = myvims[ site["datacenter"] ] datacenter_id = site["datacenter"] + myvim_thread_id = myvim_threads_id[ site["datacenter"] ] else: vim = myvims[ default_datacenter_id ] datacenter_id = default_datacenter_id + myvim_thread_id = myvim_threads_id[default_datacenter_id] net_type = sce_net['type'] lookfor_filter = {'admin_state_up': True, 'status': 'ACTIVE'} #'shared': True if sce_net["external"]: @@ -1982,48 +2119,60 @@ def create_instance(mydb, tenant_id, instance_dict): create_network = False if create_network: #if network is not external - network_id = vim.new_network(net_vim_name, net_type, sce_net.get('ip_profile',None)) - sce_net["vim_id_sites"][datacenter_id] = network_id - auxNetDict['scenario'][sce_net['uuid']][datacenter_id] = network_id - rollbackList.append({'what':'network', 'where':'vim', 'vim_id':datacenter_id, 'uuid':network_id}) + task = new_task("new-net", (net_vim_name, net_type, sce_net.get('ip_profile',None))) + task_id = task["id"] + instance_tasks[task_id] = task + tasks_to_launch[myvim_thread_id].append(task) + #network_id = vim.new_network(net_vim_name, net_type, sce_net.get('ip_profile',None)) + sce_net["vim_id_sites"][datacenter_id] = task_id + auxNetDict['scenario'][sce_net['uuid']][datacenter_id] = task_id + rollbackList.append({'what':'network', 'where':'vim', 'vim_id':datacenter_id, 'uuid':task_id}) sce_net["created"] = True - #2. Creating new nets (vnf internal nets) in the VIM" + # 2. Creating new nets (vnf internal nets) in the VIM" #For each vnf net, we create it and we add it to instanceNetlist. for sce_vnf in scenarioDict['vnfs']: for net in sce_vnf['nets']: if sce_vnf.get("datacenter"): vim = myvims[ sce_vnf["datacenter"] ] datacenter_id = sce_vnf["datacenter"] + myvim_thread_id = myvim_threads_id[ sce_vnf["datacenter"]] else: vim = myvims[ default_datacenter_id ] datacenter_id = default_datacenter_id + myvim_thread_id = myvim_threads_id[default_datacenter_id] descriptor_net = instance_dict.get("vnfs",{}).get(sce_vnf["name"],{}) net_name = descriptor_net.get("name") if not net_name: net_name = "%s.%s" %(instance_name, net["name"]) net_name = net_name[:255] #limit length net_type = net['type'] - network_id = vim.new_network(net_name, net_type, net.get('ip_profile',None)) - net['vim_id'] = network_id + task = new_task("new-net", (net_name, net_type, net.get('ip_profile',None))) + task_id = task["id"] + instance_tasks[task_id] = task + tasks_to_launch[myvim_thread_id].append(task) + # network_id = vim.new_network(net_name, net_type, net.get('ip_profile',None)) + net['vim_id'] = task_id if sce_vnf['uuid'] not in auxNetDict: auxNetDict[sce_vnf['uuid']] = {} - auxNetDict[sce_vnf['uuid']][net['uuid']] = network_id - rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':network_id}) + auxNetDict[sce_vnf['uuid']][net['uuid']] = task_id + rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':task_id}) net["created"] = True #print "auxNetDict:" #print yaml.safe_dump(auxNetDict, indent=4, default_flow_style=False) - #3. Creating new vm instances in the VIM + # 3. Creating new vm instances in the VIM #myvim.new_vminstance(self,vimURI,tenant_id,name,description,image_id,flavor_id,net_dict) for sce_vnf in scenarioDict['vnfs']: if sce_vnf.get("datacenter"): vim = myvims[ sce_vnf["datacenter"] ] + myvim_thread_id = myvim_threads_id[ sce_vnf["datacenter"] ] datacenter_id = sce_vnf["datacenter"] else: vim = myvims[ default_datacenter_id ] + myvim_thread_id = myvim_threads_id[ default_datacenter_id ] datacenter_id = default_datacenter_id sce_vnf["datacenter_id"] = datacenter_id i = 0 @@ -2046,9 +2195,6 @@ def create_instance(mydb, tenant_id, instance_dict): flavor_dict['extended']= yaml.load(flavor_dict['extended']) 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: @@ -2063,14 +2209,11 @@ def create_instance(mydb, tenant_id, instance_dict): 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'] myVMDict['flavorRef'] = vm['vim_flavor_id'] myVMDict['networks'] = [] + task_depends = {} #TODO ALF. connect_mgmt_interfaces. Connect management interfaces if this is true for iface in vm['interfaces']: netDict = {} @@ -2121,6 +2264,8 @@ def create_instance(mydb, tenant_id, instance_dict): break else: netDict['net_id'] = auxNetDict[ sce_vnf['uuid'] ][ iface['net_id'] ] + if netDict.get('net_id') and is_task_id(netDict['net_id']): + task_depends[netDict['net_id']] = instance_tasks[netDict['net_id']] #skip bridge ifaces not connected to any net #if 'net_id' not in netDict or netDict['net_id']==None: # continue @@ -2134,10 +2279,12 @@ def create_instance(mydb, tenant_id, instance_dict): 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_vm, - disk_list = myVMDict['disks']) - + task = new_task("new-vm", (myVMDict['name'], myVMDict['description'], myVMDict.get('start', None), + myVMDict['imageRef'], myVMDict['flavorRef'], myVMDict['networks'], + cloud_config_vm, myVMDict['disks']), depends=task_depends) + instance_tasks[task["id"]] = task + tasks_to_launch[myvim_thread_id].append(task) + vm_id = task["id"] 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] @@ -2147,10 +2294,24 @@ def create_instance(mydb, tenant_id, instance_dict): if net["name"]==iface["internal_name"]: iface["vim_id"]=net["vim_id"] break - scenarioDict["datacenter2tenant"] = datacenter2tenant + scenarioDict["datacenter2tenant"] = myvim_threads_id 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) + for myvim_thread_id,task_list in tasks_to_launch.items(): + for task in task_list: + vim_threads["running"][myvim_thread_id].insert_task(task) + + global_instance_tasks[instance_id] = instance_tasks + # Update database with those ended instance_tasks + # for task in instance_tasks.values(): + # if task["status"] == "ok": + # if task["name"] == "new-vm": + # mydb.update_rows("instance_vms", UPDATE={"vim_vm_id": task["result"]}, + # WHERE={"vim_vm_id": task["id"]}) + # elif task["name"] == "new-net": + # mydb.update_rows("instance_nets", UPDATE={"vim_net_id": task["result"]}, + # WHERE={"vim_net_id": task["id"]}) return mydb.get_instance_scenario(instance_id) except (NfvoException, vimconn.vimconnException,db_base_Exception) as e: message = rollback(mydb, myvims, rollbackList) @@ -2164,6 +2325,7 @@ def create_instance(mydb, tenant_id, instance_dict): #logger.error("create_instance: %s", error_text) raise NfvoException(error_text, e.http_code) + def delete_instance(mydb, tenant_id, instance_id): #print "Checking that the instance_id exists and getting the instance dictionary" instanceDict = mydb.get_instance_scenario(instance_id, tenant_id) @@ -2176,13 +2338,20 @@ def delete_instance(mydb, tenant_id, instance_id): #2. delete from VIM error_msg = "" - myvims={} + myvims = {} + myvim_threads = {} #2.1 deleting VMs #vm_fail_list=[] for sce_vnf in instanceDict['vnfs']: datacenter_key = (sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"]) if datacenter_key not in myvims: + try: + _,myvim_thread = get_vim_thread(mydb, tenant_id, sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"]) + except NfvoException as e: + logger.error(str(e)) + myvim_thread = None + myvim_threads[datacenter_key] = myvim_thread vims = get_vim(mydb, tenant_id, datacenter_id=sce_vnf["datacenter_id"], datacenter_tenant_id=sce_vnf["datacenter_tenant_id"]) if len(vims) == 0: @@ -2192,12 +2361,32 @@ def delete_instance(mydb, tenant_id, instance_id): else: myvims[datacenter_key] = vims.values()[0] myvim = myvims[datacenter_key] + myvim_thread = myvim_threads[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']) + task=None + if is_task_id(vm['vim_vm_id']): + task_id = vm['vim_vm_id'] + old_task = global_instance_tasks[instance_id].get(task_id) + if not old_task: + error_msg += "\n VM was scheduled for create, but task {} is not found".format(task_id) + continue + with task_lock: + if old_task["status"] == "enqueued": + old_task["status"] = "deleted" + elif old_task["status"] == "error": + continue + elif old_task["status"] == "processing": + task = new_task("del-vm", (task_id, vm["interfaces"]), depends={task_id: old_task}) + else: #ok + task = new_task("del-vm", (old_task["result"], vm["interfaces"])) + else: + task = new_task("del-vm", (vm['vim_vm_id'], vm["interfaces"]) ) + if task: + myvim_thread.insert_task(task) except vimconn.vimconnNotFoundException as e: 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", @@ -2214,6 +2403,12 @@ def delete_instance(mydb, tenant_id, instance_id): continue #skip not created nets datacenter_key = (net["datacenter_id"], net["datacenter_tenant_id"]) if datacenter_key not in myvims: + try: + _,myvim_thread = get_vim_thread(mydb, tenant_id, sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"]) + except NfvoException as e: + logger.error(str(e)) + myvim_thread = None + myvim_threads[datacenter_key] = myvim_thread vims = get_vim(mydb, tenant_id, datacenter_id=net["datacenter_id"], datacenter_tenant_id=net["datacenter_tenant_id"]) if len(vims) == 0: @@ -2222,189 +2417,213 @@ def delete_instance(mydb, tenant_id, instance_id): else: myvims[datacenter_key] = vims.values()[0] myvim = myvims[datacenter_key] + myvim_thread = myvim_threads[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']) + task = None + if is_task_id(net['vim_net_id']): + task_id = net['vim_net_id'] + old_task = global_instance_tasks[instance_id].get(task_id) + if not old_task: + error_msg += "\n NET was scheduled for create, but task {} is not found".format(task_id) + continue + with task_lock: + if old_task["status"] == "enqueued": + old_task["status"] = "deleted" + elif old_task["status"] == "error": + continue + elif old_task["status"] == "processing": + task = new_task("del-net", task_id, depends={task_id: old_task}) + else: # ok + task = new_task("del-net", old_task["result"]) + else: + task = new_task("del-net", (net['vim_net_id'], net['sdn_net_id'])) + if task: + myvim_thread.insert_task(task) except vimconn.vimconnNotFoundException as e: - error_msg+="\n NET VIM_id={} not found at datacenter={}".format(net['vim_net_id'], net["datacenter_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'])) + net['uuid'], net['vim_net_id'], str(net['vnf_net_id'])) except vimconn.vimconnException as e: - error_msg+="\n NET VIM_id={} at datacenter={} Error: {} {}".format(net['vim_net_id'], net["datacenter_id"], e.http_code, 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: + 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: return 'instance ' + message + ' deleted' + def refresh_instance(mydb, nfvo_tenant, instanceDict, datacenter=None, vim_tenant=None): '''Refreshes a scenario instance. It modifies instanceDict''' '''Returns: - result: <0 if there is any unexpected error, n>=0 if no errors where n is the number of vms and nets that couldn't be updated in the database - error_msg ''' - # Assumption: nfvo_tenant and instance_id were checked before entering into this function - #print "nfvo.refresh_instance begins" - #print json.dumps(instanceDict, indent=4) - - #print "Getting the VIM URL and the VIM tenant_id" - myvims={} - - # 1. Getting VIM vm and net list - vms_updated = [] #List of VM instance uuids in openmano that were updated - vms_notupdated=[] - 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[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 = {} - for net in instanceDict['nets']: - 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"]) - - # 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_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') - 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 = {} - 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_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') - 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" - logger.debug("VMs updated in the database: %s; nets updated in the database %s; VMs not updated: %s; nets not updated: %s", - str(vms_updated), str(nets_updated), str(vms_notupdated), str(nets_notupdated)) + # # Assumption: nfvo_tenant and instance_id were checked before entering into this function + # #print "nfvo.refresh_instance begins" + # #print json.dumps(instanceDict, indent=4) + # + # #print "Getting the VIM URL and the VIM tenant_id" + # myvims={} + # + # # 1. Getting VIM vm and net list + # vms_updated = [] #List of VM instance uuids in openmano that were updated + # vms_notupdated=[] + # 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[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 = {} + # for net in instanceDict['nets']: + # 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"]) + # + # # 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_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') + # 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 = {} + # 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_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') + # 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" + # logger.debug("VMs updated in the database: %s; nets updated in the database %s; VMs not updated: %s; nets not updated: %s", + # str(vms_updated), str(nets_updated), str(vms_notupdated), str(nets_notupdated)) instance_id = instanceDict['uuid'] - if len(vms_notupdated)+len(nets_notupdated)>0: - error_msg = "VMs not updated: " + str(vms_notupdated) + "; nets not updated: " + str(nets_notupdated) - return len(vms_notupdated)+len(nets_notupdated), 'Scenario instance ' + instance_id + ' refreshed but some elements could not be updated in the database: ' + error_msg + # if len(vms_notupdated)+len(nets_notupdated)>0: + # error_msg = "VMs not updated: " + str(vms_notupdated) + "; nets not updated: " + str(nets_notupdated) + # return len(vms_notupdated)+len(nets_notupdated), 'Scenario instance ' + instance_id + ' refreshed but some elements could not be updated in the database: ' + error_msg return 0, 'Scenario instance ' + instance_id + ' refreshed.' + def instance_action(mydb,nfvo_tenant,instance_id, action_dict): #print "Checking that the instance_id exists and getting the instance dictionary" instanceDict = mydb.get_instance_scenario(instance_id, nfvo_tenant) @@ -2477,6 +2696,7 @@ def instance_action(mydb,nfvo_tenant,instance_id, action_dict): else: return vm_result + def create_or_use_console_proxy_thread(console_server, console_port): #look for a non-used port console_thread_key = console_server + ":" + str(console_port) @@ -2501,6 +2721,7 @@ def create_or_use_console_proxy_thread(console_server, console_port): raise NfvoException(str(e), HTTP_Bad_Request) raise NfvoException("Not found any free 'http_console_ports'", HTTP_Conflict) + def check_tenant(mydb, tenant_id): '''check that tenant exists at database''' tenant = mydb.get_rows(FROM='nfvo_tenants', SELECT=('uuid',), WHERE={'uuid': tenant_id}) @@ -2508,10 +2729,12 @@ def check_tenant(mydb, tenant_id): raise NfvoException("tenant '{}' not found".format(tenant_id), HTTP_Not_Found) return + def new_tenant(mydb, tenant_dict): tenant_id = mydb.new_row("nfvo_tenants", tenant_dict, add_uuid=True) return tenant_id + def delete_tenant(mydb, tenant): #get nfvo_tenant info @@ -2519,6 +2742,7 @@ def delete_tenant(mydb, tenant): mydb.delete_row_by_id("nfvo_tenants", tenant_dict['uuid']) return tenant_dict['uuid'] + " " + tenant_dict["name"] + def new_datacenter(mydb, datacenter_descriptor): if "config" in datacenter_descriptor: datacenter_descriptor["config"]=yaml.safe_dump(datacenter_descriptor["config"],default_flow_style=True,width=256) @@ -2536,6 +2760,7 @@ def new_datacenter(mydb, datacenter_descriptor): datacenter_id = mydb.new_row("datacenters", datacenter_descriptor, add_uuid=True) return datacenter_id + def edit_datacenter(mydb, datacenter_id_name, datacenter_descriptor): #obtain data, check that only one exist datacenter = mydb.get_table_by_uuid_name('datacenters', datacenter_id_name) @@ -2552,7 +2777,10 @@ def edit_datacenter(mydb, datacenter_id_name, datacenter_descriptor): if new_config_dict[k]==None: to_delete.append(k) - config_dict = yaml.load(datacenter["config"]) + config_text = datacenter.get("config") + if not config_text: + config_text = '{}' + config_dict = yaml.load(config_text) config_dict.update(new_config_dict) #delete null fields for k in to_delete: @@ -2563,12 +2791,14 @@ def edit_datacenter(mydb, datacenter_id_name, datacenter_descriptor): mydb.update_rows('datacenters', datacenter_descriptor, where) return datacenter_id + def delete_datacenter(mydb, datacenter): #get nfvo_tenant info datacenter_dict = mydb.get_table_by_uuid_name('datacenters', datacenter, '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, config=None): #get datacenter info datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, None, datacenter) @@ -2630,9 +2860,46 @@ def associate_datacenter_to_tenant(mydb, nfvo_tenant, datacenter, vim_tenant_id= # create thread datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_dict['uuid'], datacenter_id) # reload data thread_name = get_non_used_vim_name(datacenter_name, datacenter_id, tenant_dict['name'], tenant_dict['uuid']) - new_thread = vim_thread.vim_thread(myvim, thread_name) + new_thread = vim_thread.vim_thread(myvim, task_lock, thread_name, datacenter_name, db=db, db_lock=db_lock, ovim=ovim) new_thread.start() - vim_threads["running"][datacenter_id + "-" + tenant_dict['uuid']] = new_thread + thread_id = datacenter_tenants_dict["uuid"] + vim_threads["running"][thread_id] = new_thread + return datacenter_id + +def edit_datacenter_to_tenant(mydb, nfvo_tenant, datacenter_id, vim_tenant_id=None, vim_tenant_name=None, vim_username=None, vim_password=None, config=None): + #Obtain the data of this datacenter_tenant_id + vim_data = mydb.get_rows( + SELECT=("datacenter_tenants.vim_tenant_name", "datacenter_tenants.vim_tenant_id", "datacenter_tenants.user", + "datacenter_tenants.passwd", "datacenter_tenants.config"), + FROM="datacenter_tenants JOIN tenants_datacenters ON datacenter_tenants.uuid=tenants_datacenters.datacenter_tenant_id", + WHERE={"tenants_datacenters.nfvo_tenant_id": nfvo_tenant, + "tenants_datacenters.datacenter_id": datacenter_id}) + + logger.debug(str(vim_data)) + if len(vim_data) < 1: + raise NfvoException("Datacenter {} is not attached for tenant {}".format(datacenter_id, nfvo_tenant), HTTP_Conflict) + + v = vim_data[0] + if v['config']: + v['config'] = yaml.load(v['config']) + + if vim_tenant_id: + v['vim_tenant_id'] = vim_tenant_id + if vim_tenant_name: + v['vim_tenant_name'] = vim_tenant_name + if vim_username: + v['user'] = vim_username + if vim_password: + v['passwd'] = vim_password + if config: + if not v['config']: + v['config'] = {} + v['config'].update(config) + + logger.debug(str(v)) + deassociate_datacenter_to_tenant(mydb, nfvo_tenant, datacenter_id, vim_tenant_id=v['vim_tenant_id']) + associate_datacenter_to_tenant(mydb, nfvo_tenant, datacenter_id, vim_tenant_id=v['vim_tenant_id'], vim_tenant_name=v['vim_tenant_name'], + vim_username=v['user'], vim_password=v['passwd'], config=v['config']) return datacenter_id @@ -2675,12 +2942,13 @@ def deassociate_datacenter_to_tenant(mydb, tenant_id, datacenter, vim_tenant_id= except db_base_Exception as e: logger.error("Cannot delete datacenter_tenants " + str(e)) pass # the error will be caused because dependencies, vim_tenant can not be deleted - thread_id = datacenter_id + "-" + tenant_datacenter_item["nfvo_tenant_id"] + thread_id = tenant_datacenter_item["datacenter_tenant_id"] thread = vim_threads["running"][thread_id] - thread.insert_task("exit") + thread.insert_task(new_task("exit", None)) vim_threads["deleting"][thread_id] = thread return "datacenter {} detached. {}".format(datacenter_id, warning) + def datacenter_action(mydb, tenant_id, datacenter, action_dict): #DEPRECATED #get datacenter info @@ -2723,6 +2991,7 @@ def datacenter_action(mydb, tenant_id, datacenter, action_dict): else: raise NfvoException("Unknown action " + str(action_dict), HTTP_Bad_Request) + def datacenter_edit_netmap(mydb, tenant_id, datacenter, netmap, action_dict): #get datacenter info datacenter_id, _ = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter) @@ -2732,6 +3001,7 @@ def datacenter_edit_netmap(mydb, tenant_id, datacenter, netmap, action_dict): WHERE={'datacenter_id':datacenter_id, what: netmap}) return result + def datacenter_new_netmap(mydb, tenant_id, datacenter, action_dict=None): #get datacenter info datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter) @@ -2778,6 +3048,7 @@ def datacenter_new_netmap(mydb, tenant_id, datacenter, action_dict=None): net_list.append(net_nfvo) return net_list + def vim_action_get(mydb, tenant_id, datacenter, item, name): #get datacenter info datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter) @@ -2809,6 +3080,7 @@ def vim_action_get(mydb, tenant_id, datacenter, item, name): print "vim_action Not possible to get_%s_list from VIM: %s " % (item, str(e)) raise NfvoException("Not possible to get_{}_list from VIM: {}".format(item, str(e)), e.http_code) + def vim_action_delete(mydb, tenant_id, datacenter, item, name): #get datacenter info if tenant_id == "any": @@ -2842,6 +3114,7 @@ def vim_action_delete(mydb, tenant_id, datacenter, item, name): return "{} {} {} deleted".format(item[:-1], item_id,item_name) + def vim_action_create(mydb, tenant_id, datacenter, item, descriptor): #get datacenter info logger.debug("vim_action_create descriptor %s", str(descriptor)) @@ -2855,7 +3128,8 @@ def vim_action_create(mydb, tenant_id, datacenter, item, descriptor): net_type = net.pop("type", "bridge") net_public = net.pop("shared", False) net_ipprofile = net.pop("ip_profile", None) - content = myvim.new_network(net_name, net_type, net_ipprofile, shared=net_public, **net) + net_vlan = net.pop("vlan", None) + content = myvim.new_network(net_name, net_type, net_ipprofile, shared=net_public, vlan=net_vlan) #, **net) elif item=="tenants": tenant = descriptor["tenant"] content = myvim.new_tenant(tenant["name"], tenant.get("description")) @@ -2865,3 +3139,122 @@ def vim_action_create(mydb, tenant_id, datacenter, item, descriptor): raise NfvoException("Not possible to create {} at VIM: {}".format(item, str(e)), e.http_code) return vim_action_get(mydb, tenant_id, datacenter, item, content) + +def sdn_controller_create(mydb, tenant_id, sdn_controller): + data = ovim.new_of_controller(sdn_controller) + logger.debug('New SDN controller created with uuid {}'.format(data)) + return data + +def sdn_controller_update(mydb, tenant_id, controller_id, sdn_controller): + data = ovim.edit_of_controller(controller_id, sdn_controller) + msg = 'SDN controller {} updated'.format(data) + logger.debug(msg) + return msg + +def sdn_controller_list(mydb, tenant_id, controller_id=None): + if controller_id == None: + data = ovim.get_of_controllers() + else: + data = ovim.show_of_controller(controller_id) + + msg = 'SDN controller list:\n {}'.format(data) + logger.debug(msg) + return data + +def sdn_controller_delete(mydb, tenant_id, controller_id): + select_ = ('uuid', 'config') + datacenters = mydb.get_rows(FROM='datacenters', SELECT=select_) + for datacenter in datacenters: + if datacenter['config']: + config = yaml.load(datacenter['config']) + if 'sdn-controller' in config and config['sdn-controller'] == controller_id: + raise NfvoException("SDN controller {} is in use by datacenter {}".format(controller_id, datacenter['uuid']), HTTP_Conflict) + + data = ovim.delete_of_controller(controller_id) + msg = 'SDN controller {} deleted'.format(data) + logger.debug(msg) + return msg + +def datacenter_sdn_port_mapping_set(mydb, tenant_id, datacenter_id, sdn_port_mapping): + controller = mydb.get_rows(FROM="datacenters", SELECT=("config",), WHERE={"uuid":datacenter_id}) + if len(controller) < 1: + raise NfvoException("Datacenter {} not present in the database".format(datacenter_id), HTTP_Not_Found) + + try: + sdn_controller_id = yaml.load(controller[0]["config"])["sdn-controller"] + except: + raise NfvoException("The datacenter {} has not an SDN controller associated".format(datacenter_id), HTTP_Bad_Request) + + sdn_controller = ovim.show_of_controller(sdn_controller_id) + switch_dpid = sdn_controller["dpid"] + + maps = list() + for compute_node in sdn_port_mapping: + #element = {"ofc_id": sdn_controller_id, "region": datacenter_id, "switch_dpid": switch_dpid} + element = dict() + element["compute_node"] = compute_node["compute_node"] + for port in compute_node["ports"]: + element["pci"] = port.get("pci") + element["switch_port"] = port.get("switch_port") + element["switch_mac"] = port.get("switch_mac") + if not element["pci"] or not (element["switch_port"] or element["switch_mac"]): + raise NfvoException ("The mapping must contain the 'pci' and at least one of the elements 'switch_port'" + " or 'switch_mac'", HTTP_Bad_Request) + maps.append(dict(element)) + + return ovim.set_of_port_mapping(maps, ofc_id=sdn_controller_id, switch_dpid=switch_dpid, region=datacenter_id) + +def datacenter_sdn_port_mapping_list(mydb, tenant_id, datacenter_id): + maps = ovim.get_of_port_mappings(db_filter={"region": datacenter_id}) + + result = { + "sdn-controller": None, + "datacenter-id": datacenter_id, + "dpid": None, + "ports_mapping": list() + } + + datacenter = mydb.get_table_by_uuid_name('datacenters', datacenter_id) + if datacenter['config']: + config = yaml.load(datacenter['config']) + if 'sdn-controller' in config: + controller_id = config['sdn-controller'] + sdn_controller = sdn_controller_list(mydb, tenant_id, controller_id) + result["sdn-controller"] = controller_id + result["dpid"] = sdn_controller["dpid"] + + if result["sdn-controller"] == None or result["dpid"] == None: + raise NfvoException("Not all SDN controller information for datacenter {} could be found: {}".format(datacenter_id, result), + HTTP_Internal_Server_Error) + + if len(maps) == 0: + return result + + ports_correspondence_dict = dict() + for link in maps: + if result["sdn-controller"] != link["ofc_id"]: + raise NfvoException("The sdn-controller specified for different port mappings differ", HTTP_Internal_Server_Error) + if result["dpid"] != link["switch_dpid"]: + raise NfvoException("The dpid specified for different port mappings differ", HTTP_Internal_Server_Error) + element = dict() + element["pci"] = link["pci"] + if link["switch_port"]: + element["switch_port"] = link["switch_port"] + if link["switch_mac"]: + element["switch_mac"] = link["switch_mac"] + + if not link["compute_node"] in ports_correspondence_dict: + content = dict() + content["compute_node"] = link["compute_node"] + content["ports"] = list() + ports_correspondence_dict[link["compute_node"]] = content + + ports_correspondence_dict[link["compute_node"]]["ports"].append(element) + + for key in sorted(ports_correspondence_dict): + result["ports_mapping"].append(ports_correspondence_dict[key]) + + return result + +def datacenter_sdn_port_mapping_delete(mydb, tenant_id, datacenter_id): + return ovim.clear_of_port_mapping(db_filter={"region":datacenter_id})