X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=osm_ro%2Fnfvo.py;h=f3fb7b752aeb10ee84272c37333567b16126989d;hb=refs%2Fchanges%2F30%2F5530%2F1;hp=af84204fd4a7a384dc0bdb28fd462578b0861cc2;hpb=f1ba57e5806479a5a38d5c4f48da8799e78e400a;p=osm%2FRO.git diff --git a/osm_ro/nfvo.py b/osm_ro/nfvo.py index af84204f..f3fb7b75 100644 --- a/osm_ro/nfvo.py +++ b/osm_ro/nfvo.py @@ -43,13 +43,13 @@ from db_base import db_base_Exception import nfvo_db from threading import Lock -from time import time +import time as t from lib_osm_openvim import ovim as ovim_module from lib_osm_openvim.ovim import ovimException +from Crypto.PublicKey import RSA import osm_im.vnfd as vnfd_catalog import osm_im.nsd as nsd_catalog - from pyangbind.lib.serialise import pybindJSONDecoder from itertools import chain @@ -67,10 +67,9 @@ vim_threads = {"running":{}, "deleting": {}, "names": []} # threads running vim_persistent_info = {} logger = logging.getLogger('openmano.nfvo') task_lock = Lock() -global_instance_tasks = {} last_task_id = 0.0 -db=None -db_lock=Lock() +db = None +db_lock = Lock() class NfvoException(Exception): def __init__(self, message, http_code): @@ -80,14 +79,16 @@ class NfvoException(Exception): def get_task_id(): global last_task_id - task_id = time() + task_id = t.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) + return "ACTION-{:.6f}".format(task_id) + # return (t.strftime("%Y%m%dT%H%M%S.{}%Z", t.localtime(task_id))).format(int((task_id % 1)*1e6)) def new_task(name, params, depends=None): + """Deprected!!!""" task_id = get_task_id() task = {"status": "enqueued", "id": task_id, "name": name, "params": params} if depends: @@ -96,7 +97,7 @@ def new_task(name, params, depends=None): def is_task_id(id): - return True if id[:5] == "TASK." else False + return True if id[:5] == "TASK-" else False def get_non_used_vim_name(datacenter_name, datacenter_id, tenant_name, tenant_id): @@ -208,7 +209,7 @@ def stop_service(): if ovim: ovim.stop_service() for thread_id,thread in vim_threads["running"].items(): - thread.insert_task(new_task("exit", None)) + thread.insert_task("exit") vim_threads["deleting"][thread_id] = thread vim_threads["running"] = {} if global_config and global_config.get("console_thread"): @@ -347,7 +348,7 @@ def rollback(mydb, vims, rollback_list): 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"]}) + mydb.delete_row(FROM="datacenters_images", WHERE={"datacenter_vim_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"]}) @@ -514,9 +515,11 @@ def create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vi rollback_list.append({"where":"mano", "what":"image","uuid":image_mano_id}) #create image at every vim for vim_id,vim in vims.iteritems(): + datacenter_vim_id = vim["config"]["datacenter_tenant_id"] image_created="false" #look at database - image_db = mydb.get_rows(FROM="datacenters_images", WHERE={'datacenter_id':vim_id, 'image_id':image_mano_id}) + image_db = mydb.get_rows(FROM="datacenters_images", + WHERE={'datacenter_vim_id': datacenter_vim_id, 'image_id': image_mano_id}) #look at VIM if this image exist try: if image_dict['location'] is not None: @@ -565,10 +568,13 @@ def create_or_use_image(mydb, vims, image_dict, rollback_list, only_create_at_vi #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}) + mydb.new_row('datacenters_images', {'datacenter_vim_id': datacenter_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}) + mydb.update_rows('datacenters_images', UPDATE={'vim_id':image_vim_id}, WHERE={'datacenter_vim_id':vim_id, 'image_id':image_mano_id}) return image_vim_id if only_create_at_vim else image_mano_id @@ -627,9 +633,11 @@ def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_ del flavor_dict['uuid'] flavor_vim_id=None for vim_id,vim in vims.items(): + datacenter_vim_id = vim["config"]["datacenter_tenant_id"] flavor_created="false" #look at database - flavor_db = mydb.get_rows(FROM="datacenters_flavors", WHERE={'datacenter_id':vim_id, 'flavor_id':flavor_mano_id}) + flavor_db = mydb.get_rows(FROM="datacenters_flavors", + WHERE={'datacenter_vim_id': datacenter_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: @@ -719,11 +727,12 @@ def create_or_use_flavor(mydb, vims, flavor_dict, rollback_list, only_create_at_ 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}) + {'datacenter_vim_id': datacenter_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}) + mydb.update_rows('datacenters_flavors', UPDATE={'vim_id':flavor_vim_id}, + WHERE={'datacenter_vim_id': datacenter_vim_id, 'flavor_id': flavor_mano_id}) return flavor_vim_id if only_create_at_vim else flavor_mano_id @@ -777,7 +786,10 @@ def new_vnfd_v3(mydb, tenant_id, vnf_descriptor): """ try: myvnfd = vnfd_catalog.vnfd() - pybindJSONDecoder.load_ietf_json(vnf_descriptor, None, None, obj=myvnfd) + try: + pybindJSONDecoder.load_ietf_json(vnf_descriptor, None, None, obj=myvnfd) + except Exception as e: + raise NfvoException("Error. Invalid VNF descriptor format " + str(e), HTTP_Bad_Request) db_vnfs = [] db_nets = [] db_vms = [] @@ -787,8 +799,8 @@ def new_vnfd_v3(mydb, tenant_id, vnf_descriptor): db_flavors = [] uuid_list = [] vnfd_uuid_list = [] - for rift_vnfd in myvnfd.vnfd_catalog.vnfd.itervalues(): - vnfd = rift_vnfd.get() + for vnfd_yang in myvnfd.vnfd_catalog.vnfd.itervalues(): + vnfd = vnfd_yang.get() # table vnf vnf_uuid = str(uuid4()) @@ -892,22 +904,22 @@ def new_vnfd_v3(mydb, tenant_id, vnf_descriptor): if vdu["guest-epa"].get("numa-node-policy"): # TODO or dedicated_int: numa_node_policy = vdu["guest-epa"].get("numa-node-policy") if numa_node_policy.get("node"): - numa_node = numa_node_policy.node[0] + numa_node = numa_node_policy["node"]['0'] if numa_node.get("num-cores"): numa["cores"] = numa_node["num-cores"] epa_vcpu_set = True if numa_node.get("paired-threads"): if numa_node["paired-threads"].get("num-paired-threads"): - numa["paired-threads"] = numa_node["paired-threads"]["num-paired-threads"] + numa["paired-threads"] = int(numa_node["paired-threads"]["num-paired-threads"]) epa_vcpu_set = True - if len(numa_node["paired-threads"].get("paired-thread-ids")) > 0: + if len(numa_node["paired-threads"].get("paired-thread-ids")): numa["paired-threads-id"] = [] - for pair in numa_node["paired-threads"]["paired-thread-ids"].itervalues: + for pair in numa_node["paired-threads"]["paired-thread-ids"].itervalues(): numa["paired-threads-id"].append( (str(pair["thread-a"]), str(pair["thread-b"])) ) if numa_node.get("num-threads"): - numa["threads"] = numa_node["num-threads"] + numa["threads"] = int(numa_node["num-threads"]) epa_vcpu_set = True if numa_node.get("memory-mb"): numa["memory"] = max(int(numa_node["memory-mb"] / 1024), 1) @@ -946,10 +958,10 @@ def new_vnfd_v3(mydb, tenant_id, vnf_descriptor): # cloud-init boot_data = {} if vdu.get("cloud-init"): - boot_data["user-data"] = vdu["cloud-init"] + boot_data["user-data"] = str(vdu["cloud-init"]) elif vdu.get("cloud-init-file"): # TODO Where this file content is present??? - # boot_data["user-data"] = rift_vnfd.files[vdu["cloud-init-file"]] + # boot_data["user-data"] = vnfd_yang.files[vdu["cloud-init-file"]] boot_data["user-data"] = str(vdu["cloud-init-file"]) if vdu.get("supplemental-boot-data"): @@ -964,7 +976,7 @@ def new_vnfd_v3(mydb, tenant_id, vnf_descriptor): "content": cfg_source}) boot_data['config-files'] = om_cfgfile_list if boot_data: - db_vm["boot_data"] = boot_data + db_vm["boot_data"] = yaml.safe_dump(boot_data, default_flow_style=True, width=256) db_vms.append(db_vm) db_vms_index += 1 @@ -972,7 +984,8 @@ def new_vnfd_v3(mydb, tenant_id, vnf_descriptor): # table interfaces (internal/external interfaces) cp_name2iface_uuid = {} cp_name2vm_uuid = {} - for iface in chain(vdu.get("internal-interface").itervalues(), vdu.get("external-interface").itervalues()): + # for iface in chain(vdu.get("internal-interface").itervalues(), vdu.get("external-interface").itervalues()): + for iface in vdu.get("interface").itervalues(): iface_uuid = str(uuid4()) uuid_list.append(iface_uuid) db_interface = { @@ -996,11 +1009,15 @@ def new_vnfd_v3(mydb, tenant_id, vnf_descriptor): db_interface["type"] = "data" db_interface["model"] = get_str(iface.get("virtual-interface"), "type", 12) else: - raise ValueError("Interface type {} not supported".format(iface.get("virtual-interface").get("type"))) + raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{}]':'vdu[{}]':'interface':'virtual" + "-interface':'type':'{}'. Interface type is not supported".format( + str(vnfd["id"])[:255], str(vdu["id"])[:255], + iface.get("virtual-interface").get("type")), + HTTP_Bad_Request) - if iface.get("vnfd-connection-point-ref"): + if iface.get("external-connection-point-ref"): try: - cp = vnfd.get("connection-point")[iface.get("vnfd-connection-point-ref")] + cp = vnfd.get("connection-point")[iface.get("external-connection-point-ref")] db_interface["external_name"] = get_str(cp, "name", 255) cp_name2iface_uuid[db_interface["external_name"]] = iface_uuid cp_name2vm_uuid[db_interface["external_name"]] = vm_uuid @@ -1008,27 +1025,28 @@ def new_vnfd_v3(mydb, tenant_id, vnf_descriptor): # if cp.get("port-security-enabled") == False: # elif cp.get("port-security-enabled") == True: except KeyError: - raise KeyError( - "Error wrong reference at vnfd['{vnf}'] vdu['{vdu}']:internal-interface['{iface}']:" - "vnfd-connection-point-ref '{cp}' is not present at connection-point".format( - vnf=vnfd["id"], vdu=vdu["id"], iface=iface["name"], - cp=iface.get("vnfd-connection-point-ref")) - ) - elif iface.get("vdu-internal-connection-point-ref"): + raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'vdu[{vdu}]':" + "'interface[{iface}]':'vnfd-connection-point-ref':'{cp}' is not present" + " at connection-point".format( + vnf=vnfd["id"], vdu=vdu["id"], iface=iface["name"], + cp=iface.get("vnfd-connection-point-ref")), + HTTP_Bad_Request) + elif iface.get("internal-connection-point-ref"): try: for vld in vnfd.get("internal-vld").itervalues(): for cp in vld.get("internal-connection-point").itervalues(): - if cp.get("id-ref") == iface.get("vdu-internal-connection-point-ref"): + if cp.get("id-ref") == iface.get("internal-connection-point-ref"): db_interface["net_id"] = net_id2uuid[vld.get("id")] break except KeyError: - raise KeyError( - "Error at vnfd['{vnf}'] vdu['{vdu}']:internal-interface['{iface}']:" - "vdu-internal-connection-point-ref '{cp}' is not referenced by any internal-vld".format( - vnf=vnfd["id"], vdu=vdu["id"], iface=iface["name"], - cp=iface.get("vdu-internal-connection-point-ref")) - ) - + raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'vdu[{vdu}]':" + "'interface[{iface}]':'vdu-internal-connection-point-ref':'{cp}' is not" + " referenced by any internal-vld".format( + vnf=vnfd["id"], vdu=vdu["id"], iface=iface["name"], + cp=iface.get("vdu-internal-connection-point-ref")), + HTTP_Bad_Request) + if iface.get("position") is not None: + db_interface["created_at"] = int(iface.get("position")) - 1000 db_interfaces.append(db_interface) # VNF affinity and antiaffinity @@ -1037,9 +1055,10 @@ def new_vnfd_v3(mydb, tenant_id, vnf_descriptor): for vdu in pg.get("member-vdus").itervalues(): vdu_id = get_str(vdu, "member-vdu-ref", 255) if vdu_id not in vdu_id2db_table_index: - raise KeyError( - "Error at 'vnfd'['{vnf}']:'placement-groups'['{pg}']:'member-vdus':'{vdu}' references a non existing vdu".format( - vnf=vnfd["id"], pg=pg_name, vdu=vdu_id)) + raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'placement-groups[{pg}]':" + "'member-vdus':'{vdu}'. Reference to a non-existing vdu".format( + vnf=vnfd["id"], pg=pg_name, vdu=vdu_id), + HTTP_Bad_Request) db_vms[vdu_id2db_table_index[vdu_id]]["availability_zone"] = pg_name # TODO consider the case of isolation and not colocation # if pg.get("strategy") == "ISOLATION": @@ -1048,26 +1067,36 @@ def new_vnfd_v3(mydb, tenant_id, vnf_descriptor): mgmt_access = {} if vnfd["mgmt-interface"].get("vdu-id"): if vnfd["mgmt-interface"]["vdu-id"] not in vdu_id2uuid: - raise KeyError( - "Error at vnfd['{vnf}']:'mgmt-interface':'vdu-id':{vdu} reference a non existing vdu".format( - vnf=vnfd["id"], vdu=vnfd["mgmt-interface"]["vdu-id"])) + raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'mgmt-interface':'vdu-id':" + "'{vdu}'. Reference to a non-existing vdu".format( + vnf=vnfd["id"], vdu=vnfd["mgmt-interface"]["vdu-id"]), + HTTP_Bad_Request) mgmt_access["vm_id"] = vdu_id2uuid[vnfd["mgmt-interface"]["vdu-id"]] if vnfd["mgmt-interface"].get("ip-address"): mgmt_access["ip-address"] = str(vnfd["mgmt-interface"].get("ip-address")) if vnfd["mgmt-interface"].get("cp"): if vnfd["mgmt-interface"]["cp"] not in cp_name2iface_uuid: - raise KeyError( - "Error at vnfd['{vnf}']:'mgmt-interface':'cp':{cp} reference a non existing connection-point". - format(vnf=vnfd["id"], cp=vnfd["mgmt-interface"]["cp"])) + raise NfvoException("Error. Invalid VNF descriptor at 'vnfd[{vnf}]':'mgmt-interface':'cp':'{cp}'. " + "Reference to a non-existing connection-point".format( + vnf=vnfd["id"], cp=vnfd["mgmt-interface"]["cp"]), + HTTP_Bad_Request) mgmt_access["vm_id"] = cp_name2vm_uuid[vnfd["mgmt-interface"]["cp"]] mgmt_access["interface_id"] = cp_name2iface_uuid[vnfd["mgmt-interface"]["cp"]] - default_user = get_str(vnfd.get("vnf-configuration").get("config-access", {}).get("ssh-access", {}), + default_user = get_str(vnfd.get("vnf-configuration", {}).get("config-access", {}).get("ssh-access", {}), "default-user", 64) + if default_user: mgmt_access["default_user"] = default_user + required = get_str(vnfd.get("vnf-configuration", {}).get("config-access", {}).get("ssh-access", {}), + "required", 6) + if required: + mgmt_access["required"] = required + if mgmt_access: db_vnf["mgmt_access"] = yaml.safe_dump(mgmt_access, default_flow_style=True, width=256) + + db_vnfs.append(db_vnf) db_tables=[ {"vnfs": db_vnfs}, @@ -1082,6 +1111,8 @@ def new_vnfd_v3(mydb, tenant_id, vnf_descriptor): yaml.safe_dump(db_tables, indent=4, default_flow_style=False) ) mydb.new_rows(db_tables, uuid_list) return vnfd_uuid_list + except NfvoException: + raise except Exception as e: logger.error("Exception {}".format(e)) raise # NfvoException("Exception {}".format(e), HTTP_Bad_Request) @@ -1463,7 +1494,7 @@ def delete_vnf(mydb,tenant_id,vnf_id,datacenter=None,vim_tenant=None): #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: + if flavor_vim["datacenter_vim_id"] not in vims: # TODO change to datacenter_tenant_id continue if flavor_vim['created']=='false': #skip this flavor because not created by openmano continue @@ -1494,7 +1525,7 @@ def delete_vnf(mydb,tenant_id,vnf_id,datacenter=None,vim_tenant=None): #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: + if image_vim["datacenter_vim_id"] not in vims: # TODO change to datacenter_tenant_id continue if image_vim['created']=='false': #skip this image because not created by openmano continue @@ -1986,7 +2017,10 @@ def new_nsd_v3(mydb, tenant_id, nsd_descriptor): """ try: mynsd = nsd_catalog.nsd() - pybindJSONDecoder.load_ietf_json(nsd_descriptor, None, None, obj=mynsd) + try: + pybindJSONDecoder.load_ietf_json(nsd_descriptor, None, None, obj=mynsd) + except Exception as e: + raise NfvoException("Error. Invalid NS descriptor format: " + str(e), HTTP_Bad_Request) db_scenarios = [] db_sce_nets = [] db_sce_vnfs = [] @@ -1995,8 +2029,8 @@ def new_nsd_v3(mydb, tenant_id, nsd_descriptor): db_ip_profiles_index = 0 uuid_list = [] nsd_uuid_list = [] - for rift_nsd in mynsd.nsd_catalog.nsd.itervalues(): - nsd = rift_nsd.get() + for nsd_yang in mynsd.nsd_catalog.nsd.itervalues(): + nsd = nsd_yang.get() # table sceanrios scenario_uuid = str(uuid4()) @@ -2021,9 +2055,10 @@ def new_nsd_v3(mydb, tenant_id, nsd_descriptor): existing_vnf = mydb.get_rows(FROM="vnfs", WHERE={'osm_id': str(vnf["vnfd-id-ref"])[:255], 'tenant_id': tenant_id}) if not existing_vnf: - raise KeyError("Error at 'nsd[{}]':'constituent-vnfd':'vnfd-id-ref':'{}' references a " - "non existing VNFD in the catalog".format(str(nsd["id"]), - str(vnf["vnfd-id-ref"])[:255])) + raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'constituent-vnfd':'vnfd-id-ref':" + "'{}'. Reference to a non-existing VNFD in the catalog".format( + str(nsd["id"]), str(vnf["vnfd-id-ref"])[:255]), + HTTP_Bad_Request) sce_vnf_uuid = str(uuid4()) uuid_list.append(sce_vnf_uuid) db_sce_vnf = { @@ -2086,9 +2121,10 @@ def new_nsd_v3(mydb, tenant_id, nsd_descriptor): if vld.get("ip-profile-ref"): ip_profile_name = vld.get("ip-profile-ref") if ip_profile_name not in ip_profile_name2db_table_index: - raise KeyError("Error at 'nsd[{}]':'vld[{}]':'ip-profile-ref':'{}' references a non existing " - "'ip_profiles'".format( - str(nsd["id"]), str(vld["id"]), str(vld["ip-profile-ref"]))) + raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'vld[{}]':'ip-profile-ref':'{}'." + " Reference to a non-existing 'ip_profiles'".format( + str(nsd["id"]), str(vld["id"]), str(vld["ip-profile-ref"])), + HTTP_Bad_Request) db_ip_profiles[ip_profile_name2db_table_index[ip_profile_name]]["sce_net_id"] = sce_net_uuid # table sce_interfaces (vld:vnfd-connection-point-ref) @@ -2096,9 +2132,11 @@ def new_nsd_v3(mydb, tenant_id, nsd_descriptor): vnf_index = int(iface['member-vnf-index-ref']) # check correct parameters if vnf_index not in vnf_index2vnf_uuid: - raise KeyError("Error at 'nsd[{}]':'vld[{}]':'vnfd-connection-point-ref':'member-vnf-index-ref'" - ":'{}' references a non existing index at 'nsd':'constituent-vnfd'".format( - str(nsd["id"]), str(vld["id"]), str(iface["member-vnf-index-ref"]))) + raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'vld[{}]':'vnfd-connection-point" + "-ref':'member-vnf-index-ref':'{}'. Reference to a non-existing index at " + "'nsd':'constituent-vnfd'".format( + str(nsd["id"]), str(vld["id"]), str(iface["member-vnf-index-ref"])), + HTTP_Bad_Request) existing_ifaces = mydb.get_rows(SELECT=('i.uuid as uuid',), FROM="interfaces as i join vms on i.vm_id=vms.uuid", @@ -2106,11 +2144,12 @@ def new_nsd_v3(mydb, tenant_id, nsd_descriptor): 'external_name': get_str(iface, "vnfd-connection-point-ref", 255)}) if not existing_ifaces: - raise KeyError("Error at 'nsd[{}]':'vld[{}]':'vnfd-connection-point-ref':'vnfd-connection-point" - "-ref':'{}' references a non existing interface at VNFD '{}'".format( - str(nsd["id"]), str(vld["id"]), str(iface["vnfd-connection-point-ref"]), - str(iface.get("vnfd-id-ref"))[:255])) - + raise NfvoException("Error. Invalid NS descriptor at 'nsd[{}]':'vld[{}]':'vnfd-connection-point" + "-ref':'vnfd-connection-point-ref':'{}'. Reference to a non-existing " + "connection-point name at VNFD '{}'".format( + str(nsd["id"]), str(vld["id"]), str(iface["vnfd-connection-point-ref"]), + str(iface.get("vnfd-id-ref"))[:255]), + HTTP_Bad_Request) interface_uuid = existing_ifaces[0]["uuid"] sce_interface_uuid = str(uuid4()) uuid_list.append(sce_net_uuid) @@ -2135,6 +2174,8 @@ def new_nsd_v3(mydb, tenant_id, nsd_descriptor): yaml.safe_dump(db_tables, indent=4, default_flow_style=False) ) mydb.new_rows(db_tables, uuid_list) return nsd_uuid_list + except NfvoException: + raise except Exception as e: logger.error("Exception {}".format(e)) raise # NfvoException("Exception {}".format(e), HTTP_Bad_Request) @@ -2157,7 +2198,7 @@ def start_scenario(mydb, tenant_id, scenario_id, instance_scenario_name, instanc 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 = mydb.get_scenario(scenario_id, tenant_id, datacenter_id=datacenter_id) scenarioDict['datacenter2tenant'] = { datacenter_id: myvim['config']['datacenter_tenant_id'] } scenarioDict['datacenter_id'] = datacenter_id #print '================scenarioDict=======================' @@ -2369,7 +2410,6 @@ def start_scenario(mydb, tenant_id, scenario_id, instance_scenario_name, instanc #logger.error("start_scenario %s", error_text) raise NfvoException(error_text, e.http_code) - def unify_cloud_config(cloud_config_preserve, cloud_config): """ join the cloud config information into cloud_config_preserve. In case of conflict cloud_config_preserve preserves @@ -2491,6 +2531,28 @@ def get_vim_thread(mydb, tenant_id, datacenter_id_name=None, datacenter_tenant_i raise NfvoException("{} {}".format(type(e).__name__ , str(e)), e.http_code) +def get_datacenter_uuid(mydb, tenant_id, datacenter_id_name): + WHERE_dict={} + if utils.check_valid_uuid(datacenter_id_name): + WHERE_dict['d.uuid'] = datacenter_id_name + else: + WHERE_dict['d.name'] = datacenter_id_name + + if tenant_id: + WHERE_dict['nfvo_tenant_id'] = 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" + else: + from_ = 'datacenters as d' + vimaccounts = mydb.get_rows(FROM=from_, SELECT=("d.uuid as uuid",), WHERE=WHERE_dict ) + if len(vimaccounts) == 0: + raise NfvoException("datacenter '{}' not found".format(str(datacenter_id_name)), HTTP_Not_Found) + elif len(vimaccounts)>1: + #print "nfvo.datacenter_action() error. Several datacenters found" + raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict) + return vimaccounts[0]["uuid"] + + def get_datacenter_by_name_uuid(mydb, tenant_id, datacenter_id_name=None, **extra_filter): datacenter_id = None datacenter_name = None @@ -2519,34 +2581,38 @@ def update(d, u): d[k] = u[k] return d - def create_instance(mydb, tenant_id, instance_dict): # print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id" # logger.debug("Creating instance...") scenario = instance_dict["scenario"] - #find main datacenter + # find main datacenter myvims = {} myvim_threads_id = {} - instance_tasks={} - tasks_to_launch={} datacenter = instance_dict.get("datacenter") default_datacenter_id, vim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter) myvims[default_datacenter_id] = vim myvim_threads_id[default_datacenter_id], _ = get_vim_thread(mydb, tenant_id, default_datacenter_id) - tasks_to_launch[myvim_threads_id[default_datacenter_id]] = [] - #myvim_tenant = myvim['tenant_id'] -# default_datacenter_name = vim['name'] + tenant = mydb.get_rows_by_id('nfvo_tenants', tenant_id) + # myvim_tenant = myvim['tenant_id'] + rollbackList=[] - #print "Checking that the scenario exists and getting the scenario dictionary" - scenarioDict = mydb.get_scenario(scenario, tenant_id, default_datacenter_id) + # print "Checking that the scenario exists and getting the scenario dictionary" + scenarioDict = mydb.get_scenario(scenario, tenant_id, datacenter_vim_id=myvim_threads_id[default_datacenter_id], + datacenter_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))) + # 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))) + db_instance_vnfs = [] + db_instance_vms = [] + db_instance_interfaces = [] + db_ip_profiles = [] + db_vim_actions = [] uuid_list = [] + task_index = 0 instance_name = instance_dict["name"] instance_uuid = str(uuid4()) uuid_list.append(instance_uuid) @@ -2559,47 +2625,56 @@ def create_instance(mydb, tenant_id, instance_dict): # filled bellow 'datacenter_tenant_id' "description": instance_dict.get("description"), } - db_ip_profiles=[] if scenarioDict.get("cloud-config"): db_instance_scenario["cloud_config"] = yaml.safe_dump(scenarioDict["cloud-config"], default_flow_style=True, width=256) + instance_action_id = get_task_id() + db_instance_action = { + "uuid": instance_action_id, # same uuid for the instance and the action on create + "tenant_id": tenant_id, + "instance_id": instance_uuid, + "description": "CREATE", + } - vnf_net2instance = {} #Auxiliar dictionary. First key:'scenario' or sce_vnf uuid. Second Key: uuid of the net/sce_net. Value: vim_net_id + # Auxiliary dictionaries from x to y + vnf_net2instance = {} sce_net2instance = {} - auxNetDict = {} #Auxiliar dictionary. First key:'scenario' or sce_vnf uuid. Second Key: uuid of the net/sce_net. Value: vim_net_id - auxNetDict['scenario'] = {} + net2task_id = {'scenario': {}} - logger.debug("Creating instance from scenario-dict:\n%s", yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False)) #TODO remove + # logger.debug("Creating instance from scenario-dict:\n%s", + # yaml.safe_dump(scenarioDict, indent=4, default_flow_style=False)) try: # 0 check correct parameters - for net_name, net_instance_desc in instance_dict.get("networks",{}).iteritems(): + for net_name, net_instance_desc in instance_dict.get("networks", {}).iteritems(): found = False for scenario_net in scenarioDict['nets']: if net_name == scenario_net["name"]: found = True break if not found: - raise NfvoException("Invalid scenario network name '{}' at instance:networks".format(net_name), HTTP_Bad_Request) + 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"): + site["datacenter"] = get_datacenter_uuid(mydb, tenant_id, site["datacenter"]) if site["datacenter"] not in myvims: - #Add this datacenter to myvims + # Add this datacenter to myvims d, v = get_datacenter_by_name_uuid(mydb, tenant_id, site["datacenter"]) myvims[d] = v - myvim_threads_id[d],_ = get_vim_thread(mydb, tenant_id, site["datacenter"]) - tasks_to_launch[myvim_threads_id[d]] = [] - site["datacenter"] = d #change name to id + myvim_threads_id[d], _ = get_vim_thread(mydb, tenant_id, site["datacenter"]) + 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) + raise NfvoException("Found more than one entries without datacenter field at " + "instance:networks:{}:sites".format(net_name), HTTP_Bad_Request) site_without_datacenter_field = True - site["datacenter"] = default_datacenter_id #change name to id + site["datacenter"] = default_datacenter_id # change name to id for vnf_name, vnf_instance_desc in instance_dict.get("vnfs",{}).iteritems(): - found=False + found = False for scenario_vnf in scenarioDict['vnfs']: if vnf_name == scenario_vnf['name']: found = True @@ -2607,20 +2682,24 @@ def create_instance(mydb, tenant_id, instance_dict): if not found: raise NfvoException("Invalid vnf name '{}' at instance:vnfs".format(vnf_instance_desc), HTTP_Bad_Request) if "datacenter" in vnf_instance_desc: - # Add this datacenter to myvims + # Add this datacenter to myvims + vnf_instance_desc["datacenter"] = get_datacenter_uuid(mydb, tenant_id, vnf_instance_desc["datacenter"]) 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_id[d],_ = get_vim_thread(mydb, tenant_id, vnf_instance_desc["datacenter"]) - tasks_to_launch[myvim_threads_id[d]] = [] + myvim_threads_id[d], _ = get_vim_thread(mydb, tenant_id, vnf_instance_desc["datacenter"]) scenario_vnf["datacenter"] = vnf_instance_desc["datacenter"] - #0.1 parse cloud-config parameters + # 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. + # We add the RO key to cloud_config + if tenant[0].get('RO_pub_key'): + RO_key = {"key-pairs": [tenant[0]['RO_pub_key']]} + cloud_config = unify_cloud_config(cloud_config, RO_key) + + # 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"]: @@ -2650,16 +2729,17 @@ def create_instance(mydb, tenant_id, instance_dict): 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)) + # 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" db_instance_nets = [] for sce_net in scenarioDict['nets']: - descriptor_net = instance_dict.get("networks",{}).get(sce_net["name"],{}) + descriptor_net = instance_dict.get("networks", {}).get(sce_net["name"], {}) net_name = descriptor_net.get("vim-network-name") sce_net2instance[sce_net['uuid']] = {} - auxNetDict['scenario'][sce_net['uuid']] = {} + net2task_id['scenario'][sce_net['uuid']] = {} sites = descriptor_net.get("sites", [ {} ]) for site in sites: @@ -2672,7 +2752,7 @@ def create_instance(mydb, tenant_id, instance_dict): datacenter_id = default_datacenter_id myvim_thread_id = myvim_threads_id[default_datacenter_id] net_type = sce_net['type'] - lookfor_filter = {'admin_state_up': True, 'status': 'ACTIVE'} #'shared': True + lookfor_filter = {'admin_state_up': True, 'status': 'ACTIVE'} # 'shared': True if not net_name: if sce_net["external"]: @@ -2699,14 +2779,15 @@ def create_instance(mydb, tenant_id, instance_dict): net_vim_name = site["netmap-create"] elif sce_net["external"]: if sce_net['vim_id'] != None: - #there is a netmap at datacenter_nets database #TODO REVISE!!!! + # there is a netmap at datacenter_nets database # TODO REVISE!!!! 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 + filter_text = "vim_id '{}' datacenter_netmap name '{}'. Try to reload vims with "\ + "datacenter-net-update".format(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 + # There is not a netmap, look at datacenter for a net with this name and create if not found create_network = True lookfor_network = True lookfor_filter["name"] = sce_net["name"] @@ -2717,30 +2798,19 @@ def create_instance(mydb, tenant_id, instance_dict): create_network = True 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: - vim_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 = task["id"] - instance_tasks[task_id] = task - tasks_to_launch[myvim_thread_id].append(task) - #network_id = vim.new_network(net_vim_name, net_type, sce_net.get('ip_profile',None)) - vim_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 + if lookfor_network and create_network: + # TODO create two tasks FIND + CREATE with their relationship + task_action = "FIND" + task_params = (lookfor_filter,) + # task_action = "CREATE" + # task_params = (net_vim_name, net_type, sce_net.get('ip_profile', None)) + # task + elif lookfor_network: + task_action = "FIND" + task_params = (lookfor_filter,) + elif create_network: + task_action = "CREATE" + task_params = (net_vim_name, net_type, sce_net.get('ip_profile', None)) # fill database content net_uuid = str(uuid4()) @@ -2748,7 +2818,7 @@ def create_instance(mydb, tenant_id, instance_dict): sce_net2instance[sce_net['uuid']][datacenter_id] = net_uuid db_net = { "uuid": net_uuid, - 'vim_net_id': vim_id, + 'vim_net_id': None, "instance_scenario_id": instance_uuid, "sce_net_id": sce_net["uuid"], "created": create_network, @@ -2757,6 +2827,20 @@ def create_instance(mydb, tenant_id, instance_dict): 'status': 'BUILD' if create_network else "ACTIVE" } db_instance_nets.append(db_net) + db_vim_action = { + "instance_action_id": instance_action_id, + "status": "SCHEDULED", + "task_index": task_index, + "datacenter_vim_id": myvim_thread_id, + "action": task_action, + "item": "instance_nets", + "item_id": net_uuid, + "extra": yaml.safe_dump({"params": task_params}, default_flow_style=True, width=256) + } + net2task_id['scenario'][sce_net['uuid']][datacenter_id] = task_index + task_index += 1 + db_vim_actions.append(db_vim_action) + if 'ip_profile' in sce_net: db_ip_profile={ 'instance_net_id': net_uuid, @@ -2775,33 +2859,23 @@ def create_instance(mydb, tenant_id, instance_dict): for sce_vnf in scenarioDict['vnfs']: for net in sce_vnf['nets']: if sce_vnf.get("datacenter"): - vim = myvims[ sce_vnf["datacenter"] ] datacenter_id = sce_vnf["datacenter"] - myvim_thread_id = myvim_threads_id[ sce_vnf["datacenter"]] + myvim_thread_id = myvim_threads_id[sce_vnf["datacenter"]] else: - vim = myvims[ default_datacenter_id ] datacenter_id = default_datacenter_id myvim_thread_id = myvim_threads_id[default_datacenter_id] - descriptor_net = instance_dict.get("vnfs",{}).get(sce_vnf["name"],{}) + 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_name = "{}.{}".format(instance_name, net["name"]) + net_name = net_name[:255] # limit length net_type = net['type'] - task = new_task("new-net", (net_name, net_type, net.get('ip_profile',None))) - task_id = task["id"] - instance_tasks[task_id] = task - tasks_to_launch[myvim_thread_id].append(task) - # network_id = vim.new_network(net_name, net_type, net.get('ip_profile',None)) - vim_id = task_id + if sce_vnf['uuid'] not in vnf_net2instance: vnf_net2instance[sce_vnf['uuid']] = {} - vnf_net2instance[sce_vnf['uuid']][net['uuid']] = task_id - if sce_vnf['uuid'] not in auxNetDict: - auxNetDict[sce_vnf['uuid']] = {} - auxNetDict[sce_vnf['uuid']][net['uuid']] = task_id - rollbackList.append({'what':'network','where':'vim','vim_id':datacenter_id,'uuid':task_id}) - net["created"] = True + if sce_vnf['uuid'] not in net2task_id: + net2task_id[sce_vnf['uuid']] = {} + net2task_id[sce_vnf['uuid']][net['uuid']] = task_index # fill database content net_uuid = str(uuid4()) @@ -2809,7 +2883,7 @@ def create_instance(mydb, tenant_id, instance_dict): vnf_net2instance[sce_vnf['uuid']][net['uuid']] = net_uuid db_net = { "uuid": net_uuid, - 'vim_net_id': vim_id, + 'vim_net_id': None, "instance_scenario_id": instance_uuid, "net_id": net["uuid"], "created": True, @@ -2817,6 +2891,21 @@ def create_instance(mydb, tenant_id, instance_dict): 'datacenter_tenant_id': myvim_thread_id, } db_instance_nets.append(db_net) + + db_vim_action = { + "instance_action_id": instance_action_id, + "task_index": task_index, + "datacenter_vim_id": myvim_thread_id, + "status": "SCHEDULED", + "action": "CREATE", + "item": "instance_nets", + "item_id": net_uuid, + "extra": yaml.safe_dump({"params": (net_name, net_type, net.get('ip_profile',None))}, + default_flow_style=True, width=256) + } + task_index += 1 + db_vim_actions.append(db_vim_action) + if 'ip_profile' in net: db_ip_profile = { 'instance_net_id': net_uuid, @@ -2830,16 +2919,12 @@ def create_instance(mydb, tenant_id, instance_dict): } db_ip_profiles.append(db_ip_profile) - #print "vnf_net2instance:" - #print yaml.safe_dump(vnf_net2instance, indent=4, default_flow_style=False) + # print "vnf_net2instance:" + # print yaml.safe_dump(vnf_net2instance, indent=4, default_flow_style=False) # 3. Creating new vm instances in the VIM - db_instance_vnfs = [] - db_instance_vms = [] - db_instance_interfaces = [] - #myvim.new_vminstance(self,vimURI,tenant_id,name,description,image_id,flavor_id,net_dict) - sce_vnf_list = sorted(scenarioDict['vnfs'], key=lambda k: k['name']) - #for sce_vnf in scenarioDict['vnfs']: + # myvim.new_vminstance(self,vimURI,tenant_id,name,description,image_id,flavor_id,net_dict) + sce_vnf_list = sorted(scenarioDict['vnfs'], key=lambda k: k['name']) for sce_vnf in sce_vnf_list: vnf_availability_zones = [] for vm in sce_vnf['vms']: @@ -2881,25 +2966,25 @@ def create_instance(mydb, tenant_id, instance_dict): myVMDict['description'] = myVMDict['name'][0:99] # if not startvms: # myVMDict['start'] = "no" - myVMDict['name'] = myVMDict['name'][0:255] #limit name length + myVMDict['name'] = myVMDict['name'][0:255] # limit name length #create image at vim in case it not exist image_dict = mydb.get_table_by_uuid_name("images", vm['image_id']) image_id = create_or_use_image(mydb, {datacenter_id: vim}, image_dict, [], True) vm['vim_image_id'] = image_id - #create flavor at vim in case it not exist + # 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_dict['extended'] = yaml.load(flavor_dict['extended']) flavor_id = create_or_use_flavor(mydb, {datacenter_id: vim}, flavor_dict, rollbackList, True) - #Obtain information for additional disks + # 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]) + # extended_flavor_dict_yaml = yaml.load(extended_flavor_dict[0]) myVMDict['disks'] = None extended_info = extended_flavor_dict[0]['extended'] if extended_info != None: @@ -2912,8 +2997,8 @@ def create_instance(mydb, tenant_id, instance_dict): myVMDict['flavorRef'] = vm['vim_flavor_id'] myVMDict['availability_zone'] = vm.get('availability_zone') myVMDict['networks'] = [] - task_depends = {} - #TODO ALF. connect_mgmt_interfaces. Connect management interfaces if this is true + task_depends_on = [] + # TODO ALF. connect_mgmt_interfaces. Connect management interfaces if this is true db_vm_ifaces = [] for iface in vm['interfaces']: netDict = {} @@ -2921,8 +3006,9 @@ def create_instance(mydb, tenant_id, instance_dict): 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 + # 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']: @@ -2957,20 +3043,20 @@ def create_instance(mydb, tenant_id, instance_dict): 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'] ][datacenter_id] + netDict['net_id'] = "TASK-{}".format(net2task_id['scenario'][ vnf_iface['sce_net_id'] ][datacenter_id]) instance_net_id = sce_net2instance[ vnf_iface['sce_net_id'] ][datacenter_id] + task_depends_on.append(net2task_id['scenario'][ vnf_iface['sce_net_id'] ][datacenter_id]) break else: - netDict['net_id'] = auxNetDict[ sce_vnf['uuid'] ][ iface['net_id'] ] + netDict['net_id'] = "TASK-{}".format(net2task_id[ sce_vnf['uuid'] ][ iface['net_id'] ]) instance_net_id = vnf_net2instance[ sce_vnf['uuid'] ][ iface['net_id'] ] - if netDict.get('net_id') and is_task_id(netDict['net_id']): - task_depends[netDict['net_id']] = instance_tasks[netDict['net_id']] - #skip bridge ifaces not connected to any net - #if 'net_id' not in netDict or netDict['net_id']==None: - # continue + task_depends_on.append(net2task_id[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) db_vm_iface={ # "uuid" @@ -3001,16 +3087,9 @@ def create_instance(mydb, tenant_id, instance_dict): vm_index_name = "" if vm.get('count', 1) > 1: vm_index_name += "." + chr(97 + vm_index) - task = new_task("new-vm", (myVMDict['name']+vm_index_name, myVMDict['description'], - myVMDict.get('start', None), myVMDict['imageRef'], - myVMDict['flavorRef'], myVMDict['networks'], - cloud_config_vm, myVMDict['disks'], av_index, - vnf_availability_zones), depends=task_depends) - instance_tasks[task["id"]] = task - tasks_to_launch[myvim_thread_id].append(task) - vm_id = task["id"] - vm['vim_id'] = vm_id - rollbackList.append({'what':'vm','where':'vim','vim_id':datacenter_id,'uuid':vm_id}) + task_params = (myVMDict['name']+vm_index_name, myVMDict['description'], myVMDict.get('start', None), + myVMDict['imageRef'], myVMDict['flavorRef'], myVMDict['networks'], cloud_config_vm, + myVMDict['disks'], av_index, vnf_availability_zones) # put interface uuid back to scenario[vnfs][vms[[interfaces] for net in myVMDict['networks']: if "vim_id" in net: @@ -3023,11 +3102,13 @@ def create_instance(mydb, tenant_id, instance_dict): db_vm = { "uuid": vm_uuid, 'instance_vnf_id': vnf_uuid, - "vim_vm_id": vm_id, + #TODO delete "vim_vm_id": vm_id, "vm_id": vm["uuid"], # "status": } db_instance_vms.append(db_vm) + + iface_index = 0 for db_vm_iface in db_vm_ifaces: iface_uuid = str(uuid4()) uuid_list.append(iface_uuid) @@ -3047,9 +3128,26 @@ def create_instance(mydb, tenant_id, instance_dict): except: db_vm_iface_instance["ip_address"] = None db_instance_interfaces.append(db_vm_iface_instance) + myVMDict['networks'][iface_index]["uuid"] = iface_uuid + iface_index += 1 + + db_vim_action = { + "instance_action_id": instance_action_id, + "task_index": task_index, + "datacenter_vim_id": myvim_thread_id, + "action": "CREATE", + "status": "SCHEDULED", + "item": "instance_vms", + "item_id": vm_uuid, + "extra": yaml.safe_dump({"params": task_params, "depends_on": task_depends_on}, + default_flow_style=True, width=256) + } + task_index += 1 + db_vim_actions.append(db_vim_action) scenarioDict["datacenter2tenant"] = myvim_threads_id + db_instance_action["number_tasks"] = task_index db_instance_scenario['datacenter_tenant_id'] = myvim_threads_id[default_datacenter_id] db_instance_scenario['datacenter_id'] = default_datacenter_id db_tables=[ @@ -3059,27 +3157,20 @@ def create_instance(mydb, tenant_id, instance_dict): {"ip_profiles": db_ip_profiles}, {"instance_vms": db_instance_vms}, {"instance_interfaces": db_instance_interfaces}, + {"instance_actions": db_instance_action}, + {"vim_actions": db_vim_actions} ] - logger.debug("create_instance Deployment done scenarioDict: %s", + logger.debug("create_instance done DB tables: %s", yaml.safe_dump(db_tables, indent=4, default_flow_style=False) ) mydb.new_rows(db_tables, uuid_list) - for myvim_thread_id,task_list in tasks_to_launch.items(): - for task in task_list: - vim_threads["running"][myvim_thread_id].insert_task(task) - - global_instance_tasks[instance_uuid] = instance_tasks - # Update database with those ended instance_tasks - # for task in instance_tasks.values(): - # if task["status"] == "ok": - # if task["name"] == "new-vm": - # mydb.update_rows("instance_vms", UPDATE={"vim_vm_id": task["result"]}, - # WHERE={"vim_vm_id": task["id"]}) - # elif task["name"] == "new-net": - # mydb.update_rows("instance_nets", UPDATE={"vim_net_id": task["result"]}, - # WHERE={"vim_net_id": task["id"]}) - return mydb.get_instance_scenario(instance_uuid) - except (NfvoException, vimconn.vimconnException,db_base_Exception) as e: + for myvim_thread_id in myvim_threads_id.values(): + vim_threads["running"][myvim_thread_id].insert_task(db_vim_actions) + + returned_instance = mydb.get_instance_scenario(instance_uuid) + returned_instance["action_id"] = instance_action_id + return returned_instance + except (NfvoException, vimconn.vimconnException, db_base_Exception) as e: message = rollback(mydb, myvims, rollbackList) if isinstance(e, db_base_Exception): error_text = "database Exception" @@ -3088,29 +3179,42 @@ def create_instance(mydb, tenant_id, instance_dict): else: error_text = "Exception" error_text += " {} {}. {}".format(type(e).__name__, str(e), message) - #logger.error("create_instance: %s", error_text) + # 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" + # 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) + # 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" + # print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id" - #1. Delete from Database + # 1. Delete from Database message = mydb.delete_instance_scenario(instance_id, tenant_id) - #2. delete from VIM + # 2. delete from VIM error_msg = "" myvims = {} myvim_threads = {} + vimthread_affected = {} + + task_index = 0 + instance_action_id = get_task_id() + db_vim_actions = [] + db_instance_action = { + "uuid": instance_action_id, # same uuid for the instance and the action on create + "tenant_id": tenant_id, + "instance_id": instance_id, + "description": "DELETE", + # "number_tasks": 0 # filled bellow + } - #2.1 deleting VMs - #vm_fail_list=[] + # 2.1 deleting VMs + # vm_fail_list=[] for sce_vnf in instanceDict['vnfs']: datacenter_key = (sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"]) + vimthread_affected[sce_vnf["datacenter_tenant_id"]] = None if datacenter_key not in myvims: try: _,myvim_thread = get_vim_thread(mydb, tenant_id, sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"]) @@ -3133,26 +3237,20 @@ def delete_instance(mydb, tenant_id, instance_id): 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 = global_instance_tasks[instance_id].get(task_id) - if not old_task: - error_msg += "\n VM was scheduled for create, but task {} is not found".format(task_id) - continue - with task_lock: - if old_task["status"] == "enqueued": - old_task["status"] = "deleted" - elif old_task["status"] == "error": - continue - elif old_task["status"] == "processing": - task = new_task("del-vm", (task_id, vm["interfaces"]), depends={task_id: old_task}) - else: #ok - task = new_task("del-vm", (old_task["result"], vm["interfaces"])) - else: - task = new_task("del-vm", (vm['vim_vm_id'], vm["interfaces"]) ) - if task: - myvim_thread.insert_task(task) + db_vim_action = { + "instance_action_id": instance_action_id, + "task_index": task_index, + "datacenter_vim_id": sce_vnf["datacenter_tenant_id"], + "action": "DELETE", + "status": "SCHEDULED", + "item": "instance_vms", + "item_id": vm["uuid"], + "extra": yaml.safe_dump({"params": vm["interfaces"]}, + default_flow_style=True, width=256) + } + task_index += 1 + db_vim_actions.append(db_vim_action) + 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", @@ -3162,11 +3260,13 @@ def delete_instance(mydb, tenant_id, instance_id): 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=[] + # 2.2 deleting NETS + # net_fail_list=[] for net in instanceDict['nets']: - if not net['created']: - continue #skip not created nets + # TODO if not net['created']: + # TODO continue #skip not created nets + + vimthread_affected[net["datacenter_tenant_id"]] = None datacenter_key = (net["datacenter_id"], net["datacenter_tenant_id"]) if datacenter_key not in myvims: try: @@ -3189,26 +3289,20 @@ def delete_instance(mydb, tenant_id, instance_id): error_msg += "\n Net VIM_id={} cannot be deleted because datacenter={} not found".format(net['vim_net_id'], net["datacenter_id"]) continue try: - task = None - if is_task_id(net['vim_net_id']): - task_id = net['vim_net_id'] - old_task = global_instance_tasks[instance_id].get(task_id) - if not old_task: - error_msg += "\n NET was scheduled for create, but task {} is not found".format(task_id) - continue - with task_lock: - if old_task["status"] == "enqueued": - old_task["status"] = "deleted" - elif old_task["status"] == "error": - continue - elif old_task["status"] == "processing": - task = new_task("del-net", task_id, depends={task_id: old_task}) - else: # ok - task = new_task("del-net", old_task["result"]) - else: - task = new_task("del-net", (net['vim_net_id'], net['sdn_net_id'])) - if task: - myvim_thread.insert_task(task) + db_vim_action = { + "instance_action_id": instance_action_id, + "task_index": task_index, + "datacenter_vim_id": net["datacenter_tenant_id"], + "action": "DELETE", + "status": "SCHEDULED", + "item": "instance_nets", + "item_id": net["uuid"], + "extra": yaml.safe_dump({"params": (net['vim_net_id'], net['sdn_net_id'])}, + default_flow_style=True, width=256) + } + task_index += 1 + db_vim_actions.append(db_vim_action) + 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", @@ -3219,10 +3313,24 @@ def delete_instance(mydb, tenant_id, instance_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)) + + db_instance_action["number_tasks"] = task_index + db_tables = [ + {"instance_actions": db_instance_action}, + {"vim_actions": db_vim_actions} + ] + + logger.debug("delete_instance done DB tables: %s", + yaml.safe_dump(db_tables, indent=4, default_flow_style=False)) + mydb.new_rows(db_tables, ()) + for myvim_thread_id in vimthread_affected.keys(): + vim_threads["running"][myvim_thread_id].insert_task(db_vim_actions) + 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 + return 'action_id={} instance {} deleted but some elements could not be deleted, or already deleted '\ + '(error: 404) from VIM: {}'.format(instance_action_id, message, error_msg) else: - return 'instance ' + message + ' deleted' + return "action_id={} instance {} deleted".format(instance_action_id, message) def refresh_instance(mydb, nfvo_tenant, instanceDict, datacenter=None, vim_tenant=None): @@ -3389,7 +3497,6 @@ def refresh_instance(mydb, nfvo_tenant, instanceDict, datacenter=None, vim_tenan return 0, 'Scenario instance ' + instance_id + ' refreshed.' - def instance_action(mydb,nfvo_tenant,instance_id, action_dict): #print "Checking that the instance_id exists and getting the instance dictionary" instanceDict = mydb.get_instance_scenario(instance_id, nfvo_tenant) @@ -3401,6 +3508,13 @@ def instance_action(mydb,nfvo_tenant,instance_id, action_dict): raise NfvoException("datacenter '{}' not found".format(str(instanceDict['datacenter_id'])), HTTP_Not_Found) myvim = vims.values()[0] + if action_dict.get("create-vdu"): + for vdu in action_dict["create-vdu"]: + vdu_id = vdu.get("vdu-id") + vdu_count = vdu.get("count", 1) + # get from database TODO + # insert tasks TODO + pass input_vnfs = action_dict.pop("vnfs", []) input_vms = action_dict.pop("vms", []) @@ -3412,47 +3526,72 @@ def instance_action(mydb,nfvo_tenant,instance_id, action_dict): for vm in sce_vnf['vms']: if not action_over_all: 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: + vm['uuid'] not in input_vms and vm['name'] not in input_vms: continue try: - data = myvim.action_vminstance(vm['vim_vm_id'], action_dict) - if "console" in action_dict: - 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 - else: - #print "console data", data + if "add_public_key" in action_dict: + mgmt_access = {} + if sce_vnf.get('mgmt_access'): + mgmt_access = yaml.load(sce_vnf['mgmt_access']) + ssh_access = mgmt_access['config-access']['ssh-access'] + tenant = mydb.get_rows_by_id('nfvo_tenants', nfvo_tenant) try: - console_thread = create_or_use_console_proxy_thread(data["server"], data["port"]) + if ssh_access['required'] and ssh_access['default-user']: + if 'ip_address' in vm: + mgmt_ip = vm['ip_address'].split(';') + password = mgmt_access['config-access'].get('password') + priv_RO_key = decrypt_key(tenant[0]['encrypted_RO_priv_key'], tenant[0]['uuid']) + myvim.inject_user_key(mgmt_ip[0], ssh_access['default-user'], + action_dict['add_public_key'], + password=password, ro_key=priv_RO_key) + else: + raise NfvoException("Unable to inject ssh key in vm: {} - Aborting".format(vm['uuid']), + HTTP_Internal_Server_Error) + except KeyError: + raise NfvoException("Unable to inject ssh key in vm: {} - Aborting".format(vm['uuid']), + HTTP_Internal_Server_Error) + else: + raise NfvoException("Unable to inject ssh key in vm: {} - Aborting".format(vm['uuid']), + HTTP_Internal_Server_Error) + else: + data = myvim.action_vminstance(vm['vim_vm_id'], action_dict) + if "console" in action_dict: + if not global_config["http_console_proxy"]: 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, + ip = data["server"], + port = data["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)} + 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 + else: + #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": 200, "description": "ok", "name":vm['name']} - vm_ok +=1 + else: + 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 @@ -3462,6 +3601,19 @@ def instance_action(mydb,nfvo_tenant,instance_id, action_dict): else: return vm_result +def instance_action_get(mydb, nfvo_tenant, instance_id, action_id): + filter={} + if nfvo_tenant and nfvo_tenant != "any": + filter["tenant_id"] = nfvo_tenant + if instance_id and instance_id != "any": + filter["instance_id"] = instance_id + if action_id: + filter["uuid"] = action_id + rows = mydb.get_rows(FROM="instance_actions", WHERE=filter) + if not rows and action_id: + raise NfvoException("Not found any action with this criteria", HTTP_Not_Found) + return {"ations": rows} + def create_or_use_console_proxy_thread(console_server, console_port): #look for a non-used port @@ -3495,11 +3647,18 @@ def check_tenant(mydb, tenant_id): raise NfvoException("tenant '{}' not found".format(tenant_id), HTTP_Not_Found) return - def new_tenant(mydb, tenant_dict): - tenant_id = mydb.new_row("nfvo_tenants", tenant_dict, add_uuid=True) - return tenant_id + tenant_uuid = str(uuid4()) + tenant_dict['uuid'] = tenant_uuid + try: + pub_key, priv_key = create_RO_keypair(tenant_uuid) + tenant_dict['RO_pub_key'] = pub_key + tenant_dict['encrypted_RO_priv_key'] = priv_key + mydb.new_row("nfvo_tenants", tenant_dict) + except db_base_Exception as e: + raise NfvoException("Error creating the new tenant: {} ".format(tenant_dict['name']) + str(e), HTTP_Internal_Server_Error) + return tenant_uuid def delete_tenant(mydb, tenant): #get nfvo_tenant info @@ -3733,7 +3892,7 @@ def deassociate_datacenter_to_tenant(mydb, tenant_id, datacenter, vim_tenant_id= pass # the error will be caused because dependencies, vim_tenant can not be deleted thread_id = tenant_datacenter_item["datacenter_tenant_id"] thread = vim_threads["running"][thread_id] - thread.insert_task(new_task("exit", None)) + thread.insert_task("exit") vim_threads["deleting"][thread_id] = thread return "datacenter {} detached. {}".format(datacenter_id, warning) @@ -4258,3 +4417,42 @@ def datacenter_sdn_port_mapping_list(mydb, tenant_id, datacenter_id): def datacenter_sdn_port_mapping_delete(mydb, tenant_id, datacenter_id): return ovim.clear_of_port_mapping(db_filter={"region":datacenter_id}) + +def create_RO_keypair(tenant_id): + """ + Creates a public / private keys for a RO tenant and returns their values + Params: + tenant_id: ID of the tenant + Return: + public_key: Public key for the RO tenant + private_key: Encrypted private key for RO tenant + """ + + bits = 2048 + key = RSA.generate(bits) + try: + public_key = key.publickey().exportKey('OpenSSH') + if isinstance(public_key, ValueError): + raise NfvoException("Unable to create public key: {}".format(public_key), HTTP_Internal_Server_Error) + private_key = key.exportKey(passphrase=tenant_id, pkcs=8) + except (ValueError, NameError) as e: + raise NfvoException("Unable to create private key: {}".format(e), HTTP_Internal_Server_Error) + return public_key, private_key + +def decrypt_key (key, tenant_id): + """ + Decrypts an encrypted RSA key + Params: + key: Private key to be decrypted + tenant_id: ID of the tenant + Return: + unencrypted_key: Unencrypted private key for RO tenant + """ + try: + key = RSA.importKey(key,tenant_id) + unencrypted_key = key.exportKey('PEM') + if isinstance(unencrypted_key, ValueError): + raise NfvoException("Unable to decrypt the private key: {}".format(unencrypted_key), HTTP_Internal_Server_Error) + except ValueError as e: + raise NfvoException("Unable to decrypt the private key: {}".format(e), HTTP_Internal_Server_Error) + return unencrypted_key