X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=nfvo.py;h=14ec54f13b605ef3a48f24c06b8f23280c571666;hb=06e6c396413630640cafae3488442a0869f1642d;hp=1a97fa2d62cfd15a1c330f11fb6d05ab737de6ac;hpb=c78233e1750d5d231e99ffedb5ba81014f84e6fe;p=osm%2FRO.git diff --git a/nfvo.py b/nfvo.py index 1a97fa2d..14ec54f1 100644 --- a/nfvo.py +++ b/nfvo.py @@ -30,20 +30,136 @@ __date__ ="$16-sep-2014 22:05:01$" import imp #import json import yaml -from utils import auxiliary_functions as af -from nfvo_db import HTTP_Unauthorized, HTTP_Bad_Request, HTTP_Internal_Server_Error, HTTP_Not_Found,\ +import utils +import vim_thread +from db_base import HTTP_Unauthorized, HTTP_Bad_Request, HTTP_Internal_Server_Error, HTTP_Not_Found,\ HTTP_Conflict, HTTP_Method_Not_Allowed import console_proxy_thread as cli +import vimconn +import logging +import collections +from db_base import db_base_Exception +import nfvo_db +from threading import Lock +from time import time global global_config global vimconn_imported +global logger +global default_volume_size +default_volume_size = '5' #size in GB -vimconn_imported={} #dictionary with VIM type as key, loaded module as value + +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() +task_dict = {} +last_task_id = 0.0 +db=None +db_lock=Lock() class NfvoException(Exception): - def __init__(self, error_code, text_message): - self.error_code = error_code - Exception.__init__(self, text_message) + def __init__(self, message, http_code): + self.http_code = http_code + 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, store=True, depends=None): + task_id = get_task_id() + task = {"status": "enqueued", "id": task_id, "name": name, "params": params} + if depends: + task["depends"] = depends + if store: + task_dict[task_id] = task + 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 = datacenter_name[:16] + "." + tenant_name[:16] + if name not in vim_threads["names"]: + vim_threads["names"].append(name) + return name + name = datacenter_id + "-" + tenant_id + vim_threads["names"].append(name) + return name + + +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']) + 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', + 'user','passwd', 'dt.config as dt_config', 'nfvo_tenant_id') + try: + vims = mydb.get_rows(FROM=from_, SELECT=select_) + for vim in vims: + extra={'datacenter_tenant_id': vim.get('datacenter_tenant_id')} + if vim["config"]: + extra.update(yaml.load(vim["config"])) + if vim.get('dt_config'): + extra.update(yaml.load(vim["dt_config"])) + if vim["type"] not in vimconn_imported: + module_info=None + try: + module = "vimconn_" + vim["type"] + module_info = imp.find_module(module) + vim_conn = imp.load_module(vim["type"], *module_info) + vimconn_imported[vim["type"]] = vim_conn + except (IOError, ImportError) as e: + 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) + + thread_id = vim["datacenter_id"] + "." + vim['nfvo_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, 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, task_lock, thread_name, vim['datacenter_name'], + vim.get('datacenter_tenant_id'), db=db, db_lock=db_lock) + new_thread.start() + 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(): + for thread_id,thread in vim_threads["running"].items(): + thread.insert_task(new_task("exit", None, store=False)) + vim_threads["deleting"][thread_id] = thread + vim_threads["running"] = {} def get_flavorlist(mydb, vnf_id, nfvo_tenant=None): @@ -56,19 +172,17 @@ def get_flavorlist(mydb, vnf_id, nfvo_tenant=None): WHERE_dict['vnf_id'] = vnf_id if nfvo_tenant is not None: WHERE_dict['nfvo_tenant_id'] = nfvo_tenant - + #result, content = mydb.get_table(FROM='vms join vnfs on vms.vnf_id = vnfs.uuid',SELECT=('uuid'),WHERE=WHERE_dict ) #result, content = mydb.get_table(FROM='vms',SELECT=('vim_flavor_id',),WHERE=WHERE_dict ) - result, content = mydb.get_table(FROM='vms join flavors on vms.flavor_id=flavors.uuid',SELECT=('flavor_id',),WHERE=WHERE_dict ) - if result < 0: - print "nfvo.get_flavorlist error %d %s" % (result, content) - return -result, content - print "get_flavor_list result:", result - print "get_flavor_list content:", content + flavors = mydb.get_rows(FROM='vms join flavors on vms.flavor_id=flavors.uuid',SELECT=('flavor_id',),WHERE=WHERE_dict ) + #print "get_flavor_list result:", result + #print "get_flavor_list content:", content flavorList=[] - for flavor in content: + for flavor in flavors: flavorList.append(flavor['flavor_id']) - return result, flavorList + return flavorList + def get_imagelist(mydb, vnf_id, nfvo_tenant=None): '''Obtain imageList @@ -80,236 +194,323 @@ def get_imagelist(mydb, vnf_id, nfvo_tenant=None): WHERE_dict['vnf_id'] = vnf_id if nfvo_tenant is not None: WHERE_dict['nfvo_tenant_id'] = nfvo_tenant - + #result, content = mydb.get_table(FROM='vms join vnfs on vms-vnf_id = vnfs.uuid',SELECT=('uuid'),WHERE=WHERE_dict ) - result, content = mydb.get_table(FROM='vms join images on vms.image_id=images.uuid',SELECT=('image_id',),WHERE=WHERE_dict ) - if result < 0: - print "nfvo.get_imagelist error %d %s" % (result, content) - return -result, content - print "get_image_list result:", result - print "get_image_list content:", content + images = mydb.get_rows(FROM='vms join images on vms.image_id=images.uuid',SELECT=('image_id',),WHERE=WHERE_dict ) imageList=[] - for image in content: + for image in images: imageList.append(image['image_id']) - return result, imageList + return imageList + -def get_vim(mydb, nfvo_tenant=None, datacenter_id=None, datacenter_name=None, vim_tenant=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 result, content: - <0, error_text upon error - NUMBER, dictionary with datacenter_id: vim_class with these keys: + 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' + raise exception upon error ''' 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', + select_ = ('type','d.config as config','d.uuid as datacenter_id', 'vim_url', 'vim_url_admin', 'd.name as datacenter_name', 'dt.uuid as datacenter_tenant_id','dt.vim_tenant_name as vim_tenant_name','dt.vim_tenant_id as vim_tenant_id', - 'user','passwd') + 'user','passwd', 'dt.config as dt_config') else: from_ = 'datacenters as d' select_ = ('type','config','d.uuid as datacenter_id', 'vim_url', 'vim_url_admin', 'd.name as datacenter_name') - result, content = mydb.get_table(FROM=from_, SELECT=select_, WHERE=WHERE_dict ) - if result < 0: - print "nfvo.get_vim error %d %s" % (result, content) - return result, content - #elif result==0: - # print "nfvo.get_vim not found a valid VIM with the input params " + str(WHERE_dict) - # return -HTTP_Not_Found, "datacenter not found for " + str(WHERE_dict) - #print content - vim_dict={} - for vim in content: - extra={'datacenter_tenant_id': vim.get('datacenter_tenant_id')} - if vim["config"] != None: - extra.update(yaml.load(vim["config"])) - if vim["type"] not in vimconn_imported: - module_info=None + try: + 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')} + if vim["config"]: + extra.update(yaml.load(vim["config"])) + if vim.get('dt_config'): + extra.update(yaml.load(vim["dt_config"])) + if vim["type"] not in vimconn_imported: + module_info=None + try: + module = "vimconn_" + vim["type"] + module_info = imp.find_module(module) + vim_conn = imp.load_module(vim["type"], *module_info) + vimconn_imported[vim["type"]] = vim_conn + except (IOError, ImportError) as e: + 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) + try: - module = "vimconn_" + vim["type"] - module_info = imp.find_module(module) - vim_conn = imp.load_module(vim["type"], *module_info) - vimconn_imported[vim["type"]] = vim_conn - except (IOError, ImportError) as e: - if module_info and module_info[0]: - file.close(module_info[0]) - print "Cannot open VIM module '%s.py'; %s: %s" % ( module, type(e).__name__, str(e)) - return -HTTP_Bad_Request, "Unknown vim type %s" % vim["type"] + if 'nfvo_tenant_id' in vim: + thread_id = vim["datacenter_id"] + "." + vim['nfvo_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), + url=vim['vim_url'], url_admin=vim['vim_url_admin'], + user=vim.get('user',vim_user), passwd=vim.get('passwd',vim_passwd), + 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) + return vim_dict + except db_base_Exception as e: + raise NfvoException(str(e) + " at nfvo.get_vim", e.http_code) - try: - #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'), tenant_name=vim.get('vim_tenant_name'), - url=vim['vim_url'], url_admin=vim['vim_url_admin'], - user=vim.get('user'), passwd=vim.get('passwd'), - config=extra - ) - except Exception as e: - return -HTTP_Internal_Server_Error, "Error at VIM %s; %s: %s" % ( vim["type"], type(e).__name__, str(e)) - return len(vim_dict), vim_dict def rollback(mydb, vims, rollback_list): undeleted_items=[] - #delete things by reverse order + #delete things by reverse order for i in range(len(rollback_list)-1, -1, -1): item = rollback_list[i] if item["where"]=="vim": if item["vim_id"] not in vims: continue vim=vims[ item["vim_id"] ] - if item["what"]=="image": - result, message = vim.delete_tenant_image(item["uuid"]) - if result < 0: - print "Error in rollback. Not possible to delete VIM image '%s'. Message: %s" % (item["uuid"],message) - undeleted_items.append("image %s from VIM %s" % (item["uuid"],vim["name"])) - else: - result, message = mydb.delete_row_by_dict(FROM="datacenters_images", WEHRE={"datacenter_id": vim["id"], "vim_id":item["uuid"]}) - if result < 0: - print "Error in rollback. Not possible to delete image '%s' from DB.dacenters_images. Message: %s" % (item["uuid"],message) - elif item["what"]=="flavor": - result, message = vim.delete_tenant_flavor(item["uuid"]) - if result < 0: - print "Error in rollback. Not possible to delete VIM flavor '%s'. Message: %s" % (item["uuid"],message) - undeleted_items.append("flavor %s from VIM %s" % (item["uuid"],vim["name"])) - else: - result, message = mydb.delete_row_by_dict(FROM="datacenters_flavos", WEHRE={"datacenter_id": vim["id"], "vim_id":item["uuid"]}) - if result < 0: - print "Error in rollback. Not possible to delete flavor '%s' from DB.dacenters_flavors. Message: %s" % (item["uuid"],message) - elif item["what"]=="network": - result, message = vim.delete_tenant_network(item["uuid"]) - if result < 0: - print "Error in rollback. Not possible to delete VIM network '%s'. Message: %s" % (item["uuid"],message) - undeleted_items.append("network %s from VIM %s" % (item["uuid"],vim["name"])) - elif item["what"]=="vm": - result, message = vim.delete_tenant_vminstance(item["uuid"]) - if result < 0: - print "Error in rollback. Not possible to delete VIM VM '%s'. Message: %s" % (item["uuid"],message) - undeleted_items.append("VM %s from VIM %s" % (item["uuid"],vim["name"])) + try: + if item["what"]=="image": + vim.delete_image(item["uuid"]) + mydb.delete_row(FROM="datacenters_images", WHERE={"datacenter_id": vim["id"], "vim_id":item["uuid"]}) + elif item["what"]=="flavor": + vim.delete_flavor(item["uuid"]) + mydb.delete_row(FROM="datacenters_flavors", WHERE={"datacenter_id": vim["id"], "vim_id":item["uuid"]}) + elif item["what"]=="network": + vim.delete_network(item["uuid"]) + elif item["what"]=="vm": + vim.delete_vminstance(item["uuid"]) + except vimconn.vimconnException as e: + logger.error("Error in rollback. Not possible to delete VIM %s '%s'. Message: %s", item['what'], item["uuid"], str(e)) + undeleted_items.append("{} {} from VIM {}".format(item['what'], item["uuid"], vim["name"])) + except db_base_Exception as e: + logger.error("Error in rollback. Not possible to delete %s '%s' from DB.datacenters Message: %s", item['what'], item["uuid"], str(e)) + else: # where==mano - if item["what"]=="image": - result, message = mydb.delete_row_by_dict(FROM="images", WEHRE={"uuid": item["uuid"]}) - if result < 0: - print "Error in rollback. Not possible to delete image '%s' from DB.images. Message: %s" % (item["uuid"],message) - undeleted_items.append("image %s" % (item["uuid"])) - elif item["what"]=="flavor": - result, message = mydb.delete_row_by_dict(FROM="flavors", WEHRE={"uuid": item["uuid"]}) - if result < 0: - print "Error in rollback. Not possible to delete flavor '%s' from DB.flavors. Message: %s" % (item["uuid"],message) - undeleted_items.append("flavor %s" % (item["uuid"])) - if len(undeleted_items)==0: + try: + if item["what"]=="image": + mydb.delete_row(FROM="images", WHERE={"uuid": item["uuid"]}) + elif item["what"]=="flavor": + mydb.delete_row(FROM="flavors", WHERE={"uuid": item["uuid"]}) + except db_base_Exception as e: + logger.error("Error in rollback. Not possible to delete %s '%s' from DB. Message: %s", item['what'], item["uuid"], str(e)) + undeleted_items.append("{} '{}'".format(item['what'], item["uuid"])) + if len(undeleted_items)==0: return True," Rollback successful." else: return False," Rollback fails to delete: " + str(undeleted_items) - -def check_vnf_descriptor(vnf_descriptor): + + +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 + #create a dictionary with vnfc-name: vnfc:interface-list key:values pairs vnfc_interfaces={} for vnfc in vnf_descriptor["vnf"]["VNFC"]: - name_list = [] + name_dict = {} #dataplane interfaces for numa in vnfc.get("numas",() ): for interface in numa.get("interfaces",()): - if interface["name"] in name_list: - return -HTTP_Bad_Request, "Error at vnf:VNFC[name:'%s']:numas:interfaces:name, interface name '%s' already used in this VNFC" %(vnfc["name"], interface["name"]) - name_list.append( interface["name"] ) + if interface["name"] in name_dict: + raise NfvoException( + "Error at vnf:VNFC[name:'{}']:numas:interfaces:name, interface name '{}' already used in this VNFC".format( + vnfc["name"], interface["name"]), + HTTP_Bad_Request) + name_dict[ interface["name"] ] = "underlay" #bridge interfaces for interface in vnfc.get("bridge-ifaces",() ): - if interface["name"] in name_list: - return -HTTP_Bad_Request, "Error at vnf:VNFC[name:'%s']:bridge-ifaces:name, interface name '%s' already used in this VNFC" %(vnfc["name"], interface["name"]) - name_list.append( interface["name"] ) - vnfc_interfaces[ vnfc["name"] ] = name_list - + if interface["name"] in name_dict: + raise NfvoException( + "Error at vnf:VNFC[name:'{}']:bridge-ifaces:name, interface name '{}' already used in this VNFC".format( + vnfc["name"], interface["name"]), + HTTP_Bad_Request) + name_dict[ interface["name"] ] = "overlay" + vnfc_interfaces[ vnfc["name"] ] = name_dict + # check bood-data info + if "boot-data" in vnfc: + # check that user-data is incompatible with users and config-files + if (vnfc["boot-data"].get("users") or vnfc["boot-data"].get("config-files")) and vnfc["boot-data"].get("user-data"): + raise NfvoException( + "Error at vnf:VNFC:boot-data, fields 'users' and 'config-files' are not compatible with 'user-data'", + HTTP_Bad_Request) + #check if the info in external_connections matches with the one in the vnfcs name_list=[] for external_connection in vnf_descriptor["vnf"].get("external-connections",() ): if external_connection["name"] in name_list: - return -HTTP_Bad_Request, "Error at vnf:external-connections:name, value '%s' already used as an external-connection" %(external_connection["name"]) + raise NfvoException( + "Error at vnf:external-connections:name, value '{}' already used as an external-connection".format( + external_connection["name"]), + HTTP_Bad_Request) name_list.append(external_connection["name"]) if external_connection["VNFC"] not in vnfc_interfaces: - return -HTTP_Bad_Request, "Error at vnf:external-connections[name:'%s']:VNFC, value '%s' does not match any VNFC" %(external_connection["name"], external_connection["VNFC"]) + raise NfvoException( + "Error at vnf:external-connections[name:'{}']:VNFC, value '{}' does not match any VNFC".format( + external_connection["name"], external_connection["VNFC"]), + HTTP_Bad_Request) + if external_connection["local_iface_name"] not in vnfc_interfaces[ external_connection["VNFC"] ]: - return -HTTP_Bad_Request, "Error at vnf:external-connections[name:'%s']:local_iface_name, value '%s' does not match any interface of this VNFC" %(external_connection["name"], external_connection["local_iface_name"]) - + raise NfvoException( + "Error at vnf:external-connections[name:'{}']:local_iface_name, value '{}' does not match any interface of this VNFC".format( + external_connection["name"], + external_connection["local_iface_name"]), + HTTP_Bad_Request ) + #check if the info in internal_connections matches with the one in the vnfcs name_list=[] for internal_connection in vnf_descriptor["vnf"].get("internal-connections",() ): if internal_connection["name"] in name_list: - return -HTTP_Bad_Request, "Error at vnf:internal-connections:name, value '%s' already used as an internal-connection" %(internal_connection["name"]) + raise NfvoException( + "Error at vnf:internal-connections:name, value '%s' already used as an internal-connection".format( + internal_connection["name"]), + HTTP_Bad_Request) name_list.append(internal_connection["name"]) #We should check that internal-connections of type "ptp" have only 2 elements - if len(internal_connection["elements"])>2 and internal_connection["type"] == "ptp": - return -HTTP_Bad_Request, "Error at vnf:internal-connections[name:'%s']:elements, size must be 2 for a type:'ptp'" %(internal_connection["name"]) - for port in internal_connection["elements"]: - if port["VNFC"] not in vnfc_interfaces: - return -HTTP_Bad_Request, "Error at vnf:internal-connections[name:'%s']:elements[]:VNFC, value '%s' does not match any VNFC" %(internal_connection["name"], port["VNFC"]) - if port["local_iface_name"] not in vnfc_interfaces[ port["VNFC"] ]: - return -HTTP_Bad_Request, "Error at vnf:internal-connections[name:'%s']:elements[]:local_iface_name, value '%s' does not match any interface of this VNFC" %(internal_connection["name"], port["local_iface_name"]) - - - return 200, None -def create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=False, return_on_error = False): + if len(internal_connection["elements"])>2 and (internal_connection.get("type") == "ptp" or internal_connection.get("type") == "e-line"): + raise NfvoException( + "Error at 'vnf:internal-connections[name:'{}']:elements', size must be 2 for a '{}' type. Consider change it to '{}' type".format( + internal_connection["name"], + 'ptp' if vnf_descriptor_version==1 else 'e-line', + 'data' if vnf_descriptor_version==1 else "e-lan"), + HTTP_Bad_Request) + for port in internal_connection["elements"]: + vnf = port["VNFC"] + iface = port["local_iface_name"] + if vnf not in vnfc_interfaces: + raise NfvoException( + "Error at vnf:internal-connections[name:'{}']:elements[]:VNFC, value '{}' does not match any VNFC".format( + internal_connection["name"], vnf), + HTTP_Bad_Request) + if iface not in vnfc_interfaces[ vnf ]: + raise NfvoException( + "Error at vnf:internal-connections[name:'{}']:elements[]:local_iface_name, value '{}' does not match any interface of this VNFC".format( + internal_connection["name"], iface), + HTTP_Bad_Request) + return -HTTP_Bad_Request, + if vnf_descriptor_version==1 and "type" not in internal_connection: + if vnfc_interfaces[vnf][iface] == "overlay": + internal_connection["type"] = "bridge" + else: + internal_connection["type"] = "data" + if vnf_descriptor_version==2 and "implementation" not in internal_connection: + if vnfc_interfaces[vnf][iface] == "overlay": + internal_connection["implementation"] = "overlay" + else: + internal_connection["implementation"] = "underlay" + if (internal_connection.get("type") == "data" or internal_connection.get("type") == "ptp" or \ + internal_connection.get("implementation") == "underlay") and vnfc_interfaces[vnf][iface] == "overlay": + raise NfvoException( + "Error at vnf:internal-connections[name:'{}']:elements[]:{}, interface of type {} connected to an {} network".format( + internal_connection["name"], + iface, 'bridge' if vnf_descriptor_version==1 else 'overlay', + 'data' if vnf_descriptor_version==1 else 'underlay'), + HTTP_Bad_Request) + if (internal_connection.get("type") == "bridge" or internal_connection.get("implementation") == "overlay") and \ + vnfc_interfaces[vnf][iface] == "underlay": + raise NfvoException( + "Error at vnf:internal-connections[name:'{}']:elements[]:{}, interface of type {} connected to an {} network".format( + internal_connection["name"], iface, + 'data' if vnf_descriptor_version==1 else 'underlay', + 'bridge' if vnf_descriptor_version==1 else 'overlay'), + HTTP_Bad_Request) + + +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: - res,content = mydb.get_table(FROM="images", WHERE={'location':image_dict['location'], 'metadata':image_dict['metadata']}) - if res>=1: - image_mano_id = content[0]['uuid'] - elif res<0: - return res, content + if image_dict['location']: + images = mydb.get_rows(FROM="images", WHERE={'location':image_dict['location'], 'metadata':image_dict['metadata']}) + else: + images = mydb.get_rows(FROM="images", WHERE={'universal_name':image_dict['universal_name'], 'checksum':image_dict['checksum']}) + if len(images)>=1: + image_mano_id = images[0]['uuid'] else: - #create image + #create image in MANO DB temp_image_dict={'name':image_dict['name'], 'description':image_dict.get('description',None), - 'location':image_dict['location'], 'metadata':image_dict.get('metadata',None) + 'location':image_dict['location'], 'metadata':image_dict.get('metadata',None), + 'universal_name':image_dict['universal_name'] , 'checksum':image_dict['checksum'] } - res,content = mydb.new_row('images', temp_image_dict, tenant_id=None, add_uuid=True) - if res>0: - image_mano_id= content - rollback_list.append({"where":"mano", "what":"image","uuid":image_mano_id}) - else: - return res if res<0 else -1, content + #temp_image_dict['location'] = image_dict.get('new_location') if image_dict['location'] is None + image_mano_id = mydb.new_row('images', temp_image_dict, add_uuid=True) + rollback_list.append({"where":"mano", "what":"image","uuid":image_mano_id}) #create image at every vim for vim_id,vim in vims.iteritems(): image_created="false" #look at database - res_db,image_db = mydb.get_table(FROM="datacenters_images", WHERE={'datacenter_id':vim_id, 'image_id':image_mano_id}) - if res_db<0: - return res_db, image_db + image_db = mydb.get_rows(FROM="datacenters_images", WHERE={'datacenter_id':vim_id, 'image_id':image_mano_id}) #look at VIM if this image exist - res_vim, image_vim_id = vim.get_image_id_from_path(image_dict['location']) - if res_vim < 0: - print "Error contacting VIM to know if the image %s existed previously." %image_vim_id - continue - elif res_vim==0: - #Create the image in VIM - result, image_vim_id = vim.new_tenant_image(image_dict) - if result < 0: - print "Error creating image at VIM: %s." %image_vim_id + try: + if image_dict['location'] is not None: + image_vim_id = vim.get_image_id_from_path(image_dict['location']) + else: + filter_dict = {} + filter_dict['name'] = image_dict['universal_name'] + if image_dict.get('checksum') != None: + filter_dict['checksum'] = image_dict['checksum'] + #logger.debug('>>>>>>>> Filter dict: %s', str(filter_dict)) + vim_images = vim.get_image_list(filter_dict) + #logger.debug('>>>>>>>> VIM images: %s', str(vim_images)) + if len(vim_images) > 1: + raise vimconn.vimconnException("More than one candidate VIM image found for filter: {}".format(str(filter_dict)), HTTP_Conflict) + elif len(vim_images) == 0: + raise vimconn.vimconnNotFoundException("Image not found at VIM with filter: '{}'".format(str(filter_dict))) + else: + #logger.debug('>>>>>>>> VIM image 0: %s', str(vim_images[0])) + image_vim_id = vim_images[0]['id'] + + except vimconn.vimconnNotFoundException as e: + #Create the image in VIM only if image_dict['location'] or image_dict['new_location'] is not None + try: + #image_dict['location']=image_dict.get('new_location') if image_dict['location'] is None + if image_dict['location']: + image_vim_id = vim.new_image(image_dict) + rollback_list.append({"where":"vim", "vim_id": vim_id, "what":"image","uuid":image_vim_id}) + image_created="true" + else: + #If we reach this point, then the image has image name, and optionally checksum, and could not be found + raise vimconn.vimconnException(str(e)) + except vimconn.vimconnException as e: if return_on_error: - return result, image_vim_id + logger.error("Error creating image at VIM '%s': %s", vim["name"], str(e)) + raise + image_vim_id = None + logger.warn("Error creating image at VIM '%s': %s", vim["name"], str(e)) continue - else: - rollback_list.append({"where":"vim", "vim_id": vim_id, "what":"image","uuid":image_vim_id}) - image_created="true" - - #if reach here the image has been create or exist - if res_db==0: + 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 = None + continue + #if we reach here, the image has been created or existed + if len(image_db)==0: #add new vim_id at datacenters_images mydb.new_row('datacenters_images', {'datacenter_id':vim_id, 'image_id':image_mano_id, 'vim_id': image_vim_id, 'created':image_created}) elif image_db[0]["vim_id"]!=image_vim_id: #modify existing vim_id at datacenters_images mydb.update_rows('datacenters_images', UPDATE={'vim_id':image_vim_id}, WHERE={'datacenter_id':vim_id, 'image_id':image_mano_id}) - - return 1, 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): + 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'), 'vcpus':flavor_dict.get('vcpus'), @@ -322,12 +523,12 @@ def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_ #look if flavor exist if only_create_at_vim: flavor_mano_id = flavor_dict['uuid'] + if return_on_error == None: + return_on_error = True else: - res,content = mydb.get_table(FROM="flavors", WHERE=temp_flavor_dict) - if res>=1: - flavor_mano_id = content[0]['uuid'] - elif res<0: - return res, content + flavors = mydb.get_rows(FROM="flavors", WHERE=temp_flavor_dict) + if len(flavors)>=1: + flavor_mano_id = flavors[0]['uuid'] else: #create flavor #create one by one the images of aditional disks @@ -335,28 +536,29 @@ def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_ if 'extended' in flavor_dict and flavor_dict['extended']!=None: dev_nb=0 for device in flavor_dict['extended'].get('devices',[]): - if "image" not in device: + if "image" not in device and "image name" not in device: continue - image_dict={'location':device['image'], 'name':flavor_dict['name']+str(dev_nb)+"-img", 'description':flavor_dict.get('description')} + image_dict={} + image_dict['name']=device.get('image name',flavor_dict['name']+str(dev_nb)+"-img") + image_dict['universal_name']=device.get('image name') + image_dict['description']=flavor_dict['name']+str(dev_nb)+"-img" + image_dict['location']=device.get('image') + #image_dict['new_location']=vnfc.get('image location') + image_dict['checksum']=device.get('image checksum') image_metadata_dict = device.get('image metadata', None) image_metadata_str = None - if image_metadata_dict != None: + if image_metadata_dict != None: image_metadata_str = yaml.safe_dump(image_metadata_dict,default_flow_style=True,width=256) image_dict['metadata']=image_metadata_str - res, image_id = create_or_use_image(mydb, vims, image_dict, rollback_list) - if res < 0: - return res, image_id + rollback(mydb, vims, rollback_list)[1] - print "Additional disk image id for VNFC %s: %s" % (flavor_dict['name']+str(dev_nb)+"-img", image_id) + image_id = create_or_use_image(mydb, vims, image_dict, rollback_list) + #print "Additional disk image id for VNFC %s: %s" % (flavor_dict['name']+str(dev_nb)+"-img", image_id) dev_image_list.append(image_id) - dev_nb += 1 + dev_nb += 1 temp_flavor_dict['name'] = flavor_dict['name'] temp_flavor_dict['description'] = flavor_dict.get('description',None) - res,content = mydb.new_row('flavors', temp_flavor_dict, tenant_id=None, add_uuid=True) - if res>0: - flavor_mano_id= content - rollback_list.append({"where":"mano", "what":"flavor","uuid":flavor_mano_id}) - else: - return res if res<0 else -1, content + content = mydb.new_row('flavors', temp_flavor_dict, add_uuid=True) + flavor_mano_id= content + rollback_list.append({"where":"mano", "what":"flavor","uuid":flavor_mano_id}) #create flavor at every vim if 'uuid' in flavor_dict: del flavor_dict['uuid'] @@ -364,22 +566,21 @@ def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_ for vim_id,vim in vims.items(): flavor_created="false" #look at database - res_db,flavor_db = mydb.get_table(FROM="datacenters_flavors", WHERE={'datacenter_id':vim_id, 'flavor_id':flavor_mano_id}) - if res_db<0: - return res_db, flavor_db + flavor_db = mydb.get_rows(FROM="datacenters_flavors", WHERE={'datacenter_id':vim_id, 'flavor_id':flavor_mano_id}) #look at VIM if this flavor exist SKIPPED #res_vim, flavor_vim_id = vim.get_flavor_id_from_path(flavor_dict['location']) #if res_vim < 0: # print "Error contacting VIM to know if the flavor %s existed previously." %flavor_vim_id # continue #elif res_vim==0: - + #Create the flavor in VIM #Translate images at devices from MANO id to VIM id - error=False + disk_list = [] if 'extended' in flavor_dict and flavor_dict['extended']!=None and "devices" in flavor_dict['extended']: #make a copy of original devices devices_original=[] + for device in flavor_dict["extended"].get("devices",[]): dev={} dev.update(device) @@ -391,140 +592,137 @@ def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_ dev_nb=0 for index in range(0,len(devices_original)) : device=devices_original[index] - if "image" not in device: + if "image" not in device and "image name" not in device: + if 'size' in device: + disk_list.append({'size': device.get('size', default_volume_size)}) continue - image_dict={'location':device['image'], 'name':flavor_dict['name']+str(dev_nb)+"-img", 'description':flavor_dict.get('description')} + image_dict={} + image_dict['name']=device.get('image name',flavor_dict['name']+str(dev_nb)+"-img") + image_dict['universal_name']=device.get('image name') + image_dict['description']=flavor_dict['name']+str(dev_nb)+"-img" + image_dict['location']=device.get('image') + #image_dict['new_location']=device.get('image location') + image_dict['checksum']=device.get('image checksum') image_metadata_dict = device.get('image metadata', None) image_metadata_str = None - if image_metadata_dict != None: + if image_metadata_dict != None: image_metadata_str = yaml.safe_dump(image_metadata_dict,default_flow_style=True,width=256) image_dict['metadata']=image_metadata_str - r,image_mano_id=create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=False) - if r<0: - print "Error creating device image for flavor: %s." %image_mano_id - error_text = image_mano_id - error=True - break + image_mano_id=create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=False, return_on_error=return_on_error ) image_dict["uuid"]=image_mano_id - r,image_vim_id=create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=True) - if r<0: - print "Error creating device image for flavor at VIM: %s." %image_vim_id - error_text = image_vim_id - error=True - break + image_vim_id=create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vim=True, return_on_error=return_on_error) + + #save disk information (image must be based on and size + disk_list.append({'image_id': image_vim_id, 'size': device.get('size', default_volume_size)}) + flavor_dict["extended"]["devices"][index]['imageRef']=image_vim_id dev_nb += 1 - if error: - if return_on_error: - return r, error_text - continue - if res_db>0: + if len(flavor_db)>0: #check that this vim_id exist in VIM, if not create flavor_vim_id=flavor_db[0]["vim_id"] - result, _ = vim.get_tenant_flavor(flavor_vim_id) - if result>=0: #flavor exist - continue + try: + vim.get_flavor(flavor_vim_id) + continue #flavor exist + except vimconn.vimconnException: + pass #create flavor at vim - print "nfvo.create_or_use_flavor() adding flavor to VIM %s" % vim["name"] - result, flavor_vim_id = vim.new_tenant_flavor(flavor_dict) - - if result < 0: - print "Error creating flavor at VIM %s: %s." %(vim["name"], flavor_vim_id) + logger.debug("nfvo.create_or_use_flavor() adding flavor to VIM %s", vim["name"]) + try: + flavor_vim_id = None + flavor_vim_id=vim.get_flavor_id_from_data(flavor_dict) + flavor_create="false" + except vimconn.vimconnException as e: + pass + try: + if not flavor_vim_id: + flavor_vim_id = vim.new_flavor(flavor_dict) + rollback_list.append({"where":"vim", "vim_id": vim_id, "what":"flavor","uuid":flavor_vim_id}) + flavor_created="true" + except vimconn.vimconnException as e: if return_on_error: - return result, flavor_vim_id + 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 - else: - rollback_list.append({"where":"vim", "vim_id": vim_id, "what":"flavor","uuid":flavor_vim_id}) - flavor_created="true" - #if reach here the flavor has been create or exist - if res_db==0: + if len(flavor_db)==0: #add new vim_id at datacenters_flavors - mydb.new_row('datacenters_flavors', {'datacenter_id':vim_id, 'flavor_id':flavor_mano_id, 'vim_id': flavor_vim_id, 'created':flavor_created}) + extended_devices_yaml = None + if len(disk_list) > 0: + extended_devices = dict() + extended_devices['disks'] = disk_list + extended_devices_yaml = yaml.safe_dump(extended_devices,default_flow_style=True,width=256) + mydb.new_row('datacenters_flavors', + {'datacenter_id':vim_id, 'flavor_id':flavor_mano_id, 'vim_id': flavor_vim_id, + 'created':flavor_created,'extended': extended_devices_yaml}) elif flavor_db[0]["vim_id"]!=flavor_vim_id: #modify existing vim_id at datacenters_flavors mydb.update_rows('datacenters_flavors', UPDATE={'vim_id':flavor_vim_id}, WHERE={'datacenter_id':vim_id, 'flavor_id':flavor_mano_id}) - - return 1, flavor_vim_id if only_create_at_vim else flavor_mano_id + + return flavor_vim_id if only_create_at_vim else flavor_mano_id + def new_vnf(mydb, tenant_id, vnf_descriptor): global global_config - - # Step 1. Check the VNF descriptor - result, message = check_vnf_descriptor(vnf_descriptor) - if result < 0: - print "new_vnf error: %s" %message - return result, message + # Step 1. Check the VNF descriptor + check_vnf_descriptor(vnf_descriptor, vnf_descriptor_version=1) # Step 2. Check tenant exist + vims = {} if tenant_id != "any": - if not check_tenant(mydb, tenant_id): - print 'nfvo.new_vnf() tenant %s not found' % tenant_id - return -HTTP_Not_Found, 'Tenant %s not found' % tenant_id + check_tenant(mydb, tenant_id) if "tenant_id" in vnf_descriptor["vnf"]: if vnf_descriptor["vnf"]["tenant_id"] != tenant_id: - print "nfvo.new_vnf() tenant '%s' not found" % tenant_id - return -HTTP_Unauthorized, "VNF can not have a different tenant owner '%s', must be '%s'" %(vnf_descriptor["vnf"]["tenant_id"], tenant_id) + raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format(vnf_descriptor["vnf"]["tenant_id"], tenant_id), + HTTP_Unauthorized) else: vnf_descriptor['vnf']['tenant_id'] = tenant_id # Step 3. Get the URL of the VIM from the nfvo_tenant and the datacenter - result, vims = get_vim(mydb, tenant_id) - if result < 0: - print "nfvo.new_vnf() error. Datacenter not found" - return result, vims - else: - vims={} + if global_config["auto_push_VNF_to_VIMs"]: + vims = get_vim(mydb, tenant_id) # Step 4. Review the descriptor and add missing fields #print vnf_descriptor - print "Refactoring VNF descriptor with fields: description, public (default: true)" + #logger.debug("Refactoring VNF descriptor with fields: description, public (default: true)") vnf_name = vnf_descriptor['vnf']['name'] vnf_descriptor['vnf']['description'] = vnf_descriptor['vnf'].get("description", vnf_name) if "physical" in vnf_descriptor['vnf']: del vnf_descriptor['vnf']['physical'] #print vnf_descriptor - # Step 5. Check internal connections - # TODO: to be moved to step 1???? - internal_connections=vnf_descriptor['vnf'].get('internal_connections',[]) - for ic in internal_connections: - if len(ic['elements'])>2 and ic['type']=='ptp': - return -HTTP_Bad_Request, "Mismatch 'type':'ptp' with %d elements at 'vnf':'internal-conections'['name':'%s']. Change 'type' to 'data'" %(len(ic), ic['name']) - elif len(ic['elements'])==2 and ic['type']=='data': - return -HTTP_Bad_Request, "Mismatch 'type':'data' with 2 elements at 'vnf':'internal-conections'['name':'%s']. Change 'type' to 'ptp'" %(ic['name']) - - # Step 6. For each VNFC in the descriptor, flavors and images are created in the VIM - print 'BEGIN creation of VNF "%s"' % vnf_name - print "VNF %s: consisting of %d VNFC(s)" % (vnf_name,len(vnf_descriptor['vnf']['VNFC'])) - + + # Step 6. For each VNFC in the descriptor, flavors and images are created in the VIM + logger.debug('BEGIN creation of VNF "%s"' % vnf_name) + logger.debug("VNF %s: consisting of %d VNFC(s)" % (vnf_name,len(vnf_descriptor['vnf']['VNFC']))) + #For each VNFC, we add it to the VNFCDict and we create a flavor. VNFCDict = {} # Dictionary, key: VNFC name, value: dict with the relevant information to create the VNF and VMs in the MANO database rollback_list = [] # It will contain the new images created in mano. It is used for rollback - try: - print "Creating additional disk images and new flavors in the VIM for each VNFC" + logger.debug("Creating additional disk images and new flavors in the VIM for each VNFC") for vnfc in vnf_descriptor['vnf']['VNFC']: VNFCitem={} VNFCitem["name"] = vnfc['name'] VNFCitem["description"] = vnfc.get("description", 'VM %s of the VNF %s' %(vnfc['name'],vnf_name)) - - print "Flavor name: %s. Description: %s" % (VNFCitem["name"]+"-flv", VNFCitem["description"]) - + + #print "Flavor name: %s. Description: %s" % (VNFCitem["name"]+"-flv", VNFCitem["description"]) + myflavorDict = {} - myflavorDict["name"] = vnfc['name']+"-flv" + myflavorDict["name"] = vnfc['name']+"-flv" #Maybe we could rename the flavor by using the field "image name" if exists myflavorDict["description"] = VNFCitem["description"] myflavorDict["ram"] = vnfc.get("ram", 0) myflavorDict["vcpus"] = vnfc.get("vcpus", 0) myflavorDict["disk"] = vnfc.get("disk", 1) myflavorDict["extended"] = {} - + devices = vnfc.get("devices") if devices != None: myflavorDict["extended"]["devices"] = devices - + # TODO: # Mapping from processor models to rankings should be available somehow in the NFVO. They could be taken from VIM or directly from a new database table - # Another option is that the processor in the VNF descriptor specifies directly the ranking of the host - + # Another option is that the processor in the VNF descriptor specifies directly the ranking of the host + # Previous code has been commented #if vnfc['processor']['model'] == "Intel(R) Xeon(R) CPU E5-4620 0 @ 2.20GHz" : # myflavorDict["flavor"]['extended']['processor_ranking'] = 200 @@ -538,139 +736,269 @@ def new_vnf(mydb, tenant_id, vnf_descriptor): # else: # return -HTTP_Bad_Request, "Error creating flavor: unknown processor model. Rollback fail: you need to access VIM and delete the following %s" % message myflavorDict['extended']['processor_ranking'] = 100 #Hardcoded value, while we decide when the mapping is done - + if 'numas' in vnfc and len(vnfc['numas'])>0: myflavorDict['extended']['numas'] = vnfc['numas'] #print myflavorDict - + # Step 6.2 New flavors are created in the VIM - res, flavor_id = create_or_use_flavor(mydb, vims, myflavorDict, rollback_list) - if res < 0: - return res, flavor_id + rollback(mydb, vims, rollback_list)[1] + flavor_id = create_or_use_flavor(mydb, vims, myflavorDict, rollback_list) - print "Flavor id for VNFC %s: %s" % (vnfc['name'],flavor_id) + #print "Flavor id for VNFC %s: %s" % (vnfc['name'],flavor_id) VNFCitem["flavor_id"] = flavor_id VNFCDict[vnfc['name']] = VNFCitem - - print "Creating new images in the VIM for each VNFC" + + logger.debug("Creating new images in the VIM for each VNFC") # Step 6.3 New images are created in the VIM #For each VNFC, we must create the appropriate image. - #This "for" loop might be integrated with the previous one + #This "for" loop might be integrated with the previous one #In case this integration is made, the VNFCDict might become a VNFClist. for vnfc in vnf_descriptor['vnf']['VNFC']: - print "Image name: %s. Description: %s" % (vnfc['name']+"-img", VNFCDict[vnfc['name']]['description']) - image_dict={'location':vnfc['VNFC image'], 'name':vnfc['name']+"-img", 'description':VNFCDict[vnfc['name']]['description']} + #print "Image name: %s. Description: %s" % (vnfc['name']+"-img", VNFCDict[vnfc['name']]['description']) + image_dict={} + image_dict['name']=vnfc.get('image name',vnf_name+"-"+vnfc['name']+"-img") + image_dict['universal_name']=vnfc.get('image name') + image_dict['description']=vnfc.get('image name', VNFCDict[vnfc['name']]['description']) + image_dict['location']=vnfc.get('VNFC image') + #image_dict['new_location']=vnfc.get('image location') + image_dict['checksum']=vnfc.get('image checksum') image_metadata_dict = vnfc.get('image metadata', None) image_metadata_str = None - if image_metadata_dict is not None: + if image_metadata_dict is not None: image_metadata_str = yaml.safe_dump(image_metadata_dict,default_flow_style=True,width=256) image_dict['metadata']=image_metadata_str #print "create_or_use_image", mydb, vims, image_dict, rollback_list - res, image_id = create_or_use_image(mydb, vims, image_dict, rollback_list) - if res < 0: - return res, image_id + rollback(mydb, vims, rollback_list)[1] - print "Image id for VNFC %s: %s" % (vnfc['name'],image_id) + image_id = create_or_use_image(mydb, vims, image_dict, rollback_list) + #print "Image id for VNFC %s: %s" % (vnfc['name'],image_id) VNFCDict[vnfc['name']]["image_id"] = image_id - VNFCDict[vnfc['name']]["image_path"] = vnfc['VNFC image'] + VNFCDict[vnfc['name']]["image_path"] = vnfc.get('VNFC image') + if vnfc.get("boot-data"): + VNFCDict[vnfc['name']]["boot_data"] = yaml.safe_dump(vnfc["boot-data"], default_flow_style=True, width=256) - except KeyError as e: - print "Error while creating a VNF. KeyError: " + str(e) + + # Step 7. Storing the VNF descriptor in the repository + if "descriptor" not in vnf_descriptor["vnf"]: + vnf_descriptor["vnf"]["descriptor"] = yaml.safe_dump(vnf_descriptor, indent=4, explicit_start=True, default_flow_style=False) + + # Step 8. Adding the VNF to the NFVO DB + vnf_id = mydb.new_vnf_as_a_whole(tenant_id,vnf_name,vnf_descriptor,VNFCDict) + return vnf_id + except (db_base_Exception, vimconn.vimconnException, KeyError) as e: _, message = rollback(mydb, vims, rollback_list) - return -HTTP_Internal_Server_Error, "Error while creating a VNF. KeyError " + str(e) + "." + message - - # Step 7. Storing the VNF descriptor in the repository - if "descriptor" not in vnf_descriptor["vnf"]: - vnf_descriptor["vnf"]["descriptor"] = yaml.safe_dump(vnf_descriptor, indent=4, explicit_start=True, default_flow_style=False) + if isinstance(e, db_base_Exception): + error_text = "Exception at database" + elif isinstance(e, KeyError): + error_text = "KeyError exception " + e.http_code = HTTP_Internal_Server_Error + else: + error_text = "Exception at VIM" + error_text += " {} {}. {}".format(type(e).__name__, str(e), message) + #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 + + # Step 1. Check the VNF descriptor + check_vnf_descriptor(vnf_descriptor, vnf_descriptor_version=2) + # Step 2. Check tenant exist + vims = {} + if tenant_id != "any": + check_tenant(mydb, tenant_id) + if "tenant_id" in vnf_descriptor["vnf"]: + if vnf_descriptor["vnf"]["tenant_id"] != tenant_id: + raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format(vnf_descriptor["vnf"]["tenant_id"], tenant_id), + HTTP_Unauthorized) + else: + vnf_descriptor['vnf']['tenant_id'] = tenant_id + # Step 3. Get the URL of the VIM from the nfvo_tenant and the datacenter + if global_config["auto_push_VNF_to_VIMs"]: + vims = get_vim(mydb, tenant_id) + + # Step 4. Review the descriptor and add missing fields + #print vnf_descriptor + #logger.debug("Refactoring VNF descriptor with fields: description, public (default: true)") + vnf_name = vnf_descriptor['vnf']['name'] + vnf_descriptor['vnf']['description'] = vnf_descriptor['vnf'].get("description", vnf_name) + if "physical" in vnf_descriptor['vnf']: + del vnf_descriptor['vnf']['physical'] + #print vnf_descriptor + + # Step 6. For each VNFC in the descriptor, flavors and images are created in the VIM + logger.debug('BEGIN creation of VNF "%s"' % vnf_name) + logger.debug("VNF %s: consisting of %d VNFC(s)" % (vnf_name,len(vnf_descriptor['vnf']['VNFC']))) - # Step 8. Adding the VNF to the NFVO DB + #For each VNFC, we add it to the VNFCDict and we create a flavor. + VNFCDict = {} # Dictionary, key: VNFC name, value: dict with the relevant information to create the VNF and VMs in the MANO database + rollback_list = [] # It will contain the new images created in mano. It is used for rollback try: - result, vnf_id = mydb.new_vnf_as_a_whole(tenant_id,vnf_name,vnf_descriptor,VNFCDict) - except KeyError as e: - print "Error while creating a VNF. KeyError: " + str(e) - _, message = rollback(mydb, vims, rollback_list) - return -HTTP_Internal_Server_Error, "Error while creating a VNF. KeyError " + str(e) + "." + message - - if result < 0: + logger.debug("Creating additional disk images and new flavors in the VIM for each VNFC") + for vnfc in vnf_descriptor['vnf']['VNFC']: + VNFCitem={} + VNFCitem["name"] = vnfc['name'] + VNFCitem["description"] = vnfc.get("description", 'VM %s of the VNF %s' %(vnfc['name'],vnf_name)) + + #print "Flavor name: %s. Description: %s" % (VNFCitem["name"]+"-flv", VNFCitem["description"]) + + myflavorDict = {} + myflavorDict["name"] = vnfc['name']+"-flv" #Maybe we could rename the flavor by using the field "image name" if exists + myflavorDict["description"] = VNFCitem["description"] + myflavorDict["ram"] = vnfc.get("ram", 0) + myflavorDict["vcpus"] = vnfc.get("vcpus", 0) + myflavorDict["disk"] = vnfc.get("disk", 1) + myflavorDict["extended"] = {} + + devices = vnfc.get("devices") + if devices != None: + myflavorDict["extended"]["devices"] = devices + + # TODO: + # Mapping from processor models to rankings should be available somehow in the NFVO. They could be taken from VIM or directly from a new database table + # Another option is that the processor in the VNF descriptor specifies directly the ranking of the host + + # Previous code has been commented + #if vnfc['processor']['model'] == "Intel(R) Xeon(R) CPU E5-4620 0 @ 2.20GHz" : + # myflavorDict["flavor"]['extended']['processor_ranking'] = 200 + #elif vnfc['processor']['model'] == "Intel(R) Xeon(R) CPU E5-2697 v2 @ 2.70GHz" : + # myflavorDict["flavor"]['extended']['processor_ranking'] = 300 + #else: + # result2, message = rollback(myvim, myvimURL, myvim_tenant, flavorList, imageList) + # if result2: + # print "Error creating flavor: unknown processor model. Rollback successful." + # return -HTTP_Bad_Request, "Error creating flavor: unknown processor model. Rollback successful." + # else: + # return -HTTP_Bad_Request, "Error creating flavor: unknown processor model. Rollback fail: you need to access VIM and delete the following %s" % message + myflavorDict['extended']['processor_ranking'] = 100 #Hardcoded value, while we decide when the mapping is done + + if 'numas' in vnfc and len(vnfc['numas'])>0: + myflavorDict['extended']['numas'] = vnfc['numas'] + + #print myflavorDict + + # Step 6.2 New flavors are created in the VIM + flavor_id = create_or_use_flavor(mydb, vims, myflavorDict, rollback_list) + + #print "Flavor id for VNFC %s: %s" % (vnfc['name'],flavor_id) + VNFCitem["flavor_id"] = flavor_id + VNFCDict[vnfc['name']] = VNFCitem + + logger.debug("Creating new images in the VIM for each VNFC") + # Step 6.3 New images are created in the VIM + #For each VNFC, we must create the appropriate image. + #This "for" loop might be integrated with the previous one + #In case this integration is made, the VNFCDict might become a VNFClist. + for vnfc in vnf_descriptor['vnf']['VNFC']: + #print "Image name: %s. Description: %s" % (vnfc['name']+"-img", VNFCDict[vnfc['name']]['description']) + image_dict={} + image_dict['name']=vnfc.get('image name',vnf_name+"-"+vnfc['name']+"-img") + image_dict['universal_name']=vnfc.get('image name') + image_dict['description']=vnfc.get('image name', VNFCDict[vnfc['name']]['description']) + image_dict['location']=vnfc.get('VNFC image') + #image_dict['new_location']=vnfc.get('image location') + image_dict['checksum']=vnfc.get('image checksum') + image_metadata_dict = vnfc.get('image metadata', None) + image_metadata_str = None + if image_metadata_dict is not None: + image_metadata_str = yaml.safe_dump(image_metadata_dict,default_flow_style=True,width=256) + image_dict['metadata']=image_metadata_str + #print "create_or_use_image", mydb, vims, image_dict, rollback_list + image_id = create_or_use_image(mydb, vims, image_dict, rollback_list) + #print "Image id for VNFC %s: %s" % (vnfc['name'],image_id) + VNFCDict[vnfc['name']]["image_id"] = image_id + VNFCDict[vnfc['name']]["image_path"] = vnfc.get('VNFC image') + if vnfc.get("boot-data"): + VNFCDict[vnfc['name']]["boot_data"] = yaml.safe_dump(vnfc["boot-data"], default_flow_style=True, width=256) + + # Step 7. Storing the VNF descriptor in the repository + if "descriptor" not in vnf_descriptor["vnf"]: + vnf_descriptor["vnf"]["descriptor"] = yaml.safe_dump(vnf_descriptor, indent=4, explicit_start=True, default_flow_style=False) + + # Step 8. Adding the VNF to the NFVO DB + vnf_id = mydb.new_vnf_as_a_whole2(tenant_id,vnf_name,vnf_descriptor,VNFCDict) + return vnf_id + except (db_base_Exception, vimconn.vimconnException, KeyError) as e: _, message = rollback(mydb, vims, rollback_list) - return result, vnf_id + "." + message + if isinstance(e, db_base_Exception): + error_text = "Exception at database" + elif isinstance(e, KeyError): + error_text = "KeyError exception " + e.http_code = HTTP_Internal_Server_Error + else: + error_text = "Exception at VIM" + error_text += " {} {}. {}".format(type(e).__name__, str(e), message) + #logger.error("start_scenario %s", error_text) + raise NfvoException(error_text, e.http_code) - return 200,vnf_id def get_vnf_id(mydb, tenant_id, vnf_id): #check valid tenant_id - if tenant_id != "any" and not check_tenant(mydb, tenant_id): - print 'nfvo.get_vnf_id() tenant %s not found' % tenant_id - return -HTTP_Not_Found, "Tenant '%s' not found" % tenant_id + check_tenant(mydb, tenant_id) #obtain data where_or = {} if tenant_id != "any": where_or["tenant_id"] = tenant_id where_or["public"] = True - result, content = mydb.get_table_by_uuid_name('vnfs', vnf_id, "VNF", WHERE_OR=where_or, WHERE_AND_OR="AND") - if result < 0: - print "nfvo.get_vnf_id() error %d %s" % (result, content) - return (result, content) + vnf = mydb.get_table_by_uuid_name('vnfs', vnf_id, "VNF", WHERE_OR=where_or, WHERE_AND_OR="AND") - - vnf_id=content["uuid"] + vnf_id=vnf["uuid"] filter_keys = ('uuid','name','description','public', "tenant_id", "created_at") - filtered_content = dict( (k,v) for k,v in content.iteritems() if k in filter_keys ) + filtered_content = dict( (k,v) for k,v in vnf.iteritems() if k in filter_keys ) #change_keys_http2db(filtered_content, http2db_vnf, reverse=True) data={'vnf' : filtered_content} #GET VM - result,content = mydb.get_table(FROM='vnfs join vms on vnfs.uuid=vms.vnf_id', - SELECT=('vms.uuid as uuid','vms.name as name', 'vms.description as description'), + content = mydb.get_rows(FROM='vnfs join vms on vnfs.uuid=vms.vnf_id', + SELECT=('vms.uuid as uuid','vms.name as name', 'vms.description as description', 'boot_data'), WHERE={'vnfs.uuid': vnf_id} ) - if result < 0: - print "nfvo.get_vnf_id error %d %s" % (result, content) - return (result, content) - elif result==0: - print "nfvo.get_vnf_id vnf '%s' not found" % vnf_id - return (-HTTP_Not_Found, "vnf %s not found" % vnf_id) + if len(content)==0: + raise NfvoException("vnf '{}' not found".format(vnf_id), HTTP_Not_Found) + # change boot_data into boot-data + for vm in content: + if vm.get("boot_data"): + vm["boot-data"] = yaml.safe_load(vm["boot_data"]) + del vm["boot_data"] data['vnf']['VNFC'] = content + #TODO: GET all the information from a VNFC and include it in the output. + #GET NET - result,content = mydb.get_table(FROM='vnfs join nets on vnfs.uuid=nets.vnf_id', + content = mydb.get_rows(FROM='vnfs join nets on vnfs.uuid=nets.vnf_id', SELECT=('nets.uuid as uuid','nets.name as name','nets.description as description', 'nets.type as type', 'nets.multipoint as multipoint'), WHERE={'vnfs.uuid': vnf_id} ) - if result < 0: - print "nfvo.get_vnf_id error %d %s" % (result, content) - return (result, content) - else: - if result==0: - data['vnf']['nets'] = [] - else: - data['vnf']['nets'] = content - #GET Interfaces - result,content = mydb.get_table(FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces on vms.uuid=interfaces.vm_id',\ + data['vnf']['nets'] = content + + #GET ip-profile for each net + for net in data['vnf']['nets']: + ipprofiles = mydb.get_rows(FROM='ip_profiles', + SELECT=('ip_version','subnet_address','gateway_address','dns_address','dhcp_enabled','dhcp_start_address','dhcp_count'), + WHERE={'net_id': net["uuid"]} ) + if len(ipprofiles)==1: + net["ip_profile"] = ipprofiles[0] + elif len(ipprofiles)>1: + raise NfvoException("More than one ip-profile found with this criteria: net_id='{}'".format(net['uuid']), HTTP_Bad_Request) + + + #TODO: For each net, GET its elements and relevant info per element (VNFC, iface, ip_address) and include them in the output. + + #GET External Interfaces + content = mydb.get_rows(FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces on vms.uuid=interfaces.vm_id',\ SELECT=('interfaces.uuid as uuid','interfaces.external_name as external_name', 'vms.name as vm_name', 'interfaces.vm_id as vm_id', \ 'interfaces.internal_name as internal_name', 'interfaces.type as type', 'interfaces.vpci as vpci','interfaces.bw as bw'),\ - WHERE={'vnfs.uuid': vnf_id}, + WHERE={'vnfs.uuid': vnf_id}, WHERE_NOT={'interfaces.external_name': None} ) #print content - if result < 0: - print "nfvo.get_vnf_id error %d %s" % (result, content) - return (result, content) - else: - if result==0: - data['vnf']['external-connections'] = [] - else: - data['vnf']['external-connections'] = content - return 0, data + data['vnf']['external-connections'] = content + + return data def delete_vnf(mydb,tenant_id,vnf_id,datacenter=None,vim_tenant=None): # Check tenant exist if tenant_id != "any": - if not check_tenant(mydb, tenant_id): - print 'nfvo.delete_vnf() tenant %s not found' % tenant_id - return -HTTP_Not_Found, 'Tenant %s not found' % tenant_id + check_tenant(mydb, tenant_id) # Get the URL of the VIM from the nfvo_tenant and the datacenter - result, vims = get_vim(mydb, tenant_id) - if result < 0: - print "nfvo.delete_vnf() error. Datacenter not found" - return result, vims + vims = get_vim(mydb, tenant_id) else: vims={} @@ -679,97 +1007,88 @@ def delete_vnf(mydb,tenant_id,vnf_id,datacenter=None,vim_tenant=None): if tenant_id != "any": where_or["tenant_id"] = tenant_id where_or["public"] = True - result, content = mydb.get_table_by_uuid_name('vnfs', vnf_id, "VNF", WHERE_OR=where_or, WHERE_AND_OR="AND") - if result < 0: - return result, content - vnf_id = content["uuid"] - + vnf = mydb.get_table_by_uuid_name('vnfs', vnf_id, "VNF", WHERE_OR=where_or, WHERE_AND_OR="AND") + vnf_id = vnf["uuid"] + # "Getting the list of flavors and tenants of the VNF" - result,flavorList = get_flavorlist(mydb, vnf_id) - if result < 0: - print flavorList - elif result==0: - print "delete_vnf error. No flavors found for the VNF id '%s'" % vnf_id - - result,imageList = get_imagelist(mydb, vnf_id) - print "imageList", imageList - if result < 0: - print imageList - elif result==0: - print "delete_vnf error. No images found for the VNF id '%s'" % vnf_id - - result, content = mydb.delete_row('vnfs', vnf_id, tenant_id) - if result == 0: - return -HTTP_Not_Found, content - elif result >0: - print content - else: - print "delete_vnf error",result, content - return result, content - + flavorList = get_flavorlist(mydb, vnf_id) + if len(flavorList)==0: + logger.warn("delete_vnf error. No flavors found for the VNF id '%s'", vnf_id) + + imageList = get_imagelist(mydb, vnf_id) + if len(imageList)==0: + logger.warn( "delete_vnf error. No images found for the VNF id '%s'", vnf_id) + + deleted = mydb.delete_row_by_id('vnfs', vnf_id) + if deleted == 0: + raise NfvoException("vnf '{}' not found".format(vnf_id), HTTP_Not_Found) + undeletedItems = [] for flavor in flavorList: #check if flavor is used by other vnf - r,c = mydb.get_table(FROM='vms', WHERE={'flavor_id':flavor} ) - if r < 0: - print 'delete_vnf_error. Not possible to delete VIM flavor "%s". %s' % (flavor,c) - undeletedItems.append("flavor "+ flavor["flavor_id"]) - elif r > 0: - print 'Flavor %s not deleted because it is being used by another VNF %s' %(flavor,str(c)) - continue - #flavor not used, must be deleted - #delelte at VIM - r,c = mydb.get_table(FROM='datacenters_flavors', WHERE={'flavor_id':flavor}) - if r>0: + try: + c = mydb.get_rows(FROM='vms', WHERE={'flavor_id':flavor} ) + if len(c) > 0: + logger.debug("Flavor '%s' not deleted because it is being used by another VNF", flavor) + continue + #flavor not used, must be deleted + #delelte at VIM + c = mydb.get_rows(FROM='datacenters_flavors', WHERE={'flavor_id':flavor}) for flavor_vim in c: if flavor_vim["datacenter_id"] not in vims: continue if flavor_vim['created']=='false': #skip this flavor because not created by openmano continue myvim=vims[ flavor_vim["datacenter_id"] ] - result, message = myvim.delete_tenant_flavor(flavor_vim["vim_id"]) - if result < 0: - print 'delete_vnf_error. Not possible to delete VIM flavor "%s". Message: %s' % (flavor,message) - if result != -HTTP_Not_Found: - undeletedItems.append("flavor %s from VIM %s" % (flavor_vim["vim_id"], flavor_vim["datacenter_id"] )) - #delete flavor from Database, using table flavors and with cascade foreign key also at datacenters_flavors - result, content = mydb.delete_row('flavors', flavor) - if result <0: + try: + myvim.delete_flavor(flavor_vim["vim_id"]) + except vimconn.vimconnNotFoundException as e: + logger.warn("VIM flavor %s not exist at datacenter %s", flavor_vim["vim_id"], flavor_vim["datacenter_id"] ) + except vimconn.vimconnException as e: + logger.error("Not possible to delete VIM flavor %s from datacenter %s: %s %s", + flavor_vim["vim_id"], flavor_vim["datacenter_id"], type(e).__name__, str(e)) + undeletedItems.append("flavor {} from VIM {}".format(flavor_vim["vim_id"], flavor_vim["datacenter_id"] )) + #delete flavor from Database, using table flavors and with cascade foreign key also at datacenters_flavors + mydb.delete_row_by_id('flavors', flavor) + except db_base_Exception as e: + logger.error("delete_vnf_error. Not possible to get flavor details and delete '%s'. %s", flavor, str(e)) undeletedItems.append("flavor %s" % flavor) - + + for image in imageList: - #check if image is used by other vnf - r,c = mydb.get_table(FROM='vms', WHERE={'image_id':image} ) - if r < 0: - print 'delete_vnf_error. Not possible to delete VIM image "%s". %s' % (image,c) - undeletedItems.append("image "+ image["image_id"]) - elif r > 0: - print 'Image %s not deleted because it is being used by another VNF %s' %(image,str(c)) - continue - #image not used, must be deleted - #delelte at VIM - r,c = mydb.get_table(FROM='datacenters_images', WHERE={'image_id':image}) - if r>0: + try: + #check if image is used by other vnf + c = mydb.get_rows(FROM='vms', WHERE={'image_id':image} ) + if len(c) > 0: + logger.debug("Image '%s' not deleted because it is being used by another VNF", image) + continue + #image not used, must be deleted + #delelte at VIM + c = mydb.get_rows(FROM='datacenters_images', WHERE={'image_id':image}) for image_vim in c: if image_vim["datacenter_id"] not in vims: continue if image_vim['created']=='false': #skip this image because not created by openmano continue myvim=vims[ image_vim["datacenter_id"] ] - result, message = myvim.delete_tenant_image(image_vim["vim_id"]) - if result < 0: - print 'delete_vnf_error. Not possible to delete VIM image "%s". Message: %s' % (image,message) - if result != -HTTP_Not_Found: - undeletedItems.append("image %s from VIM %s" % (image_vim["vim_id"], image_vim["datacenter_id"] )) - #delete image from Database, using table images and with cascade foreign key also at datacenters_images - result, content = mydb.delete_row('images', image) - if result <0: + try: + myvim.delete_image(image_vim["vim_id"]) + except vimconn.vimconnNotFoundException as e: + logger.warn("VIM image %s not exist at datacenter %s", image_vim["vim_id"], image_vim["datacenter_id"] ) + except vimconn.vimconnException as e: + logger.error("Not possible to delete VIM image %s from datacenter %s: %s %s", + image_vim["vim_id"], image_vim["datacenter_id"], type(e).__name__, str(e)) + undeletedItems.append("image {} from VIM {}".format(image_vim["vim_id"], image_vim["datacenter_id"] )) + #delete image from Database, using table images and with cascade foreign key also at datacenters_images + mydb.delete_row_by_id('images', image) + except db_base_Exception as e: + logger.error("delete_vnf_error. Not possible to get image details and delete '%s'. %s", image, str(e)) undeletedItems.append("image %s" % image) - if undeletedItems: - return 200, "delete_vnf error. Undeleted: %s" %(undeletedItems) - - return 200,vnf_id + return vnf_id + " " + vnf["name"] + #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) @@ -784,38 +1103,42 @@ 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): - result, vims = get_vim(mydb, nfvo_tenant_id) - if result < 0: - return result, vims - elif result == 0: - return -HTTP_Not_Found, "No datacenter found" + vims = get_vim(mydb, nfvo_tenant_id) + if len(vims) == 0: + raise NfvoException("No datacenter found for tenant '{}'".format(str(nfvo_tenant_id)), 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) myvim = vims.values()[0] - result,hosts = myvim.get_hosts() - if result < 0: - return result, hosts - print '===================' - print 'hosts '+ yaml.safe_dump(hosts, indent=4, default_flow_style=False) - - datacenter = {'Datacenters': [ {'name':myvim['name'],'servers':[]} ] } - for host in hosts: - server={'name':host['name'], 'vms':[]} - for vm in host['instances']: - #get internal name and model - r,c = mydb.get_table(SELECT=('name',), FROM='instance_vms as iv join vms on iv.vm_id=vms.uuid',\ - WHERE={'vim_vm_id':vm['id']} ) - if r==0: - print "nfvo.get_hosts virtual machine at VIM (%s) not found at tidnfvo" % vm['id'] - continue - if r<0: - print "nfvo.get_hosts virtual machine at VIM (%s) error %d %s" % (vm['id'], r, c) - continue - server['vms'].append( {'name':vm['name'] , 'model':c[0]['name']} ) - datacenter['Datacenters'][0]['servers'].append(server) - #return -400, "en construccion" - - #print 'datacenters '+ json.dumps(datacenter, indent=4) - return result, datacenter + try: + hosts = myvim.get_hosts() + logger.debug('VIM hosts response: '+ yaml.safe_dump(hosts, indent=4, default_flow_style=False)) + + datacenter = {'Datacenters': [ {'name':myvim['name'],'servers':[]} ] } + for host in hosts: + server={'name':host['name'], 'vms':[]} + for vm in host['instances']: + #get internal name and model + try: + c = mydb.get_rows(SELECT=('name',), FROM='instance_vms as iv join vms on iv.vm_id=vms.uuid',\ + WHERE={'vim_vm_id':vm['id']} ) + if len(c) == 0: + logger.warn("nfvo.get_hosts virtual machine at VIM '{}' not found at tidnfvo".format(vm['id'])) + continue + server['vms'].append( {'name':vm['name'] , 'model':c[0]['name']} ) + + except db_base_Exception as e: + logger.warn("nfvo.get_hosts virtual machine at VIM '{}' error {}".format(vm['id'], str(e))) + datacenter['Datacenters'][0]['servers'].append(server) + #return -400, "en construccion" + + #print 'datacenters '+ json.dumps(datacenter, indent=4) + return datacenter + 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): @@ -824,17 +1147,15 @@ def new_scenario(mydb, tenant_id, topo): # return result, vims #1: parse input if tenant_id != "any": - if not check_tenant(mydb, tenant_id): - print 'nfvo.new_scenario() tenant %s not found' % tenant_id - return -HTTP_Not_Found, 'Tenant %s not found' % tenant_id + check_tenant(mydb, tenant_id) if "tenant_id" in topo: if topo["tenant_id"] != tenant_id: - print "nfvo.new_scenario() tenant '%s' not found" % tenant_id - return -HTTP_Unauthorized, "VNF can not have a different tenant owner '%s', must be '%s'" %(topo["tenant_id"], tenant_id) + raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format(topo["tenant_id"], tenant_id), + HTTP_Unauthorized) else: tenant_id=None -#1.1: get VNFs and external_networks (other_nets). +#1.1: get VNFs and external_networks (other_nets). vnfs={} other_nets={} #external_networks, bridge_networks and data_networkds nodes = topo['topology']['nodes'] @@ -842,51 +1163,51 @@ def new_scenario(mydb, tenant_id, topo): if nodes[k]['type'] == 'VNF': vnfs[k] = nodes[k] vnfs[k]['ifaces'] = {} - elif nodes[k]['type'] == 'other_network' or nodes[k]['type'] == 'external_network': + elif nodes[k]['type'] == 'other_network' or nodes[k]['type'] == 'external_network': other_nets[k] = nodes[k] other_nets[k]['external']=True - elif nodes[k]['type'] == 'network': + elif nodes[k]['type'] == 'network': other_nets[k] = nodes[k] other_nets[k]['external']=False - + #1.2: Check that VNF are present at database table vnfs. Insert uuid, description and external interfaces for name,vnf in vnfs.items(): - WHERE_={} + where={} + where_or={"tenant_id": tenant_id, 'public': "true"} error_text = "" error_pos = "'topology':'nodes':'" + name + "'" if 'vnf_id' in vnf: error_text += " 'vnf_id' " + vnf['vnf_id'] - WHERE_['uuid'] = vnf['vnf_id'] + where['uuid'] = vnf['vnf_id'] if 'VNF model' in vnf: error_text += " 'VNF model' " + vnf['VNF model'] - WHERE_['name'] = vnf['VNF model'] - if len(WHERE_) == 0: - return -HTTP_Bad_Request, "needed a 'vnf_id' or 'VNF model' at " + error_pos - r,vnf_db = mydb.get_table(SELECT=('uuid','name','description'), FROM='vnfs', WHERE=WHERE_) - if r<0: - print "nfvo.new_scenario Error getting vnfs",r,vnf_db - elif r==0: - print "nfvo.new_scenario Error" + error_text + " is not present at database" - return -HTTP_Bad_Request, "unknown" + error_text + " at " + error_pos - elif r>1: - print "nfvo.new_scenario Error more than one" + error_text + " are present at database" - return -HTTP_Bad_Request, "more than one" + error_text + " at " + error_pos + " Concrete with 'vnf_id'" + where['name'] = vnf['VNF model'] + if len(where) == 0: + raise NfvoException("Descriptor need a 'vnf_id' or 'VNF model' field at " + error_pos, HTTP_Bad_Request) + + vnf_db = mydb.get_rows(SELECT=('uuid','name','description'), + FROM='vnfs', + WHERE=where, + WHERE_OR=where_or, + WHERE_AND_OR="AND") + if len(vnf_db)==0: + raise NfvoException("unknown" + error_text + " at " + error_pos, HTTP_Not_Found) + elif len(vnf_db)>1: + raise NfvoException("more than one" + error_text + " at " + error_pos + " Concrete with 'vnf_id'", HTTP_Conflict) vnf['uuid']=vnf_db[0]['uuid'] vnf['description']=vnf_db[0]['description'] #get external interfaces - r,ext_ifaces = mydb.get_table(SELECT=('external_name as name','i.uuid as iface_uuid', 'i.type as type'), - FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces as i on vms.uuid=i.vm_id', + ext_ifaces = mydb.get_rows(SELECT=('external_name as name','i.uuid as iface_uuid', 'i.type as type'), + FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces as i on vms.uuid=i.vm_id', WHERE={'vnfs.uuid':vnf['uuid']}, WHERE_NOT={'external_name':None} ) - if r<0: - print "nfvo.new_scenario Error getting external interfaces of vnfs",r,ext_ifaces - return -HTTP_Internal_Server_Error, "Error getting external interfaces of vnfs: " + ext_ifaces for ext_iface in ext_ifaces: vnf['ifaces'][ ext_iface['name'] ] = {'uuid':ext_iface['iface_uuid'], 'type':ext_iface['type']} #1.4 get list of connections conections = topo['topology']['connections'] conections_list = [] + conections_list_name = [] for k in conections.keys(): if type(conections[k]['nodes'])==dict: #dict with node:iface pairs ifaces_list = conections[k]['nodes'].items() @@ -899,31 +1220,33 @@ def new_scenario(mydb, tenant_id, topo): con_type = conections[k].get("type", "link") if con_type != "link": if k in other_nets: - return -HTTP_Bad_Request, "format error. Reapeted network name at 'topology':'connections':'%s'" % (str(k)) + raise NfvoException("Format error. Reapeted network name at 'topology':'connections':'{}'".format(str(k)), HTTP_Bad_Request) other_nets[k] = {'external': False} if conections[k].get("graph"): other_nets[k]["graph"] = conections[k]["graph"] ifaces_list.append( (k, None) ) - + if con_type == "external_network": other_nets[k]['external'] = True if conections[k].get("model"): other_nets[k]["model"] = conections[k]["model"] else: other_nets[k]["model"] = k - if con_type == "dataplane_net" or con_type == "bridge_net": + if con_type == "dataplane_net" or con_type == "bridge_net": other_nets[k]["model"] = con_type - - + + conections_list_name.append(k) conections_list.append(set(ifaces_list)) #from list to set to operate as a set (this conversion removes elements that are repeated in a list) #print set(ifaces_list) #check valid VNF and iface names for iface in ifaces_list: if iface[0] not in vnfs and iface[0] not in other_nets : - return -HTTP_Bad_Request, "format error. Invalid VNF name at 'topology':'connections':'%s':'nodes':'%s'" % (str(k), iface[0]) + raise NfvoException("format error. Invalid VNF name at 'topology':'connections':'{}':'nodes':'{}'".format( + str(k), iface[0]), HTTP_Not_Found) if iface[0] in vnfs and iface[1] not in vnfs[ iface[0] ]['ifaces']: - return -HTTP_Bad_Request, "format error. Invalid interface name at 'topology':'connections':'%s':'nodes':'%s':'%s'" % (str(k), iface[0], iface[1]) + raise NfvoException("format error. Invalid interface name at 'topology':'connections':'{}':'nodes':'{}':'{}'".format( + str(k), iface[0], iface[1]), HTTP_Not_Found) #1.5 unify connections from the pair list to a consolidated list index=0 @@ -933,13 +1256,14 @@ def new_scenario(mydb, tenant_id, topo): if len(conections_list[index] & conections_list[index2])>0: #common interface, join nets conections_list[index] |= conections_list[index2] del conections_list[index2] + del conections_list_name[index2] else: index2 += 1 conections_list[index] = list(conections_list[index]) # from set to list again index += 1 #for k in conections_list: # print k - + #1.6 Delete non external nets @@ -959,17 +1283,17 @@ def new_scenario(mydb, tenant_id, topo): if 'name' not in net: net['name']=k if 'model' not in net: - return -HTTP_Bad_Request, "needed a 'model' at " + error_pos + raise NfvoException("needed a 'model' at " + error_pos, HTTP_Bad_Request) if net['model']=='bridge_net': net['type']='bridge'; elif net['model']=='dataplane_net': net['type']='data'; else: - return -HTTP_Bad_Request, "unknown 'model' '"+ net['model'] +"' at " + error_pos + raise NfvoException("unknown 'model' '"+ net['model'] +"' at " + error_pos, HTTP_Not_Found) else: #external #IF we do not want to check that external network exist at datacenter pass -#ELSE +#ELSE # error_text = "" # WHERE_={} # if 'net_id' in net: @@ -988,10 +1312,10 @@ def new_scenario(mydb, tenant_id, topo): # print "nfvo.new_scenario Error" +error_text+ " is not present at database" # return -HTTP_Bad_Request, "unknown " +error_text+ " at " + error_pos # elif r>1: -# print "nfvo.new_scenario Error more than one external_network for " +error_text+ " is present at database" -# return -HTTP_Bad_Request, "more than one external_network for " +error_text+ "at "+ error_pos + " Concrete with 'net_id'" +# print "nfvo.new_scenario Error more than one external_network for " +error_text+ " is present at database" +# return -HTTP_Bad_Request, "more than one external_network for " +error_text+ "at "+ error_pos + " Concrete with 'net_id'" # other_nets[k].update(net_db[0]) -#ENDIF +#ENDIF net_list={} net_nb=0 #Number of nets for con in conections_list: @@ -1004,9 +1328,9 @@ def new_scenario(mydb, tenant_id, topo): for net_key in other_nets.keys(): if con[index][0]==net_key: if other_net_index>=0: - error_text="There is some interface connected both to net '%s' and net '%s'" % (con[other_net_index][0], net_key) - print "nfvo.new_scenario " + error_text - return -HTTP_Bad_Request, error_text + error_text="There is some interface connected both to net '%s' and net '%s'" % (con[other_net_index][0], net_key) + #print "nfvo.new_scenario " + error_text + raise NfvoException(error_text, HTTP_Bad_Request) else: other_net_index = index net_target = net_key @@ -1024,14 +1348,14 @@ def new_scenario(mydb, tenant_id, topo): other_nets[net_target]["type"] = "data" else: other_nets[net_target]["type"] = "bridge" -#ELSE +#ELSE # if other_nets[net_target]['external'] : # type_='data' if len(con)>1 else 'ptp' #an external net is connected to a external port, so it is ptp if only one connection is done to this net # if type_=='data' and other_nets[net_target]['type']=="ptp": # error_text = "Error connecting %d nodes on a not multipoint net %s" % (len(con), net_target) # print "nfvo.new_scenario " + error_text # return -HTTP_Bad_Request, error_text -#ENDIF +#ENDIF for iface in con: vnfs[ iface[0] ]['ifaces'][ iface[1] ]['net_key'] = net_target else: @@ -1039,8 +1363,9 @@ def new_scenario(mydb, tenant_id, topo): net_type_bridge=False net_type_data=False net_target = "__-__net"+str(net_nb) - net_list[net_target] = {'name': "net-"+str(net_nb), 'description':"net-%s in scenario %s" %(net_nb,topo['name']), - 'external':False} + net_list[net_target] = {'name': conections_list_name[net_nb], #"net-"+str(net_nb), + 'description':"net-%s in scenario %s" %(net_nb,topo['name']), + 'external':False} for iface in con: vnfs[ iface[0] ]['ifaces'][ iface[1] ]['net_key'] = net_target iface_type = vnfs[ iface[0] ]['ifaces'][ iface[1] ]['type'] @@ -1050,8 +1375,8 @@ def new_scenario(mydb, tenant_id, topo): net_type_data = True if net_type_bridge and net_type_data: error_text = "Error connection interfaces of bridge type with data type. Firs node %s, iface %s" % (iface[0], iface[1]) - print "nfvo.new_scenario " + error_text - return -HTTP_Bad_Request, error_text + #print "nfvo.new_scenario " + error_text + raise NfvoException(error_text, HTTP_Bad_Request) elif net_type_bridge: type_='bridge' else: @@ -1060,16 +1385,16 @@ def new_scenario(mydb, tenant_id, topo): net_nb+=1 except Exception: error_text = "Error connection node %s : %s does not match any VNF or interface" % (iface[0], iface[1]) - print "nfvo.new_scenario " + error_text + #print "nfvo.new_scenario " + error_text #raise e - return -HTTP_Bad_Request, error_text + raise NfvoException(error_text, HTTP_Bad_Request) #1.8: Connect to management net all not already connected interfaces of type 'mgmt' - #1.8.1 obtain management net - r,mgmt_net = mydb.get_table(SELECT=('uuid','name','description','type','shared'), + #1.8.1 obtain management net + mgmt_net = mydb.get_rows(SELECT=('uuid','name','description','type','shared'), FROM='datacenter_nets', WHERE={'name':'mgmt'} ) - #1.8.2 check all interfaces from all vnfs - if r>0: + #1.8.2 check all interfaces from all vnfs + if len(mgmt_net)>0: add_mgmt_net = False for vnf in vnfs.values(): for iface in vnf['ifaces'].values(): @@ -1083,554 +1408,772 @@ def new_scenario(mydb, tenant_id, topo): net_list['mgmt']['graph']={'visible':False} net_list.update(other_nets) - print - print 'net_list', net_list - print - print 'vnfs', vnfs - print + #print + #print 'net_list', net_list + #print + #print 'vnfs', vnfs + #print #2: insert scenario. filling tables scenarios,sce_vnfs,sce_interfaces,sce_nets - r,c = mydb.new_scenario( { 'vnfs':vnfs, 'nets':net_list, + c = mydb.new_scenario( { 'vnfs':vnfs, 'nets':net_list, 'tenant_id':tenant_id, 'name':topo['name'], 'description':topo.get('description',topo['name']), 'public': topo.get('public', False) }) - - return r,c -def new_scenario_v02(mydb, tenant_id, scenario_dict): + 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"] if tenant_id != "any": - if not check_tenant(mydb, tenant_id): - print 'nfvo.new_scenario_v02() tenant %s not found' % tenant_id - return -HTTP_Not_Found, 'Tenant %s not found' % tenant_id + check_tenant(mydb, tenant_id) if "tenant_id" in scenario: if scenario["tenant_id"] != tenant_id: - print "nfvo.new_scenario_v02() tenant '%s' not found" % tenant_id - return -HTTP_Unauthorized, "VNF can not have a different tenant owner '%s', must be '%s'" %(scenario["tenant_id"], tenant_id) + # print "nfvo.new_scenario_v02() tenant '%s' not found" % tenant_id + raise NfvoException("VNF can not have a different tenant owner '{}', must be '{}'".format( + scenario["tenant_id"], tenant_id), HTTP_Unauthorized) else: tenant_id=None -#1: Check that VNF are present at database table vnfs and update content into scenario dict + # 1: Check that VNF are present at database table vnfs and update content into scenario dict for name,vnf in scenario["vnfs"].iteritems(): - WHERE_={} + where={} + where_or={"tenant_id": tenant_id, 'public': "true"} error_text = "" - error_pos = "'topology':'nodes':'" + name + "'" + error_pos = "'scenario':'vnfs':'" + name + "'" if 'vnf_id' in vnf: - error_text += " 'vnf_id' " + vnf['vnf_id'] - WHERE_['uuid'] = vnf['vnf_id'] + error_text += " 'vnf_id' " + vnf['vnf_id'] + where['uuid'] = vnf['vnf_id'] if 'vnf_name' in vnf: - error_text += " 'vnf_name' " + vnf['vnf_name'] - WHERE_['name'] = vnf['vnf_name'] - if len(WHERE_) == 0: - return -HTTP_Bad_Request, "needed a 'vnf_id' or 'VNF model' at " + error_pos - r,vnf_db = mydb.get_table(SELECT=('uuid','name','description'), FROM='vnfs', WHERE=WHERE_) - if r<0: - print "nfvo.new_scenario Error getting vnfs",r,vnf_db - elif r==0: - print "nfvo.new_scenario Error" + error_text + " is not present at database" - return -HTTP_Bad_Request, "unknown" + error_text + " at " + error_pos - elif r>1: - print "nfvo.new_scenario Error more than one" + error_text + " are present at database" - return -HTTP_Bad_Request, "more than one" + error_text + " at " + error_pos + " Concrete with 'vnf_id'" - vnf['uuid']=vnf_db[0]['uuid'] - vnf['description']=vnf_db[0]['description'] + error_text += " 'vnf_name' " + vnf['vnf_name'] + where['name'] = vnf['vnf_name'] + if len(where) == 0: + raise NfvoException("Needed a 'vnf_id' or 'vnf_name' at " + error_pos, HTTP_Bad_Request) + vnf_db = mydb.get_rows(SELECT=('uuid', 'name', 'description'), + FROM='vnfs', + WHERE=where, + WHERE_OR=where_or, + WHERE_AND_OR="AND") + if len(vnf_db) == 0: + raise NfvoException("Unknown" + error_text + " at " + error_pos, HTTP_Not_Found) + elif len(vnf_db) > 1: + raise NfvoException("More than one" + error_text + " at " + error_pos + " Concrete with 'vnf_id'", HTTP_Conflict) + vnf['uuid'] = vnf_db[0]['uuid'] + vnf['description'] = vnf_db[0]['description'] vnf['ifaces'] = {} - #get external interfaces - r,ext_ifaces = mydb.get_table(SELECT=('external_name as name','i.uuid as iface_uuid', 'i.type as type'), - FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces as i on vms.uuid=i.vm_id', - WHERE={'vnfs.uuid':vnf['uuid']}, WHERE_NOT={'external_name':None} ) - if r<0: - print "nfvo.new_scenario Error getting external interfaces of vnfs",r,ext_ifaces - return -HTTP_Internal_Server_Error, "Error getting external interfaces of vnfs: " + ext_ifaces + # get external interfaces + ext_ifaces = mydb.get_rows(SELECT=('external_name as name', 'i.uuid as iface_uuid', 'i.type as type'), + FROM='vnfs join vms on vnfs.uuid=vms.vnf_id join interfaces as i on vms.uuid=i.vm_id', + WHERE={'vnfs.uuid':vnf['uuid']}, WHERE_NOT={'external_name': None} ) for ext_iface in ext_ifaces: - vnf['ifaces'][ ext_iface['name'] ] = {'uuid':ext_iface['iface_uuid'], 'type':ext_iface['type']} + vnf['ifaces'][ ext_iface['name'] ] = {'uuid':ext_iface['iface_uuid'], 'type': ext_iface['type']} + # TODO? get internal-connections from db.nets and their profiles, and update scenario[vnfs][internal-connections] accordingly -#2: Insert net_key at every vnf interface - for net_name,net in scenario["networks"].iteritems(): - net_type_bridge=False - net_type_data=False + # 2: Insert net_key and ip_address at every vnf interface + for net_name, net in scenario["networks"].items(): + net_type_bridge = False + net_type_data = False for iface_dict in net["interfaces"]: - for vnf,iface in iface_dict.iteritems(): + if version == "0.2": + temp_dict = iface_dict + ip_address = None + elif version == "0.3": + temp_dict = {iface_dict["vnf"] : iface_dict["vnf_interface"]} + ip_address = iface_dict.get('ip_address', None) + for vnf, iface in temp_dict.items(): if vnf not in scenario["vnfs"]: - error_text = "Error at 'networks':'%s':'interfaces' VNF '%s' not match any VNF at 'vnfs'" % (net_name, vnf) - print "nfvo.new_scenario_v02 " + error_text - return -HTTP_Bad_Request, error_text + error_text = "Error at 'networks':'{}':'interfaces' VNF '{}' not match any VNF at 'vnfs'".format( + net_name, vnf) + # logger.debug("nfvo.new_scenario_v02 " + error_text) + raise NfvoException(error_text, HTTP_Not_Found) if iface not in scenario["vnfs"][vnf]['ifaces']: - error_text = "Error at 'networks':'%s':'interfaces':'%s' interface not match any VNF interface" % (net_name, iface) - print "nfvo.new_scenario_v02 " + error_text - return -HTTP_Bad_Request, error_text + error_text = "Error at 'networks':'{}':'interfaces':'{}' interface not match any VNF interface"\ + .format(net_name, iface) + # logger.debug("nfvo.new_scenario_v02 " + error_text) + raise NfvoException(error_text, HTTP_Bad_Request) if "net_key" in scenario["vnfs"][vnf]['ifaces'][iface]: - error_text = "Error at 'networks':'%s':'interfaces':'%s' interface already connected at network '%s'" \ - % (net_name, iface,scenario["vnfs"][vnf]['ifaces'][iface]['net_key']) - print "nfvo.new_scenario_v02 " + error_text - return -HTTP_Bad_Request, error_text + error_text = "Error at 'networks':'{}':'interfaces':'{}' interface already connected at network"\ + "'{}'".format(net_name, iface,scenario["vnfs"][vnf]['ifaces'][iface]['net_key']) + # logger.debug("nfvo.new_scenario_v02 " + error_text) + raise NfvoException(error_text, HTTP_Bad_Request) scenario["vnfs"][vnf]['ifaces'][ iface ]['net_key'] = net_name + scenario["vnfs"][vnf]['ifaces'][iface]['ip_address'] = ip_address iface_type = scenario["vnfs"][vnf]['ifaces'][iface]['type'] - if iface_type=='mgmt' or iface_type=='bridge': + if iface_type == 'mgmt' or iface_type == 'bridge': net_type_bridge = True else: net_type_data = True + if net_type_bridge and net_type_data: - error_text = "Error connection interfaces of bridge type and data type at 'networks':'%s':'interfaces'" % (net_name) - print "nfvo.new_scenario " + error_text - return -HTTP_Bad_Request, error_text + error_text = "Error connection interfaces of 'bridge' type and 'data' type at 'networks':'{}':'interfaces'"\ + .format(net_name) + # logger.debug("nfvo.new_scenario " + error_text) + raise NfvoException(error_text, HTTP_Bad_Request) elif net_type_bridge: - type_='bridge' + type_ = 'bridge' else: - type_='data' if len(net["interfaces"])>2 else 'ptp' + type_ = 'data' if len(net["interfaces"]) > 2 else 'ptp' + + if net.get("implementation"): # for v0.3 + if type_ == "bridge" and net["implementation"] == "underlay": + error_text = "Error connecting interfaces of data type to a network declared as 'underlay' at "\ + "'network':'{}'".format(net_name) + # logger.debug(error_text) + raise NfvoException(error_text, HTTP_Bad_Request) + elif type_ != "bridge" and net["implementation"] == "overlay": + error_text = "Error connecting interfaces of data type to a network declared as 'overlay' at "\ + "'network':'{}'".format(net_name) + # logger.debug(error_text) + raise NfvoException(error_text, HTTP_Bad_Request) + net.pop("implementation") + if "type" in net and version == "0.3": # for v0.3 + if type_ == "data" and net["type"] == "e-line": + error_text = "Error connecting more than 2 interfaces of data type to a network declared as type "\ + "'e-line' at 'network':'{}'".format(net_name) + # logger.debug(error_text) + raise NfvoException(error_text, HTTP_Bad_Request) + elif type_ == "ptp" and net["type"] == "e-lan": + type_ = "data" + net['type'] = type_ net['name'] = net_name net['external'] = net.get('external', False) -#3: insert at database + # 3: insert at database scenario["nets"] = scenario["networks"] scenario['tenant_id'] = tenant_id - r,c = mydb.new_scenario( scenario) - - return r,c + 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 - r,c = mydb.edit_scenario( data ) - return r,c + 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 = None - datacenter_name=None - if datacenter != None: - if af.check_valid_uuid(datacenter): - datacenter_id = datacenter - else: - datacenter_name = datacenter - result, vims = get_vim(mydb, tenant_id, datacenter_id, datacenter_name, vim_tenant) - if result < 0: - print "start_scenario error. Datacenter not found" - return result, vims - elif result == 0: - return -HTTP_Not_Found, "datacenter '%s' not found" % str(datacenter) - elif result > 1: - print "start_scenario error. Several datacenters available, you must concrete" - return -HTTP_Bad_Request, "Several datacenters available, you must concrete" - myvim = vims.values()[0] + #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) + 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['datacenter2tenant'] = { datacenter_id: myvim['config']['datacenter_tenant_id'] } + scenarioDict['datacenter_id'] = datacenter_id + #print '================scenarioDict=======================' + #print json.dumps(scenarioDict, indent=4) + #print 'BEGIN launching instance scenario "%s" based on "%s"' % (instance_scenario_name,scenarioDict['name']) - print "Checking that the scenario_id exists and getting the scenario dictionary" - result, scenarioDict = mydb.get_scenario(scenario_id, tenant_id, datacenter_id) - if result < 0: - print "start_scenario error. Error interacting with NFVO DB" - return result, scenarioDict - elif result == 0: - print "start_scenario error. Scenario not found" - return result, scenarioDict - - scenarioDict['datacenter_tenant_id'] = datacenter_tenant_id - scenarioDict['datacenter_id'] = datacenter_id - print '================scenarioDict=======================' - #print json.dumps(scenarioDict, indent=4) - print 'BEGIN launching instance scenario "%s" based on "%s"' % (instance_scenario_name,scenarioDict['name']) - - print "Scenario %s: consisting of %d VNF(s)" % (scenarioDict['name'],len(scenarioDict['vnfs'])) - print yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False) - - auxNetDict = {} #Auxiliar dictionary. First key:'scenario' or sce_vnf uuid. Second Key: uuid of the net/sce_net. Value: vim_net_id - auxNetDict['scenario'] = {} - - print "1. Creating new nets (sce_nets) in the VIM" - for sce_net in scenarioDict['nets']: - print "Net name: %s. Description: %s" % (sce_net["name"], sce_net["description"]) - - myNetName = "%s.%s" % (instance_scenario_name, sce_net['name']) - myNetName = myNetName[0:255] #limit length - myNetType = sce_net['type'] - myNetDict = {} - myNetDict["name"] = myNetName - myNetDict["type"] = myNetType - myNetDict["tenant_id"] = myvim_tenant - #TODO: - #We should use the dictionary as input parameter for new_tenant_network - print myNetDict - if not sce_net["external"]: - result, network_id = myvim.new_tenant_network(myNetName, myNetType) - if result < 0: - print "Error creating network: %s." %network_id - _, message = rollback(mydb, vims, rollbackList) - return result, "Error creating network: "+ network_id + "."+message - - print "New VIM network created for scenario %s. Network id: %s" % (scenarioDict['name'],network_id) - sce_net['vim_id'] = network_id - auxNetDict['scenario'][sce_net['uuid']] = network_id - rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':network_id}) - else: - if sce_net['vim_id'] == None: - error_text = "Error, datacenter '%s' does not have external network '%s'." % (datacenter_name, sce_net['name']) - _, message = rollback(mydb, vims, rollbackList) - print "nfvo.start_scenario: " + error_text - return -HTTP_Bad_Request, error_text - print "Using existent VIM network for scenario %s. Network id %s" % (scenarioDict['name'],sce_net['vim_id']) - auxNetDict['scenario'][sce_net['uuid']] = sce_net['vim_id'] - - print "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']: - print "Net name: %s. Description: %s" % (net["name"], net["description"]) - - myNetName = "%s.%s" % (instance_scenario_name,net['name']) + logger.debug("start_scenario Scenario %s: consisting of %d VNF(s)", scenarioDict['name'],len(scenarioDict['vnfs'])) + #print yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False) + + auxNetDict = {} #Auxiliar dictionary. First key:'scenario' or sce_vnf uuid. Second Key: uuid of the net/sce_net. Value: vim_net_id + auxNetDict['scenario'] = {} + + logger.debug("start_scenario 1. Creating new nets (sce_nets) in the VIM") + for sce_net in scenarioDict['nets']: + #print "Net name: %s. Description: %s" % (sce_net["name"], sce_net["description"]) + + myNetName = "%s.%s" % (instance_scenario_name, sce_net['name']) myNetName = myNetName[0:255] #limit length - myNetType = net['type'] + myNetType = sce_net['type'] myNetDict = {} myNetDict["name"] = myNetName myNetDict["type"] = myNetType myNetDict["tenant_id"] = myvim_tenant - print myNetDict + myNetIPProfile = sce_net.get('ip_profile', None) #TODO: - #We should use the dictionary as input parameter for new_tenant_network - result, network_id = myvim.new_tenant_network(myNetName, myNetType) - if result < 0: - error_text="Error creating network: %s." % network_id - _, message = rollback(mydb, vims, rollbackList) - error_text += message - print "start_scenario: " + error_text - return result, error_text - print "VIM network id for scenario %s: %s" % (scenarioDict['name'],network_id) - net['vim_id'] = network_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}) - - print "auxNetDict:" - print yaml.safe_dump(auxNetDict, indent=4, default_flow_style=False) - - print "3. Creating new vm instances in the VIM" - #myvim.new_tenant_vminstance(self,vimURI,tenant_id,name,description,image_id,flavor_id,net_dict) - i = 0 - for sce_vnf in scenarioDict['vnfs']: - for vm in sce_vnf['vms']: - i += 1 - myVMDict = {} - #myVMDict['name'] = "%s-%s-%s" % (scenarioDict['name'],sce_vnf['name'], vm['name']) - myVMDict['name'] = "%s.%s.%d" % (instance_scenario_name,sce_vnf['name'],i) - #myVMDict['description'] = vm['description'] - myVMDict['description'] = myVMDict['name'][0:99] - if not startvms: - myVMDict['start'] = "no" - myVMDict['name'] = myVMDict['name'][0:255] #limit name length - print "VM name: %s. Description: %s" % (myVMDict['name'], myVMDict['name']) - - #create image at vim in case it not exist - res, image_dict = mydb.get_table_by_uuid_name("images", vm['image_id']) - if res<0: - print "start_scenario error getting image", image_dict - return res, image_dict - res, image_id = create_or_use_image(mydb, vims, image_dict, [], True) - if res < 0: - print "start_scenario error adding image to VIM", image_dict - return res, image_id - vm['vim_image_id'] = image_id - - #create flavor at vim in case it not exist - res, flavor_dict = mydb.get_table_by_uuid_name("flavors", vm['flavor_id']) - if res<0: - print "start_scenario error getting flavor", flavor_dict - return res, flavor_dict - if flavor_dict['extended']!=None: - flavor_dict['extended']= yaml.load(flavor_dict['extended']) - res, flavor_id = create_or_use_flavor(mydb, vims, flavor_dict, [], True) - if res < 0: - print "start_scenario error adding flavor to VIM", flavor_dict - return res, flavor_id - vm['vim_flavor_id'] = flavor_id - - - myVMDict['imageRef'] = vm['vim_image_id'] - myVMDict['flavorRef'] = vm['vim_flavor_id'] - myVMDict['networks'] = [] - for iface in vm['interfaces']: - netDict = {} - if iface['type']=="data": - netDict['type'] = iface['model'] - elif "model" in iface and iface["model"]!=None: - netDict['model']=iface['model'] - #TODO in future, remove this because mac_address will not be set, and the type of PV,VF is obtained from iterface table model - #discover type of interface looking at flavor - for numa in flavor_dict.get('extended',{}).get('numas',[]): - for flavor_iface in numa.get('interfaces',[]): - if flavor_iface.get('name') == iface['internal_name']: - if flavor_iface['dedicated'] == 'yes': - netDict['type']="PF" #passthrough - elif flavor_iface['dedicated'] == 'no': - netDict['type']="VF" #siov - elif flavor_iface['dedicated'] == 'yes:sriov': - netDict['type']="VFnotShared" #sriov but only one sriov on the PF - netDict["mac_address"] = flavor_iface.get("mac_address") - break; - netDict["use"]=iface['type'] - if netDict["use"]=="data" and not netDict.get("type"): - #print "netDict", netDict - #print "iface", iface - e_text = "Cannot determine the interface type PF or VF of VNF '%s' VM '%s' iface '%s'" %(sce_vnf['name'], vm['name'], iface['internal_name']) - if flavor_dict.get('extended')==None: - return -HTTP_Conflict, e_text + "After database migration some information is not available. \ - Try to delete and create the scenarios and VNFs again" - else: - return -HTTP_Internal_Server_Error, e_text - if netDict["use"]=="mgmt" or netDict["use"]=="bridge": - netDict["type"]="virtual" - if "vpci" in iface and iface["vpci"] is not None: - netDict['vpci'] = iface['vpci'] - if "mac" in iface and iface["mac"] is not None: - netDict['mac_address'] = iface['mac'] - netDict['name'] = iface['internal_name'] - if iface['net_id'] is None: - for vnf_iface in sce_vnf["interfaces"]: - print iface - print vnf_iface - if vnf_iface['interface_id']==iface['uuid']: - netDict['net_id'] = auxNetDict['scenario'][ vnf_iface['sce_net_id'] ] - break - else: - netDict['net_id'] = auxNetDict[ sce_vnf['uuid'] ][ iface['net_id'] ] - #skip bridge ifaces not connected to any net - #if 'net_id' not in netDict or netDict['net_id']==None: - # continue - myVMDict['networks'].append(netDict) - print ">>>>>>>>>>>>>>>>>>>>>>>>>>>" - print myVMDict['name'] - print "networks", yaml.safe_dump(myVMDict['networks'], indent=4, default_flow_style=False) - print "interfaces", yaml.safe_dump(vm['interfaces'], indent=4, default_flow_style=False) - print ">>>>>>>>>>>>>>>>>>>>>>>>>>>" - result, vm_id = myvim.new_tenant_vminstance(myVMDict['name'],myVMDict['description'],myVMDict.get('start', None), - myVMDict['imageRef'],myVMDict['flavorRef'],myVMDict['networks']) - if result < 0: - error_text = "Error creating vm instance: %s." % vm_id - _, message = rollback(mydb, vims, rollbackList) - error_text += message - print "start_scenario: " + error_text - return result, error_text - print "VIM vm instance id (server id) for scenario %s: %s" % (scenarioDict['name'],vm_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] - for net in myVMDict['networks']: - if "vim_id" in net: - for iface in vm['interfaces']: - if net["name"]==iface["internal_name"]: - iface["vim_id"]=net["vim_id"] - break - - print "==================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) - result,c = mydb.new_instance_scenario_as_a_whole(tenant_id,instance_scenario_name, instance_scenario_description, scenarioDict) - if result <0: - error_text = c + "." - _, message = rollback(mydb, vims, rollbackList) - error_text += message - print "start_scenario: " + error_text - return result, error_text - - return mydb.get_instance_scenario(c) + #We should use the dictionary as input parameter for new_network + #print myNetDict + if not sce_net["external"]: + network_id = myvim.new_network(myNetName, myNetType, myNetIPProfile) + #print "New VIM network created for scenario %s. Network id: %s" % (scenarioDict['name'],network_id) + sce_net['vim_id'] = network_id + auxNetDict['scenario'][sce_net['uuid']] = network_id + rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':network_id}) + sce_net["created"] = True + else: + if sce_net['vim_id'] == None: + error_text = "Error, datacenter '%s' does not have external network '%s'." % (datacenter_name, sce_net['name']) + _, message = rollback(mydb, vims, rollbackList) + logger.error("nfvo.start_scenario: %s", error_text) + raise NfvoException(error_text, HTTP_Bad_Request) + logger.debug("Using existent VIM network for scenario %s. Network id %s", scenarioDict['name'],sce_net['vim_id']) + auxNetDict['scenario'][sce_net['uuid']] = sce_net['vim_id'] + + logger.debug("start_scenario 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']: + #print "Net name: %s. Description: %s" % (net["name"], net["description"]) + + myNetName = "%s.%s" % (instance_scenario_name,net['name']) + myNetName = myNetName[0:255] #limit length + myNetType = net['type'] + myNetDict = {} + myNetDict["name"] = myNetName + myNetDict["type"] = myNetType + myNetDict["tenant_id"] = myvim_tenant + myNetIPProfile = net.get('ip_profile', None) + #print myNetDict + #TODO: + #We should use the dictionary as input parameter for new_network + network_id = myvim.new_network(myNetName, myNetType, myNetIPProfile) + #print "VIM network id for scenario %s: %s" % (scenarioDict['name'],network_id) + net['vim_id'] = network_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}) + net["created"] = True + + #print "auxNetDict:" + #print yaml.safe_dump(auxNetDict, indent=4, default_flow_style=False) + + logger.debug("start_scenario 3. Creating new vm instances in the VIM") + #myvim.new_vminstance(self,vimURI,tenant_id,name,description,image_id,flavor_id,net_dict) + i = 0 + for sce_vnf in scenarioDict['vnfs']: + for vm in sce_vnf['vms']: + i += 1 + myVMDict = {} + #myVMDict['name'] = "%s-%s-%s" % (scenarioDict['name'],sce_vnf['name'], vm['name']) + myVMDict['name'] = "{}.{}.{}".format(instance_scenario_name,sce_vnf['name'],chr(96+i)) + #myVMDict['description'] = vm['description'] + myVMDict['description'] = myVMDict['name'][0:99] + if not startvms: + myVMDict['start'] = "no" + myVMDict['name'] = myVMDict['name'][0:255] #limit name length + #print "VM name: %s. Description: %s" % (myVMDict['name'], myVMDict['name']) + + #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, vims, image_dict, [], True) + vm['vim_image_id'] = image_id + + #create flavor at vim in case it not exist + flavor_dict = mydb.get_table_by_uuid_name("flavors", vm['flavor_id']) + if flavor_dict['extended']!=None: + flavor_dict['extended']= yaml.load(flavor_dict['extended']) + flavor_id = create_or_use_flavor(mydb, vims, flavor_dict, [], True) + vm['vim_flavor_id'] = flavor_id + + + myVMDict['imageRef'] = vm['vim_image_id'] + myVMDict['flavorRef'] = vm['vim_flavor_id'] + myVMDict['networks'] = [] + for iface in vm['interfaces']: + netDict = {} + if iface['type']=="data": + netDict['type'] = iface['model'] + elif "model" in iface and iface["model"]!=None: + netDict['model']=iface['model'] + #TODO in future, remove this because mac_address will not be set, and the type of PV,VF is obtained from iterface table model + #discover type of interface looking at flavor + for numa in flavor_dict.get('extended',{}).get('numas',[]): + for flavor_iface in numa.get('interfaces',[]): + if flavor_iface.get('name') == iface['internal_name']: + if flavor_iface['dedicated'] == 'yes': + netDict['type']="PF" #passthrough + elif flavor_iface['dedicated'] == 'no': + netDict['type']="VF" #siov + elif flavor_iface['dedicated'] == 'yes:sriov': + netDict['type']="VFnotShared" #sriov but only one sriov on the PF + netDict["mac_address"] = flavor_iface.get("mac_address") + break; + netDict["use"]=iface['type'] + if netDict["use"]=="data" and not netDict.get("type"): + #print "netDict", netDict + #print "iface", iface + e_text = "Cannot determine the interface type PF or VF of VNF '%s' VM '%s' iface '%s'" %(sce_vnf['name'], vm['name'], iface['internal_name']) + if flavor_dict.get('extended')==None: + raise NfvoException(e_text + "After database migration some information is not available. \ + Try to delete and create the scenarios and VNFs again", HTTP_Conflict) + else: + raise NfvoException(e_text, HTTP_Internal_Server_Error) + if netDict["use"]=="mgmt" or netDict["use"]=="bridge": + netDict["type"]="virtual" + if "vpci" in iface and iface["vpci"] is not None: + netDict['vpci'] = iface['vpci'] + if "mac" in iface and iface["mac"] is not None: + netDict['mac_address'] = iface['mac'] + if "port-security" in iface and iface["port-security"] is not None: + netDict['port_security'] = iface['port-security'] + if "floating-ip" in iface and iface["floating-ip"] is not None: + netDict['floating_ip'] = iface['floating-ip'] + netDict['name'] = iface['internal_name'] + if iface['net_id'] is None: + for vnf_iface in sce_vnf["interfaces"]: + #print iface + #print vnf_iface + if vnf_iface['interface_id']==iface['uuid']: + netDict['net_id'] = auxNetDict['scenario'][ vnf_iface['sce_net_id'] ] + break + else: + netDict['net_id'] = auxNetDict[ sce_vnf['uuid'] ][ iface['net_id'] ] + #skip bridge ifaces not connected to any net + #if 'net_id' not in netDict or netDict['net_id']==None: + # continue + myVMDict['networks'].append(netDict) + #print ">>>>>>>>>>>>>>>>>>>>>>>>>>>" + #print myVMDict['name'] + #print "networks", yaml.safe_dump(myVMDict['networks'], indent=4, default_flow_style=False) + #print "interfaces", yaml.safe_dump(vm['interfaces'], indent=4, default_flow_style=False) + #print ">>>>>>>>>>>>>>>>>>>>>>>>>>>" + vm_id = myvim.new_vminstance(myVMDict['name'],myVMDict['description'],myVMDict.get('start', None), + myVMDict['imageRef'],myVMDict['flavorRef'],myVMDict['networks']) + #print "VIM vm instance id (server id) for scenario %s: %s" % (scenarioDict['name'],vm_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] + for net in myVMDict['networks']: + if "vim_id" in net: + for iface in vm['interfaces']: + if net["name"]==iface["internal_name"]: + iface["vim_id"]=net["vim_id"] + break + + logger.debug("start scenario 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) + instance_id = mydb.new_instance_scenario_as_a_whole(tenant_id,instance_scenario_name, instance_scenario_description, scenarioDict) + return mydb.get_instance_scenario(instance_id) + + except (db_base_Exception, vimconn.vimconnException) as e: + _, message = rollback(mydb, vims, rollbackList) + if isinstance(e, db_base_Exception): + error_text = "Exception at database" + else: + error_text = "Exception at VIM" + error_text += " {} {}. {}".format(type(e).__name__, str(e), message) + #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 + None is admited + ''' + if not cloud_config_preserve and not cloud_config: + return None + + new_cloud_config = {"key-pairs":[], "users":[]} + # key-pairs + if cloud_config_preserve: + for key in cloud_config_preserve.get("key-pairs", () ): + if key not in new_cloud_config["key-pairs"]: + new_cloud_config["key-pairs"].append(key) + if cloud_config: + for key in cloud_config.get("key-pairs", () ): + if key not in new_cloud_config["key-pairs"]: + new_cloud_config["key-pairs"].append(key) + if not new_cloud_config["key-pairs"]: + del new_cloud_config["key-pairs"] + + # users + if cloud_config: + new_cloud_config["users"] += cloud_config.get("users", () ) + if cloud_config_preserve: + new_cloud_config["users"] += cloud_config_preserve.get("users", () ) + index_to_delete = [] + users = new_cloud_config.get("users", []) + for index0 in range(0,len(users)): + if index0 in index_to_delete: + continue + for index1 in range(index0+1,len(users)): + if index1 in index_to_delete: + continue + if users[index0]["name"] == users[index1]["name"]: + index_to_delete.append(index1) + for key in users[index1].get("key-pairs",()): + if "key-pairs" not in users[index0]: + users[index0]["key-pairs"] = [key] + elif key not in users[index0]["key-pairs"]: + users[index0]["key-pairs"].append(key) + index_to_delete.sort(reverse=True) + for index in index_to_delete: + del users[index] + if not new_cloud_config["users"]: + del new_cloud_config["users"] + + #boot-data-drive + if cloud_config and cloud_config.get("boot-data-drive") != None: + new_cloud_config["boot-data-drive"] = cloud_config["boot-data-drive"] + if cloud_config_preserve and cloud_config_preserve.get("boot-data-drive") != None: + new_cloud_config["boot-data-drive"] = cloud_config_preserve["boot-data-drive"] + + # user-data + if cloud_config and cloud_config.get("user-data") != None: + new_cloud_config["user-data"] = cloud_config["user-data"] + if cloud_config_preserve and cloud_config_preserve.get("user-data") != None: + new_cloud_config["user-data"] = cloud_config_preserve["user-data"] + + # config files + new_cloud_config["config-files"] = [] + if cloud_config and cloud_config.get("config-files") != None: + new_cloud_config["config-files"] += cloud_config["config-files"] + if cloud_config_preserve: + for file in cloud_config_preserve.get("config-files", ()): + for index in range(0, len(new_cloud_config["config-files"])): + if new_cloud_config["config-files"][index]["dest"] == file["dest"]: + new_cloud_config["config-files"][index] = file + break + else: + new_cloud_config["config-files"].append(file) + if not new_cloud_config["config-files"]: + del new_cloud_config["config-files"] + return new_cloud_config + + +def get_vim_thread(tenant_id, datacenter_id_name=None, datacenter_tenant_id=None): + datacenter_id = None + datacenter_name = None + thread = None + if datacenter_id_name: + if utils.check_valid_uuid(datacenter_id_name): + datacenter_id = datacenter_id_name + else: + datacenter_name = datacenter_id_name + if datacenter_id: + thread = vim_threads["running"].get(datacenter_id + "." + tenant_id) + else: + for k, v in vim_threads["running"].items(): + datacenter_tenant = k.split(".") + if datacenter_tenant[0] == datacenter_id and datacenter_tenant[1] == tenant_id: + if thread: + raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict) + thread = v + elif not datacenter_id and datacenter_tenant[1] == tenant_id: + if thread.datacenter_name == datacenter_name: + if thread: + raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict) + thread = v + if not thread: + raise NfvoException("datacenter '{}' not found".format(str(datacenter_id_name)), HTTP_Not_Found) + return thread + + +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: + if utils.check_valid_uuid(datacenter_id_name): + datacenter_id = datacenter_id_name + else: + datacenter_name = datacenter_id_name + 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: + #print "nfvo.datacenter_action() error. Several datacenters found" + 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''' + for k, v in u.iteritems(): + if isinstance(v, collections.Mapping): + r = update(d.get(k, {}), v) + d[k] = r + else: + 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" + # 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"] - datacenter_id = None - datacenter_name=None + + #find main datacenter + myvims = {} + myvim_threads = {} + datacenter2tenant = {} datacenter = instance_dict.get("datacenter") - if datacenter: - if af.check_valid_uuid(datacenter): - datacenter_id = datacenter - else: - datacenter_name = datacenter - result, vims = get_vim(mydb, tenant_id, datacenter_id, datacenter_name, vim_tenant=None) - if result < 0: - print "start_scenario error. Datacenter not found" - return result, vims - elif result == 0: - return -HTTP_Not_Found, "datacenter '%s' not found" % str(datacenter) - elif result > 1: - print "start_scenario error. Several datacenters available, you must concrete" - return -HTTP_Bad_Request, "Several datacenters available, you must concrete" - myvim = vims.values()[0] + default_datacenter_id, vim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter) + myvims[default_datacenter_id] = vim + myvim_threads[default_datacenter_id] = get_vim_thread(tenant_id, default_datacenter_id) + datacenter2tenant[default_datacenter_id] = vim['config']['datacenter_tenant_id'] #myvim_tenant = myvim['tenant_id'] - datacenter_id = myvim['id'] - datacenter_name = myvim['name'] - datacenter_tenant_id = myvim['config']['datacenter_tenant_id'] +# default_datacenter_name = vim['name'] rollbackList=[] - print "Checking that the scenario exists and getting the scenario dictionary" - result, scenarioDict = mydb.get_scenario(scenario, tenant_id, datacenter_id) - if result < 0: - print "start_scenario error. Error interacting with NFVO DB" - return result, scenarioDict - elif result == 0: - print "start_scenario error. Scenario not found" - return result, scenarioDict + #print "Checking that the scenario exists and getting the scenario dictionary" + scenarioDict = mydb.get_scenario(scenario, tenant_id, default_datacenter_id) + + #logger.debug(">>>>>>> Dictionaries before merging") + #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_id'] = default_datacenter_id - scenarioDict['datacenter_tenant_id'] = datacenter_tenant_id - scenarioDict['datacenter_id'] = datacenter_id - auxNetDict = {} #Auxiliar dictionary. First key:'scenario' or sce_vnf uuid. Second Key: uuid of the net/sce_net. Value: vim_net_id auxNetDict['scenario'] = {} - - print "scenario dict: ",yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False) + + logger.debug("Creating instance from scenario-dict:\n%s", yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False)) #TODO remove instance_name = instance_dict["name"] instance_description = instance_dict.get("description") + instance_tasks={} try: - #0 check correct parameters - for descriptor_net in instance_dict.get("networks",{}).keys(): - found=False + # 0 check correct parameters + for net_name, net_instance_desc in instance_dict.get("networks",{}).iteritems(): + found = False for scenario_net in scenarioDict['nets']: - if descriptor_net == scenario_net["name"]: + if net_name == scenario_net["name"]: found = True break if not found: - raise NfvoException(-HTTP_Bad_Request, "Invalid scenario network name '%s' at instance:networks" % descriptor_net ) - for descriptor_vnf in instance_dict.get("vnfs",{}).keys(): + raise NfvoException("Invalid scenario network name '{}' at instance:networks".format(net_name), HTTP_Bad_Request) + if "sites" not in net_instance_desc: + net_instance_desc["sites"] = [ {} ] + site_without_datacenter_field = False + for site in net_instance_desc["sites"]: + if site.get("datacenter"): + if site["datacenter"] not in myvims: + #Add this datacenter to myvims + d, v = get_datacenter_by_name_uuid(mydb, tenant_id, site["datacenter"]) + myvims[d] = v + myvim_threads[d] = get_vim_thread(tenant_id, site["datacenter"]) + datacenter2tenant[d] = v['config']['datacenter_tenant_id'] + 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 + + for vnf_name, vnf_instance_desc in instance_dict.get("vnfs",{}).iteritems(): found=False for scenario_vnf in scenarioDict['vnfs']: - if descriptor_vnf == scenario_vnf['name']: + if vnf_name == scenario_vnf['name']: found = True break if not found: - raise NfvoException(-HTTP_Bad_Request, "Invalid vnf name '%s' at instance:vnfs" % descriptor_vnf ) - - #1. Creating new nets (sce_nets) in the VIM" + 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 + 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 + myvim_threads[d] = get_vim_thread(tenant_id, vnf_instance_desc["datacenter"]) + datacenter2tenant[d] = v['config']['datacenter_tenant_id'] + scenario_vnf["datacenter"] = vnf_instance_desc["datacenter"] + + #0.1 parse cloud-config parameters + cloud_config = unify_cloud_config(instance_dict.get("cloud-config"), scenarioDict.get("cloud-config")) + + #0.2 merge instance information into scenario + #Ideally, the operation should be as simple as: update(scenarioDict,instance_dict) + #However, this is not possible yet. + for net_name, net_instance_desc in instance_dict.get("networks",{}).iteritems(): + for scenario_net in scenarioDict['nets']: + if net_name == scenario_net["name"]: + if 'ip-profile' in net_instance_desc: + ipprofile = net_instance_desc['ip-profile'] + ipprofile['subnet_address'] = ipprofile.pop('subnet-address',None) + ipprofile['ip_version'] = ipprofile.pop('ip-version','IPv4') + ipprofile['gateway_address'] = ipprofile.pop('gateway-address',None) + ipprofile['dns_address'] = ipprofile.pop('dns-address',None) + if 'dhcp' in ipprofile: + ipprofile['dhcp_start_address'] = ipprofile['dhcp'].get('start-address',None) + ipprofile['dhcp_enabled'] = ipprofile['dhcp'].get('enabled',True) + ipprofile['dhcp_count'] = ipprofile['dhcp'].get('count',None) + del ipprofile['dhcp'] + if 'ip_profile' not in scenario_net: + scenario_net['ip_profile'] = ipprofile + else: + update(scenario_net['ip_profile'],ipprofile) + for interface in net_instance_desc.get('interfaces', () ): + if 'ip_address' in interface: + for vnf in scenarioDict['vnfs']: + if interface['vnf'] == vnf['name']: + for vnf_interface in vnf['interfaces']: + if interface['vnf_interface'] == vnf_interface['external_name']: + vnf_interface['ip_address']=interface['ip_address'] + + #logger.debug(">>>>>>>> Merged dictionary") + 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" for sce_net in scenarioDict['nets']: + sce_net["vim_id_sites"]={} descriptor_net = instance_dict.get("networks",{}).get(sce_net["name"],{}) - net_name = descriptor_net.get("name") - net_type = sce_net['type'] - lookfor_filter = {'admin_state_up': True, 'status': 'ACTIVE'} #'shared': True - if sce_net["external"]: - if not net_name: - net_name = sce_net["name"] - if "netmap-use" in descriptor_net or "netmap-create" in descriptor_net: - create_network = False - lookfor_network = False - if "netmap-use" in descriptor_net: + net_name = descriptor_net.get("vim-network-name") + auxNetDict['scenario'][sce_net['uuid']] = {} + + sites = descriptor_net.get("sites", [ {} ]) + for site in sites: + if site.get("datacenter"): + vim = myvims[ site["datacenter"] ] + datacenter_id = site["datacenter"] + myvim_thread = myvim_threads[ site["datacenter"] ] + else: + vim = myvims[ default_datacenter_id ] + datacenter_id = default_datacenter_id + myvim_thread = myvim_threads[default_datacenter_id] + net_type = sce_net['type'] + lookfor_filter = {'admin_state_up': True, 'status': 'ACTIVE'} #'shared': True + if sce_net["external"]: + if not net_name: + net_name = sce_net["name"] + if "netmap-use" in site or "netmap-create" in site: + create_network = False + lookfor_network = False + if "netmap-use" in site: + lookfor_network = True + if utils.check_valid_uuid(site["netmap-use"]): + filter_text = "scenario id '%s'" % site["netmap-use"] + lookfor_filter["id"] = site["netmap-use"] + else: + filter_text = "scenario name '%s'" % site["netmap-use"] + lookfor_filter["name"] = site["netmap-use"] + if "netmap-create" in site: + create_network = True + net_vim_name = net_name + if site["netmap-create"]: + net_vim_name = site["netmap-create"] + + elif sce_net['vim_id'] != None: + #there is a netmap at datacenter_nets database #TODO REVISE!!!! + create_network = False lookfor_network = True - if af.check_valid_uuid(descriptor_net["netmap-use"]): - filter_text = "scenario id '%s'" % descriptor_net["netmap-use"] - lookfor_filter["id"] = descriptor_net["netmap-use"] - else: - filter_text = "scenario name '%s'" % descriptor_net["netmap-use"] - lookfor_filter["name"] = descriptor_net["netmap-use"] - if "netmap-create" in descriptor_net: + lookfor_filter["id"] = sce_net['vim_id'] + filter_text = "vim_id '%s' datacenter_netmap name '%s'. Try to reload vims with datacenter-net-update" % (sce_net['vim_id'], sce_net["name"]) + #look for network at datacenter and return error + else: + #There is not a netmap, look at datacenter for a net with this name and create if not found create_network = True - net_vim_name = net_name - if descriptor_net["netmap-create"]: - net_vim_name= descriptor_net["netmap-create"] - - elif sce_net['vim_id'] != None: - #there is a netmap at datacenter_nets database - create_network = False - lookfor_network = True - lookfor_filter["id"] = sce_net['vim_id'] - filter_text = "vim_id '%s' datacenter_netmap name '%s'. Try to reload vims with datacenter-net-update" % (sce_net['vim_id'], sce_net["name"]) - #look for network at datacenter and return error + lookfor_network = True + lookfor_filter["name"] = sce_net["name"] + net_vim_name = sce_net["name"] + filter_text = "scenario name '%s'" % sce_net["name"] else: - #There is not a netmap, look at datacenter for a net with this name and create if not found + if not net_name: + net_name = "%s.%s" %(instance_name, sce_net["name"]) + net_name = net_name[:255] #limit length + net_vim_name = net_name create_network = True - lookfor_network = True - lookfor_filter["name"] = sce_net["name"] - net_vim_name = sce_net["name"] - filter_text = "scenario name '%s'" % sce_net["name"] - else: - if not net_name: - net_name = "%s.%s" %(instance_name, sce_net["name"]) - net_name = net_name[:255] #limit length - net_vim_name = net_name - create_network = True - lookfor_network = False - - if lookfor_network: - result, vim_nets = myvim.get_network_list(filter_dict=lookfor_filter) - if result < 0: - raise NfvoException(result, "Not possible to get vim network list " + vim_nets) - elif len(vim_nets) > 1: - raise NfvoException(-HTTP_Bad_Request, "More than one candidate VIM network found for " + filter_text ) - elif len(vim_nets) == 0: - if not create_network: - raise NfvoException(-HTTP_Bad_Request, "No candidate VIM network found for " + filter_text ) - else: - sce_net['vim_id'] = vim_nets[0]['id'] - auxNetDict['scenario'][sce_net['uuid']] = vim_nets[0]['id'] - create_network = False - if create_network: - #if network is not external - result, network_id = myvim.new_tenant_network(net_vim_name, net_type) - if result < 0: - raise NfvoException(result, "Error creating vim network " + network_id) - sce_net['vim_id'] = network_id - auxNetDict['scenario'][sce_net['uuid']] = network_id - rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':network_id}) - - #2. Creating new nets (vnf internal nets) in the VIM" + lookfor_network = False + + if lookfor_network: + vim_nets = vim.get_network_list(filter_dict=lookfor_filter) + if len(vim_nets) > 1: + raise NfvoException("More than one candidate VIM network found for " + filter_text, HTTP_Bad_Request ) + elif len(vim_nets) == 0: + if not create_network: + 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: + #if network is not external + task = new_task("new-net", (net_vim_name, net_type, sce_net.get('ip_profile',None))) + task_id = myvim_thread.insert_task(task) + instance_tasks[task_id] = 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" #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 = myvim_threads[ sce_vnf["datacenter"]] + else: + vim = myvims[ default_datacenter_id ] + datacenter_id = default_datacenter_id + myvim_thread = myvim_threads[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'] - result, network_id = myvim.new_tenant_network(net_name, net_type) - if result < 0: - raise NfvoException(result, "Error creating vim network " + network_id) - net['vim_id'] = network_id + task = new_task("new-net", (net_name, net_type, net.get('ip_profile',None))) + task_id = myvim_thread.insert_task(task) + instance_tasks[task_id] = 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}) - - print "auxNetDict:" - print yaml.safe_dump(auxNetDict, indent=4, default_flow_style=False) - - #3. Creating new vm instances in the VIM - #myvim.new_tenant_vminstance(self,vimURI,tenant_id,name,description,image_id,flavor_id,net_dict) + 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 + #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 = myvim_threads[ sce_vnf["datacenter"] ] + datacenter_id = sce_vnf["datacenter"] + else: + vim = myvims[ default_datacenter_id ] + myvim_thread = myvim_threads[ default_datacenter_id ] + datacenter_id = default_datacenter_id + sce_vnf["datacenter_id"] = datacenter_id i = 0 for vm in sce_vnf['vms']: i += 1 myVMDict = {} - myVMDict['name'] = "%s.%s.%d" % (instance_name,sce_vnf['name'],i) + myVMDict['name'] = "{}.{}.{}".format(instance_name,sce_vnf['name'],chr(96+i)) myVMDict['description'] = myVMDict['name'][0:99] # if not startvms: # myVMDict['start'] = "no" myVMDict['name'] = myVMDict['name'][0:255] #limit name length #create image at vim in case it not exist - res, image_dict = mydb.get_table_by_uuid_name("images", vm['image_id']) - if res<0: - raise NfvoException(result, "Error getting VIM image "+ image_dict) - res, image_id = create_or_use_image(mydb, vims, image_dict, [], True) - if res < 0: - raise NfvoException(result, "Error adding image to VIM " + image_dict) + 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) vm['vim_image_id'] = image_id - + #create flavor at vim in case it not exist - res, flavor_dict = mydb.get_table_by_uuid_name("flavors", vm['flavor_id']) - if res<0: - raise NfvoException(result, "Error getting VIM flavor "+ flavor_dict) + flavor_dict = mydb.get_table_by_uuid_name("flavors", vm['flavor_id']) if flavor_dict['extended']!=None: flavor_dict['extended']= yaml.load(flavor_dict['extended']) - res, flavor_id = create_or_use_flavor(mydb, vims, flavor_dict, [], True) - if res < 0: - raise NfvoException(result, "Error adding flavor to VIM" + flavor_dict) + flavor_id = create_or_use_flavor(mydb, {datacenter_id: vim}, flavor_dict, rollbackList, True) + + #Obtain information for additional disks + extended_flavor_dict = mydb.get_rows(FROM='datacenters_flavors', SELECT=('extended',), WHERE={'vim_id': flavor_id}) + if not extended_flavor_dict: + raise NfvoException("flavor '{}' not found".format(flavor_id), HTTP_Not_Found) + return + + #extended_flavor_dict_yaml = yaml.load(extended_flavor_dict[0]) + myVMDict['disks'] = None + extended_info = extended_flavor_dict[0]['extended'] + if extended_info != None: + extended_flavor_dict_yaml = yaml.load(extended_info) + if 'disks' in extended_flavor_dict_yaml: + myVMDict['disks'] = extended_flavor_dict_yaml['disks'] + vm['vim_flavor_id'] = flavor_id - myVMDict['imageRef'] = vm['vim_image_id'] myVMDict['flavorRef'] = vm['vim_flavor_id'] myVMDict['networks'] = [] -#TODO ALF. connect_mgmt_interfaces. Connect management interfaces if this is true + task_depends = {} + #TODO ALF. connect_mgmt_interfaces. Connect management interfaces if this is true for iface in vm['interfaces']: netDict = {} if iface['type']=="data": @@ -1656,39 +2199,51 @@ def create_instance(mydb, tenant_id, instance_dict): #print "iface", iface e_text = "Cannot determine the interface type PF or VF of VNF '%s' VM '%s' iface '%s'" %(sce_vnf['name'], vm['name'], iface['internal_name']) if flavor_dict.get('extended')==None: - raise NfvoException(-HTTP_Conflict, e_text + "After database migration some information is not available. \ - Try to delete and create the scenarios and VNFs again") + raise NfvoException(e_text + "After database migration some information is not available. \ + Try to delete and create the scenarios and VNFs again", HTTP_Conflict) else: - raise NfvoException(-HTTP_Internal_Server_Error, e_text) + raise NfvoException(e_text, HTTP_Internal_Server_Error) if netDict["use"]=="mgmt" or netDict["use"]=="bridge": netDict["type"]="virtual" if "vpci" in iface and iface["vpci"] is not None: netDict['vpci'] = iface['vpci'] if "mac" in iface and iface["mac"] is not None: netDict['mac_address'] = iface['mac'] + if "port-security" in iface and iface["port-security"] is not None: + netDict['port_security'] = iface['port-security'] + if "floating-ip" in iface and iface["floating-ip"] is not None: + netDict['floating_ip'] = iface['floating-ip'] netDict['name'] = iface['internal_name'] if iface['net_id'] is None: for vnf_iface in sce_vnf["interfaces"]: - print iface - print vnf_iface + #print iface + #print vnf_iface if vnf_iface['interface_id']==iface['uuid']: - netDict['net_id'] = auxNetDict['scenario'][ vnf_iface['sce_net_id'] ] + netDict['net_id'] = auxNetDict['scenario'][ vnf_iface['sce_net_id'] ][datacenter_id] break else: netDict['net_id'] = auxNetDict[ sce_vnf['uuid'] ][ iface['net_id'] ] + if 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 myVMDict['networks'].append(netDict) - print ">>>>>>>>>>>>>>>>>>>>>>>>>>>" - print myVMDict['name'] - print "networks", yaml.safe_dump(myVMDict['networks'], indent=4, default_flow_style=False) - print "interfaces", yaml.safe_dump(vm['interfaces'], indent=4, default_flow_style=False) - print ">>>>>>>>>>>>>>>>>>>>>>>>>>>" - result, vm_id = myvim.new_tenant_vminstance(myVMDict['name'],myVMDict['description'],myVMDict.get('start', None), - myVMDict['imageRef'],myVMDict['flavorRef'],myVMDict['networks']) - if result < 0: - raise NfvoException(result, "Error creating VIM instance" + vm_id) + #print ">>>>>>>>>>>>>>>>>>>>>>>>>>>" + #print myVMDict['name'] + #print "networks", yaml.safe_dump(myVMDict['networks'], indent=4, default_flow_style=False) + #print "interfaces", yaml.safe_dump(vm['interfaces'], indent=4, default_flow_style=False) + #print ">>>>>>>>>>>>>>>>>>>>>>>>>>>" + if vm.get("boot_data"): + cloud_config_vm = unify_cloud_config(vm["boot_data"], cloud_config) + else: + cloud_config_vm = cloud_config + 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) + vm_id = myvim_thread.insert_task(task) + instance_tasks[vm_id] = task + 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] @@ -1698,86 +2253,165 @@ def create_instance(mydb, tenant_id, instance_dict): if net["name"]==iface["internal_name"]: iface["vim_id"]=net["vim_id"] break - print "==================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) - result,c = mydb.new_instance_scenario_as_a_whole(tenant_id,instance_name, instance_description, scenarioDict) - if result <0: - raise NfvoException(result, c) - - return mydb.get_instance_scenario(c) - except NfvoException as e: - error_text = str(e) + ". " - _, message = rollback(mydb, vims, rollbackList) - error_text += message - print "create_instance: " + error_text - return e.error_code, error_text + 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) + # Update database with those ended 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) + if isinstance(e, db_base_Exception): + error_text = "database Exception" + elif isinstance(e, vimconn.vimconnException): + error_text = "VIM Exception" + else: + error_text = "Exception" + error_text += " {} {}. {}".format(type(e).__name__, str(e), message) + #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" - result, instanceDict = mydb.get_instance_scenario(instance_id, tenant_id) - if result < 0: - print "nfvo.delete_instance() error. Error getting info from database" - return result, instanceDict - elif result == 0: - print "delete_instance error. Instance not found" - return result, instanceDict - print yaml.safe_dump(instanceDict, indent=4, default_flow_style=False) + #print "Checking that the instance_id exists and getting the instance dictionary" + instanceDict = mydb.get_instance_scenario(instance_id, tenant_id) + #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" - result, vims = get_vim(mydb, tenant_id, instanceDict['datacenter_id']) - if result < 0: - print "nfvo.delete_instance() error. Datacenter not found" - return result, vims - elif result == 0: - print "!!!!!! nfvo.delete_instance() datacenter not found!!!!" - myvim = None - else: - myvim = vims.values()[0] - - - #1. Delete from Database + #print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id" - #result,c = mydb.delete_row('instance_scenarios', instance_id, nfvo_tenant) - result,c = mydb.delete_instance_scenario(instance_id, tenant_id) - if result<0: - return result, c + #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 = {} + myvim_threads = {} #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: + try: + myvim_thread = get_vim_thread(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: + 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] + myvim_thread = myvim_threads[datacenter_key] for vm in sce_vnf['vms']: - result, vm_id = myvim.delete_tenant_vminstance(vm['vim_vm_id']) - if result < 0: - error_msg+="\n Error: " + str(-result) + " VM id=" + vm['vim_vm_id'] - #if result != -HTTP_Not_Found: vm_fail_list.append(vm) - print "Error " + str(-result) + " deleting VM instance '" + vm['name'] + "', uuid '" + vm['uuid'] + "', VIM id '" + vm['vim_vm_id'] + "', from VNF_id '" + sce_vnf['vnf_id'] + "':" + vm_id - + 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: + task=None + if is_task_id(vm['vim_vm_id']): + task_id = vm['vim_vm_id'] + old_task = task_dict.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, depends={task_id: old_task}) + else: #ok + task = new_task("del-vm", old_task["result"]) + else: + task = new_task("del-vm", vm['vim_vm_id'], store=False) + 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", + vm['name'], vm['uuid'], vm['vim_vm_id'], sce_vnf['vnf_id']) + except vimconn.vimconnException as e: + 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 #net_fail_list=[] for net in instanceDict['nets']: - if net['external']: + if not net['created']: 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(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: + 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] + 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 - result, net_id = myvim.delete_tenant_network(net['vim_net_id']) - if result < 0: - error_msg += "\n Error: " + str(-result) + " NET id=" + net['vim_net_id'] - #if result == -HTTP_Not_Found: net_fail_list.append(net) - print "Error " + str(-result) + " deleting NET uuid '" + net['uuid'] + "', VIM id '" + net['vim_net_id'] + "':" + net_id - - if len(error_msg)>0: - return 1, 'instance ' + instance_id + ' deleted but some elements could not be deleted, or already deleted (error: 404) from VIM: ' + error_msg + try: + task = None + if is_task_id(net['vim_net_id']): + task_id = net['vim_net_id'] + old_task = task_dict.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'], store=False) + 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"]) + 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 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: - return 1, 'instance ' + instance_id + ' deleted' + return 'instance ' + message + ' deleted' + def refresh_instance(mydb, nfvo_tenant, instanceDict, datacenter=None, vim_tenant=None): '''Refreshes a scenario instance. It modifies instanceDict''' @@ -1786,127 +2420,175 @@ def refresh_instance(mydb, nfvo_tenant, instanceDict, datacenter=None, vim_tenan - error_msg ''' # Assumption: nfvo_tenant and instance_id were checked before entering into this function - print "nfvo.refresh_instance begins" + #print "nfvo.refresh_instance begins" #print json.dumps(instanceDict, indent=4) - - print "Getting the VIM URL and the VIM tenant_id" - result, vims = get_vim(mydb, nfvo_tenant, instanceDict['datacenter_id']) - if result < 0: - print "nfvo.refresh_instance() error. Datacenter not found" - return result, vims - elif result == 0: - return -HTTP_Not_Found, "datacenter '%s' not found" % str(instanceDict['datacenter_id']) - myvim = vims.values()[0] - - # 1. Getting the status of all VMs - vmDict = {} - netDict = {} + + #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']: - vmDict[vm['vim_vm_id']]=None - print "VACA vm", vm - - # 2. Getting the status of all nets - # TODO: update nets inside a vnf + 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']: - #if net['external']: - # continue #skip not created nets - netDict[net['vim_net_id']]=None - - # 3. Refresh the status of VMs and nets from VIM. IT updates vmDict and netDict - result, refresh_message = myvim.refresh_tenant_vms_and_nets(vmDict, netDict) - if result < 0: - return result, refresh_message - - # 4. Update the status of VMs in the instanceDict, while collects the VMs whose status changed - vms_updated = [] #List of VM instance uuids in openmano that were updated - vms_notupdated=[] + 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 = vmDict[vm_id].pop('interfaces', []) - #4.0 look if contain manamgement interface, and if not change status from ACTIVE:NoMgmtIP to ACTIVE + 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 vmDict[vm_id]['status'] == "ACTIVE:NoMgmtIP" and not has_mgmt_iface: - vmDict[vm_id]['status'] = "ACTIVE" - if vm['status'] != vmDict[vm_id]['status'] or vm.get('error_msg')!=vmDict[vm_id].get('error_msg') or vm.get('vim_info')!=vmDict[vm_id].get('vim_info'): - vm['status'] = vmDict[vm_id]['status'] - vm['error_msg'] = vmDict[vm_id].get('error_msg') - vm['vim_info'] = vmDict[vm_id].get('vim_info') - # 4.1. Update in openmano DB the VMs whose status changed - result2, _ = mydb.update_rows('instance_vms', UPDATE=vmDict[vm_id], WHERE={'uuid':vm["uuid"]}) - if result2<0: - vms_notupdated.append(vm["uuid"]) - elif result2>0: - vms_updated.append(vm["uuid"]) - # 4.2. Update in openmano DB the interface VMs + 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=None + network_id_list=[] for net in instanceDict['nets']: if net["vim_net_id"] == interface["vim_net_id"]: - network_id = net["uuid"] - break - if not network_id: + network_id_list.append(net["uuid"]) + if not network_id_list: continue del interface["vim_net_id"] - result2, _ = mydb.update_rows('instance_interfaces', UPDATE=interface, WHERE={'instance_vm_id':vm["uuid"], "instance_net_id":network_id}) - if result2<0: - print "nfvo.refresh_instance error with vm=%s, interface_net_id=%s" % (vm["uuid"], network_id) - # 5. Update the status of nets in the instanceDict, while collects the nets whose status changed - nets_updated = [] #List of net instance uuids in openmano that were updated - nets_notupdated=[] - # TODO: update nets inside a vnf + 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'] != netDict[net_id]['status'] or net.get('error_msg')!=netDict[net_id].get('error_msg') or net.get('vim_info')!=netDict[net_id].get('vim_info'): - net['status'] = netDict[net_id]['status'] - net['error_msg'] = netDict[net_id].get('error_msg') - net['vim_info'] = netDict[net_id].get('vim_info') + 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 - result2, _ = mydb.update_rows('instance_nets', UPDATE=netDict[net_id], WHERE={'uuid':net["uuid"]}) - if result2<0: - nets_notupdated.append(net["uuid"]) - elif result2>0: - nets_updated.append(net["uuid"]) + 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" - print "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)) + #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'] - error_msg=refresh_message if len(vms_notupdated)+len(nets_notupdated)>0: - if len(refresh_message)>0: - error_msg += "; " - error_msg += "VMs not updated: " + str(vms_notupdated) + "; nets not updated: " + str(nets_notupdated) + 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. ' + 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" - result, instanceDict = mydb.get_instance_scenario(instance_id, nfvo_tenant) - if result < 0: - print "nfvo.instance_action() error. Error getting info from database" - return result, instanceDict - elif result == 0: - print "instance_action error. Instance not found" - return -HTTP_Not_Found, "instance %s not found" % instance_id + #print "Checking that the instance_id exists and getting the instance dictionary" + instanceDict = mydb.get_instance_scenario(instance_id, nfvo_tenant) #print yaml.safe_dump(instanceDict, indent=4, default_flow_style=False) - print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id" - result, vims = get_vim(mydb, nfvo_tenant, instanceDict['datacenter_id']) - if result < 0: - print "nfvo.instance_action() error. Datacenter not found" - return result, vims - elif result == 0: - return -HTTP_Not_Found, "datacenter '%s' not found" % str(instanceDict['datacenter_id']) + #print "Checking that nfvo_tenant_id exists and getting the VIM URI 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] - + input_vnfs = action_dict.pop("vnfs", []) input_vms = action_dict.pop("vms", []) @@ -1920,47 +2602,64 @@ def instance_action(mydb,nfvo_tenant,instance_id, action_dict): if sce_vnf['uuid'] not in input_vnfs and sce_vnf['vnf_name'] not in input_vnfs and \ vm['uuid'] not in input_vms and vm['name'] not in input_vms: continue - result, data = myvim.action_tenant_vminstance(vm['vim_vm_id'], action_dict) - if result < 0: - vm_result[ vm['uuid'] ] = {"vim_result": -result, "name":vm['name'], "description": data} - vm_error+=1 - else: + try: + data = myvim.action_vminstance(vm['vim_vm_id'], action_dict) if "console" in action_dict: - if data["server"]=="127.0.0.1" or data["server"]=="localhost": + if not global_config["http_console_proxy"]: + vm_result[ vm['uuid'] ] = {"vim_result": 200, + "description": "{protocol}//{ip}:{port}/{suffix}".format( + protocol=data["protocol"], + ip = data["server"], + port = data["port"], + suffix = data["suffix"]), + "name":vm['name'] + } + vm_ok +=1 + elif data["server"]=="127.0.0.1" or data["server"]=="localhost": vm_result[ vm['uuid'] ] = {"vim_result": -HTTP_Unauthorized, "description": "this console is only reachable by local interface", "name":vm['name'] } vm_error+=1 - continue - #print "console data", data - r2, console_thread = create_or_use_console_proxy_thread(data["server"], data["port"]) - if r2<0: - vm_result[ vm['uuid'] ] = {"vim_result": -r2, "name":vm['name'], "description": console_thread} else: - vm_result[ vm['uuid'] ] = {"vim_result": result, - "description": "%s//%s:%d/%s" %(data["protocol"], console_thread.host, console_thread.port, data["suffix"]), - "name":vm['name'] - } - vm_ok +=1 + #print "console data", data + try: + console_thread = create_or_use_console_proxy_thread(data["server"], data["port"]) + vm_result[ vm['uuid'] ] = {"vim_result": 200, + "description": "{protocol}//{ip}:{port}/{suffix}".format( + protocol=data["protocol"], + ip = global_config["http_console_host"], + port = console_thread.port, + suffix = data["suffix"]), + "name":vm['name'] + } + vm_ok +=1 + except NfvoException as e: + vm_result[ vm['uuid'] ] = {"vim_result": e.http_code, "name":vm['name'], "description": str(e)} + vm_error+=1 + else: - vm_result[ vm['uuid'] ] = {"vim_result": result, "description": "ok", "name":vm['name']} + vm_result[ vm['uuid'] ] = {"vim_result": 200, "description": "ok", "name":vm['name']} vm_ok +=1 + except vimconn.vimconnException as e: + vm_result[ vm['uuid'] ] = {"vim_result": e.http_code, "name":vm['name'], "description": str(e)} + vm_error+=1 if vm_ok==0: #all goes wrong - return 1, vm_result + return vm_result else: - return 1, vm_result - + 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) if console_thread_key in global_config["console_thread"]: #global_config["console_thread"][console_thread_key].start_timeout() - return 1, global_config["console_thread"][console_thread_key] - + return global_config["console_thread"][console_thread_key] + for port in global_config["console_port_iterator"](): - print "create_or_use_console_proxy_thread() port:", port + #print "create_or_use_console_proxy_thread() port:", port if port in global_config["console_ports"]: continue try: @@ -1968,53 +2667,60 @@ def create_or_use_console_proxy_thread(console_server, console_port): clithread.start() global_config["console_thread"][console_thread_key] = clithread global_config["console_ports"][port] = console_thread_key - return 1, clithread + return clithread except cli.ConsoleProxyExceptionPortUsed as e: #port used, try with onoher continue except cli.ConsoleProxyException as e: - return -1, str(e) - return -1, "Not found any free 'http_console_ports'" + 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''' - result, _ = mydb.get_table(FROM='nfvo_tenants', SELECT=('uuid',), WHERE={'uuid': tenant_id}) - if result<=0: return False - return True + tenant = mydb.get_rows(FROM='nfvo_tenants', SELECT=('uuid',), WHERE={'uuid': tenant_id}) + if not tenant: + raise NfvoException("tenant '{}' not found".format(tenant_id), HTTP_Not_Found) + return + def new_tenant(mydb, tenant_dict): - result, tenant_id = mydb.new_row("nfvo_tenants", tenant_dict, None, add_uuid=True, log=True) - if result < 0: - return result, tenant_id - return 200,tenant_id + tenant_id = mydb.new_row("nfvo_tenants", tenant_dict, add_uuid=True) + return tenant_id + def delete_tenant(mydb, tenant): #get nfvo_tenant info - result,tenant_dict = mydb.get_table_by_uuid_name('nfvo_tenants', tenant, 'tenant') - if result < 0: - return result, tenant_dict - result, tenant_id = mydb.delete_row("nfvo_tenants", tenant_dict['uuid'], None) - if result < 0: - return result, tenant_id - return 200, tenant_dict['uuid'] + tenant_dict = mydb.get_table_by_uuid_name('nfvo_tenants', tenant, '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) - result, datacenter_id = mydb.new_row("datacenters", datacenter_descriptor, None, add_uuid=True, log=True) - if result < 0: - return result, datacenter_id - return 200,datacenter_id + #Check that datacenter-type is correct + datacenter_type = datacenter_descriptor.get("type", "openvim"); + module_info = None + try: + module = "vimconn_" + datacenter_type + module_info = imp.find_module(module) + except (IOError, ImportError): + if module_info and module_info[0]: + file.close(module_info[0]) + raise NfvoException("Incorrect datacenter type '{}'. Plugin '{}'.py not installed".format(datacenter_type, module), HTTP_Bad_Request) + + 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 - result, content = mydb.get_table_by_uuid_name('datacenters', datacenter_id_name) - if result < 0: - return result, content - #edit data - datacenter_id = content['uuid'] - where={'uuid': content['uuid']} + datacenter = mydb.get_table_by_uuid_name('datacenters', datacenter_id_name) + #edit data + datacenter_id = datacenter['uuid'] + where={'uuid': datacenter['uuid']} if "config" in datacenter_descriptor: if datacenter_descriptor['config']!=None: try: @@ -2024,66 +2730,43 @@ def edit_datacenter(mydb, datacenter_id_name, datacenter_descriptor): for k in new_config_dict: if new_config_dict[k]==None: to_delete.append(k) - - config_dict = yaml.load(content["config"]) + + config_dict = yaml.load(datacenter["config"]) config_dict.update(new_config_dict) #delete null fields for k in to_delete: del config_dict[k] - except Exception,e: - return -HTTP_Bad_Request, "Bad format at datacenter:config " + str(e) + except Exception as e: + raise NfvoException("Bad format at datacenter:config " + str(e), HTTP_Bad_Request) datacenter_descriptor["config"]= yaml.safe_dump(config_dict,default_flow_style=True,width=256) if len(config_dict)>0 else None - result, content = mydb.update_rows('datacenters', datacenter_descriptor, where) - if result < 0: - return result, datacenter_id - return 200, datacenter_id + mydb.update_rows('datacenters', datacenter_descriptor, where) + return datacenter_id + def delete_datacenter(mydb, datacenter): #get nfvo_tenant info - result,datacenter_dict = mydb.get_table_by_uuid_name('datacenters', datacenter, 'datacenter') - if result < 0: - return result, datacenter_dict + 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'] - result, datacenter_id = mydb.delete_row("datacenters", datacenter_dict['uuid'], None) - if result < 0: - return result, datacenter_id - return 200, datacenter_dict['uuid'] -def associate_datacenter_to_tenant(mydb, nfvo_tenant, datacenter, vim_tenant_id=None, vim_tenant_name=None, vim_username=None, vim_password=None): +def associate_datacenter_to_tenant(mydb, nfvo_tenant, datacenter, vim_tenant_id=None, vim_tenant_name=None, vim_username=None, vim_password=None, config=None): #get datacenter info - if af.check_valid_uuid(datacenter): - result, vims = get_vim(mydb, datacenter_id=datacenter) - else: - result, vims = get_vim(mydb, datacenter_name=datacenter) - if result < 0: - print "nfvo.associate_datacenter_to_tenant() error. Datacenter not found" - return result, vims - elif result == 0: - return -HTTP_Not_Found, "datacenter '%s' not found" % str(datacenter) - elif result>1: - print "nfvo.associate_datacenter_to_tenant() error. Several datacenters found" - #print result, vims - return -HTTP_Conflict, "More than one datacenters found, try to identify with uuid" - datacenter_id=vims.keys()[0] - myvim=vims[datacenter_id] - datacenter_name=myvim["name"] - - create_vim_tenant=True if vim_tenant_id==None and vim_tenant_name==None else False + datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, None, datacenter) + datacenter_name = myvim["name"] - #get nfvo_tenant info - result,tenant_dict = mydb.get_table_by_uuid_name('nfvo_tenants', nfvo_tenant) - if result < 0: - return result, tenant_dict + create_vim_tenant = True if not vim_tenant_id and not vim_tenant_name else False + + # get nfvo_tenant info + tenant_dict = mydb.get_table_by_uuid_name('nfvo_tenants', nfvo_tenant) if vim_tenant_name==None: vim_tenant_name=tenant_dict['name'] - + #check that this association does not exist before tenants_datacenter_dict={"nfvo_tenant_id":tenant_dict['uuid'], "datacenter_id":datacenter_id } - result,content = mydb.get_table(FROM='tenants_datacenters', WHERE=tenants_datacenter_dict) - if result>0: - return -HTTP_Conflict, "datacenter %s and tenant %s are already attached" %(datacenter_id, tenant_dict['uuid']) - elif result<0: - return result, content + tenants_datacenters = mydb.get_rows(FROM='tenants_datacenters', WHERE=tenants_datacenter_dict) + if len(tenants_datacenters)>0: + raise NfvoException("datacenter '{}' and tenant'{}' are already attached".format(datacenter_id, tenant_dict['uuid']), HTTP_Conflict) vim_tenant_id_exist_atdb=False if not create_vim_tenant: @@ -2093,10 +2776,8 @@ def associate_datacenter_to_tenant(mydb, nfvo_tenant, datacenter, vim_tenant_id= if vim_tenant_name!=None: where_["vim_tenant_name"] = vim_tenant_name #check if vim_tenant_id is already at database - result,datacenter_tenants_dict = mydb.get_table(FROM='datacenter_tenants', WHERE=where_) - if result < 0: - return result, datacenter_tenants_dict - elif result>=1: + datacenter_tenants_dict = mydb.get_rows(FROM='datacenter_tenants', WHERE=where_) + if len(datacenter_tenants_dict)>=1: datacenter_tenants_dict = datacenter_tenants_dict[0] vim_tenant_id_exist_atdb=True #TODO check if a field has changed and edit entry at datacenter_tenants at DB @@ -2105,117 +2786,99 @@ def associate_datacenter_to_tenant(mydb, nfvo_tenant, datacenter, vim_tenant_id= #insert at table datacenter_tenants else: #if vim_tenant_id==None: #create tenant at VIM if not provided - res, vim_tenant_id = myvim.new_tenant(vim_tenant_name, "created by openmano for datacenter "+datacenter_name) - if res < 0: - return res, "Not possible to create vim_tenant in VIM " + vim_tenant_id + try: + vim_tenant_id = myvim.new_tenant(vim_tenant_name, "created by openmano for datacenter "+datacenter_name) + except vimconn.vimconnException as e: + raise NfvoException("Not possible to create vim_tenant {} at VIM: {}".format(vim_tenant_id, str(e)), HTTP_Internal_Server_Error) datacenter_tenants_dict = {} datacenter_tenants_dict["created"]="true" - + #fill datacenter_tenants table if not vim_tenant_id_exist_atdb: - datacenter_tenants_dict["vim_tenant_id"] = vim_tenant_id + datacenter_tenants_dict["vim_tenant_id"] = vim_tenant_id datacenter_tenants_dict["vim_tenant_name"] = vim_tenant_name - datacenter_tenants_dict["user"] = vim_username - datacenter_tenants_dict["passwd"] = vim_password - datacenter_tenants_dict["datacenter_id"] = datacenter_id - res,id_ = mydb.new_row('datacenter_tenants', datacenter_tenants_dict, tenant_dict['uuid'], True, True) - if res<1: - return -HTTP_Bad_Request, "Not possible to add %s to database datacenter_tenants table %s " %(vim_tenant_id, id_) + datacenter_tenants_dict["user"] = vim_username + datacenter_tenants_dict["passwd"] = vim_password + datacenter_tenants_dict["datacenter_id"] = datacenter_id + if config: + datacenter_tenants_dict["config"] = yaml.safe_dump(config, default_flow_style=True, width=256) + id_ = mydb.new_row('datacenter_tenants', datacenter_tenants_dict, add_uuid=True) datacenter_tenants_dict["uuid"] = id_ - + #fill tenants_datacenters table tenants_datacenter_dict["datacenter_tenant_id"]=datacenter_tenants_dict["uuid"] - res,id_ = mydb.new_row('tenants_datacenters', tenants_datacenter_dict, tenant_dict['uuid'], False, True) - if res<1: - return -HTTP_Bad_Request, "Not possible to create an entry at database table datacenter_tenants: " + id_ - return 200, datacenter_id + mydb.new_row('tenants_datacenters', tenants_datacenter_dict) + # 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, task_lock, thread_name, datacenter_name, db=db, db_lock=db_lock) + new_thread.start() + thread_id = datacenter_id + "." + tenant_dict['uuid'] + vim_threads["running"][thread_id] = new_thread + return datacenter_id + def deassociate_datacenter_to_tenant(mydb, tenant_id, datacenter, vim_tenant_id=None): #get datacenter info - if af.check_valid_uuid(datacenter): - result, vims = get_vim(mydb, datacenter_id=datacenter) - else: - result, vims = get_vim(mydb, datacenter_name=datacenter) - if result < 0: - print "nfvo.deassociate_datacenter_to_tenant() error. Datacenter not found" - return result, vims - elif result == 0: - return -HTTP_Not_Found, "datacenter '%s' not found" % str(datacenter) - elif result>1: - print "nfvo.deassociate_datacenter_to_tenant() error. Several datacenters found" - return -HTTP_Conflict, "More than one datacenters found, try to identify with uuid" - 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": tenant_uuid = None else: - result,tenant_dict = mydb.get_table_by_uuid_name('nfvo_tenants', tenant_id) - if result < 0: - return result, tenant_dict + tenant_dict = mydb.get_table_by_uuid_name('nfvo_tenants', tenant_id) tenant_uuid = tenant_dict['uuid'] #check that this association exist before tenants_datacenter_dict={"datacenter_id":datacenter_id } if tenant_uuid: tenants_datacenter_dict["nfvo_tenant_id"] = tenant_uuid - result,tenant_datacenter_list = mydb.get_table(FROM='tenants_datacenters', WHERE=tenants_datacenter_dict) - if result==0 and tenant_uuid: - return -HTTP_Not_Found, "datacenter %s and tenant %s are not attached" %(datacenter_id, tenant_dict['uuid']) - elif result<0: - return result, tenant_datacenter_list + tenant_datacenter_list = mydb.get_rows(FROM='tenants_datacenters', WHERE=tenants_datacenter_dict) + if len(tenant_datacenter_list)==0 and tenant_uuid: + raise NfvoException("datacenter '{}' and tenant '{}' are not attached".format(datacenter_id, tenant_dict['uuid']), HTTP_Not_Found) #delete this association - result,data = mydb.delete_row_by_dict(FROM='tenants_datacenters', WHERE=tenants_datacenter_dict) - if result<0: - return result,data + mydb.delete_row(FROM='tenants_datacenters', WHERE=tenants_datacenter_dict) #get vim_tenant info and deletes warning='' for tenant_datacenter_item in tenant_datacenter_list: - result,vim_tenant_dict = mydb.get_table_by_uuid_name('datacenter_tenants', tenant_datacenter_item['datacenter_tenant_id']) - if result > 0: - #try to delete vim:tenant - result,data = mydb.delete_row('datacenter_tenants', tenant_datacenter_item['datacenter_tenant_id'], tenant_uuid) - if result<0: - pass #the error will be caused because dependencies, vim_tenant can not be deleted - elif vim_tenant_dict['created']=='true': + vim_tenant_dict = mydb.get_table_by_uuid_name('datacenter_tenants', tenant_datacenter_item['datacenter_tenant_id']) + #try to delete vim:tenant + try: + mydb.delete_row_by_id('datacenter_tenants', tenant_datacenter_item['datacenter_tenant_id']) + if vim_tenant_dict['created']=='true': #delete tenant at VIM if created by NFVO - res, vim_tenant_id = myvim.delete_tenant(vim_tenant_dict['vim_tenant_id']) - if res < 0: - warning = " Not possible to delete vim_tenant id %s name %s from VIM: %s " % (vim_tenant_dict['vim_tenant_id'], vim_tenant_dict['vim_tenant_name'], vim_tenant_id) - print res, warning + try: + myvim.delete_tenant(vim_tenant_dict['vim_tenant_id']) + except vimconn.vimconnException as e: + warning = "Not possible to delete vim_tenant_id {} from VIM: {} ".format(vim_tenant_dict['vim_tenant_id'], str(e)) + logger.warn(warning) + 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 = vim_threads["running"][thread_id] + thread.insert_task(new_task("exit", None, store=False)) + vim_threads["deleting"][thread_id] = thread + return "datacenter {} detached. {}".format(datacenter_id, warning) - return 200, "datacenter %s detached.%s" %(datacenter_id, warning) def datacenter_action(mydb, tenant_id, datacenter, action_dict): #DEPRECATED - #get datacenter info - if af.check_valid_uuid(datacenter): - result, vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_id=datacenter) - else: - result, vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_name=datacenter) - if result < 0: - print "nfvo.datacenter_action() error. Datacenter not found" - return result, vims - elif result == 0: - return -HTTP_Not_Found, "datacenter '%s' not found" % str(datacenter) - elif result>1: - print "nfvo.datacenter_action() error. Several datacenters found" - return -HTTP_Conflict, "More than one datacenters found, try to identify with uuid" - datacenter_id=vims.keys()[0] - myvim=vims[datacenter_id] + #get datacenter info + datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter) if 'net-update' in action_dict: - result, content = myvim.get_network_list(filter_dict={'shared': True, 'admin_state_up': True, 'status': 'ACTIVE'}) - print content - if result < 0: - print " Not possible to get_network_list from VIM: %s " % (content) - return -HTTP_Internal_Server_Error, content + try: + nets = myvim.get_network_list(filter_dict={'shared': True, 'admin_state_up': True, 'status': 'ACTIVE'}) + #print content + except vimconn.vimconnException as e: + #logger.error("nfvo.datacenter_action() Not possible to get_network_list from VIM: %s ", str(e)) + raise NfvoException(str(e), HTTP_Internal_Server_Error) #update nets Change from VIM format to NFVO format net_list=[] - for net in content: + for net in nets: net_nfvo={'datacenter_id': datacenter_id} net_nfvo['name'] = net['name'] #net_nfvo['description']= net['name'] @@ -2224,65 +2887,39 @@ def datacenter_action(mydb, tenant_id, datacenter, action_dict): net_nfvo['shared'] = net['shared'] net_nfvo['multipoint'] = False if net['type']=='ptp' else True net_list.append(net_nfvo) - result, content = mydb.update_datacenter_nets(datacenter_id, net_list) - if result < 0: - return -HTTP_Internal_Server_Error, content - print "Inserted %d nets, deleted %d old nets" % (result, content) - - return 200, result + inserted, deleted = mydb.update_datacenter_nets(datacenter_id, net_list) + logger.info("Inserted %d nets, deleted %d old nets", inserted, deleted) + return inserted elif 'net-edit' in action_dict: net = action_dict['net-edit'].pop('net') - what = 'vim_net_id' if af.check_valid_uuid(net) else 'name' - result, content = mydb.update_rows('datacenter_nets', action_dict['net-edit'], + what = 'vim_net_id' if utils.check_valid_uuid(net) else 'name' + result = mydb.update_rows('datacenter_nets', action_dict['net-edit'], WHERE={'datacenter_id':datacenter_id, what: net}) - return result, content + return result elif 'net-delete' in action_dict: net = action_dict['net-deelte'].get('net') - what = 'vim_net_id' if af.check_valid_uuid(net) else 'name' - result, content = mydb.delete_row_by_dict(FROM='datacenter_nets', + what = 'vim_net_id' if utils.check_valid_uuid(net) else 'name' + result = mydb.delete_row(FROM='datacenter_nets', WHERE={'datacenter_id':datacenter_id, what: net}) - return result, content + return result else: - return -HTTP_Bad_Request, "Unknown action " + str(action_dict) + raise NfvoException("Unknown action " + str(action_dict), HTTP_Bad_Request) + def datacenter_edit_netmap(mydb, tenant_id, datacenter, netmap, action_dict): #get datacenter info - if af.check_valid_uuid(datacenter): - result, vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_id=datacenter) - else: - result, vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_name=datacenter) - if result < 0: - print "nfvo.datacenter_action() error. Datacenter not found" - return result, vims - elif result == 0: - return -HTTP_Not_Found, "datacenter '%s' not found" % str(datacenter) - elif result>1: - print "nfvo.datacenter_action() error. Several datacenters found" - return -HTTP_Conflict, "More than one datacenters found, try to identify with uuid" - datacenter_id=vims.keys()[0] - - what = 'uuid' if af.check_valid_uuid(netmap) else 'name' - result, content = mydb.update_rows('datacenter_nets', action_dict['netmap'], + 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'], WHERE={'datacenter_id':datacenter_id, what: netmap}) - return result, content + return result + def datacenter_new_netmap(mydb, tenant_id, datacenter, action_dict=None): #get datacenter info - if af.check_valid_uuid(datacenter): - result, vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_id=datacenter) - else: - result, vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_name=datacenter) - if result < 0: - print "nfvo.datacenter_new_netmap() error. Datacenter not found" - return result, vims - elif result == 0: - return -HTTP_Not_Found, "datacenter '%s' not found" % str(datacenter) - elif result>1: - print "nfvo.datacenter_new_netmap() error. Several datacenters found" - return -HTTP_Conflict, "More than one datacenters found, try to identify with uuid" - 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"] @@ -2292,18 +2929,18 @@ def datacenter_new_netmap(mydb, tenant_id, datacenter, action_dict=None): filter_dict["name"] = action_dict['vim_name'] else: filter_dict["shared"] = True - - result, content = myvim.get_network_list(filter_dict=filter_dict) - print result, content - if result <0: - print " Not possible to get_network_list from VIM: %s " % (content) - return -HTTP_Internal_Server_Error, content - elif len(content)>1 and action_dict: - return -HTTP_Conflict, "more than two networks found, specify with vim_id" - elif len(content)==0: # and action_dict: - return -HTTP_Not_Found, "Not found a network at VIM with " + str(filter_dict) + + try: + vim_nets = myvim.get_network_list(filter_dict=filter_dict) + except vimconn.vimconnException as e: + #logger.error("nfvo.datacenter_new_netmap() Not possible to get_network_list from VIM: %s ", str(e)) + raise NfvoException(str(e), HTTP_Internal_Server_Error) + if len(vim_nets)>1 and action_dict: + raise NfvoException("more than two networks found, specify with vim_id", HTTP_Conflict) + elif len(vim_nets)==0: # and action_dict: + raise NfvoException("Not found a network at VIM with " + str(filter_dict), HTTP_Not_Found) net_list=[] - for net in content: + for net in vim_nets: net_nfvo={'datacenter_id': datacenter_id} if action_dict and "name" in action_dict: net_nfvo['name'] = action_dict['name'] @@ -2314,136 +2951,106 @@ def datacenter_new_netmap(mydb, tenant_id, datacenter, action_dict=None): net_nfvo['type'] = net['type'][0:6] #change from ('ptp','data','bridge_data','bridge_man') to ('bridge','data','ptp') net_nfvo['shared'] = net['shared'] net_nfvo['multipoint'] = False if net['type']=='ptp' else True - result, content = mydb.new_row("datacenter_nets", net_nfvo, add_uuid=True) - if action_dict and result < 0 : - return result, content - if result < 0: - net_nfvo["status"] = "FAIL: " + content - else: + try: + net_id = mydb.new_row("datacenter_nets", net_nfvo, add_uuid=True) net_nfvo["status"] = "OK" - net_nfvo["uuid"] = content - net_list.append(net_nfvo) - return 200, net_list + net_nfvo["uuid"] = net_id + except db_base_Exception as e: + if action_dict: + raise + else: + net_nfvo["status"] = "FAIL: " + str(e) + net_list.append(net_nfvo) + return net_list + def vim_action_get(mydb, tenant_id, datacenter, item, name): #get datacenter info - if af.check_valid_uuid(datacenter): - result, vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_id=datacenter) - else: - result, vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_name=datacenter) - if result < 0: - print "nfvo.datacenter_action() error. Datacenter not found" - return result, vims - elif result == 0: - return -HTTP_Not_Found, "datacenter '%s' not found" % str(datacenter) - elif result>1: - print "nfvo.datacenter_action() error. Several datacenters found" - return -HTTP_Conflict, "More than one datacenters found, try to identify with uuid" - 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 af.check_valid_uuid(name): + if utils.check_valid_uuid(name): filter_dict["id"] = name else: filter_dict["name"] = name - if item=="networks": - #filter_dict['tenant_id'] = myvim['tenant_id'] - result, content = myvim.get_network_list(filter_dict=filter_dict) - elif item=="tenants": - result, content = myvim.get_tenant_list(filter_dict=filter_dict) - else: - return -HTTP_Method_Not_Allowed, item + "?" - if result < 0: - print "vim_action Not possible to get_%s_list from VIM: %s " % (item, content) - return -HTTP_Internal_Server_Error, content - print "vim_action response ", content #update nets Change from VIM format to NFVO format - if name and len(content)==1: - return 200, {item[:-1]: content[0]} - elif name and len(content)==0: - return -HTTP_Not_Found, "No %s found with %s" % (item[:-1], " and ".join(map(lambda x: str(x[0])+": "+str(x[1]), filter_dict.iteritems()))) - else: - return 200, {item: content} - + try: + if item=="networks": + #filter_dict['tenant_id'] = myvim['tenant_id'] + content = myvim.get_network_list(filter_dict=filter_dict) + elif item=="tenants": + content = myvim.get_tenant_list(filter_dict=filter_dict) + elif item == "images": + content = myvim.get_image_list(filter_dict=filter_dict) + else: + raise NfvoException(item + "?", HTTP_Method_Not_Allowed) + logger.debug("vim_action response %s", content) #update nets Change from VIM format to NFVO format + if name and len(content)==1: + return {item[:-1]: content[0]} + elif name and len(content)==0: + raise NfvoException("No {} found with ".format(item[:-1]) + " and ".join(map(lambda x: str(x[0])+": "+str(x[1]), filter_dict.iteritems())), + datacenter) + else: + return {item: content} + except vimconn.vimconnException as e: + 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": tenant_id=None - if af.check_valid_uuid(datacenter): - result, vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_id=datacenter) - else: - result, vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_name=datacenter) - if result < 0: - print "nfvo.datacenter_action() error. Datacenter not found" - return result, vims - elif result == 0: - return -HTTP_Not_Found, "datacenter '%s' not found" % str(datacenter) - elif result>1: - print "nfvo.datacenter_action() error. Several datacenters found" - return -HTTP_Conflict, "More than one datacenters found, try to identify with uuid" - datacenter_id=vims.keys()[0] - myvim=vims[datacenter_id] + datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter) #get uuid name - result, content = vim_action_get(mydb, tenant_id, datacenter, item, name) - print content - if result < 0: - return result, content + content = vim_action_get(mydb, tenant_id, datacenter, item, name) + logger.debug("vim_action_delete vim response: " + str(content)) items = content.values()[0] if type(items)==list and len(items)==0: - return -HTTP_Not_Found, "Not found " + item + raise NfvoException("Not found " + item, HTTP_Not_Found) elif type(items)==list and len(items)>1: - return -HTTP_Not_Found, "Found more than one %s with this name. Use uuid." % item + raise NfvoException("Found more than one {} with this name. Use uuid.".format(item), HTTP_Not_Found) else: # it is a dict item_id = items["id"] item_name = str(items.get("name")) - - if item=="networks": - result, content = myvim.delete_tenant_network(item_id) - elif item=="tenants": - result, content = myvim.delete_tenant(item_id) - else: - return -HTTP_Method_Not_Allowed, item + "?" - if result < 0: - print "vim_action Not possible to delete %s %s from VIM: %s " % (item, name, content) - return result, content - return 200, "%s %s %s deleted" %( item[:-1], item_id,item_name) - + + try: + if item=="networks": + content = myvim.delete_network(item_id) + elif item=="tenants": + content = myvim.delete_tenant(item_id) + elif item == "images": + content = myvim.delete_image(item_id) + else: + raise NfvoException(item + "?", HTTP_Method_Not_Allowed) + except vimconn.vimconnException as e: + #logger.error( "vim_action Not possible to delete_{} {}from VIM: {} ".format(item, name, str(e))) + raise NfvoException("Not possible to delete_{} {} from VIM: {}".format(item, name, str(e)), e.http_code) + + return "{} {} {} deleted".format(item[:-1], item_id,item_name) + + 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 + datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter) + try: + if item=="networks": + net = descriptor["network"] + net_name = net.pop("name") + net_type = net.pop("type", "bridge") + net_public = net.pop("shared", False) + net_ipprofile = net.pop("ip_profile", None) + 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")) + else: + raise NfvoException(item + "?", HTTP_Method_Not_Allowed) + except vimconn.vimconnException as e: + raise NfvoException("Not possible to create {} at VIM: {}".format(item, str(e)), e.http_code) - if af.check_valid_uuid(datacenter): - result, vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_id=datacenter) - else: - result, vims = get_vim(mydb, nfvo_tenant=tenant_id, datacenter_name=datacenter) - if result < 0: - print "nfvo.datacenter_action() error. Datacenter not found" - return result, vims - elif result == 0: - return -HTTP_Not_Found, "datacenter '%s' not found" % str(datacenter) - elif result>1: - print "nfvo.datacenter_action() error. Several datacenters found" - return -HTTP_Conflict, "More than one datacenters found, try to identify with uuid" - datacenter_id=vims.keys()[0] - myvim=vims[datacenter_id] - - if item=="networks": - net = descriptor["network"] - net_name = net.pop("name") - net_type = net.pop("type", "bridge") - net_public=net.pop("shared", False) - result, content = myvim.new_tenant_network(net_name, net_type, net_public, **net) - elif item=="tenants": - tenant = descriptor["tenant"] - result, content = myvim.new_tenant(tenant["name"], tenant.get("description")) - else: - return -HTTP_Method_Not_Allowed, item + "?" - if result < 0: - print "vim_action Not possible to create %s at VIM: %s " % (item, content) - return result, content return vim_action_get(mydb, tenant_id, datacenter, item, content) - - \ No newline at end of file