X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=osm_lcm%2Flcm.py;h=310c4340abe8a8cb6e65e0e4b59e0df94cbe2ec1;hb=86aa62f73881f01687cc9f3f5112552c1788fa54;hp=8c10554f7ac5a6f80c89e73362e408b2fb1f2c55;hpb=22f4f9c3f2fef11377202b95fe2333b78255f8de;p=osm%2FLCM.git diff --git a/osm_lcm/lcm.py b/osm_lcm/lcm.py index 8c10554f..310c4340 100644 --- a/osm_lcm/lcm.py +++ b/osm_lcm/lcm.py @@ -3,13 +3,14 @@ import asyncio import yaml -import ROclient import logging import logging.handlers import getopt import functools import sys import traceback +import ROclient +# from osm_lcm import version as lcm_version, version_date as lcm_version_date, ROclient from osm_common import dbmemory from osm_common import dbmongo from osm_common import fslocal @@ -22,19 +23,115 @@ from os import environ, path from n2vc.vnf import N2VC from n2vc import version as N2VC_version +from collections import OrderedDict from copy import deepcopy from http import HTTPStatus from time import time __author__ = "Alfonso Tierno" -min_RO_version = [0, 5, 69] +min_RO_version = [0, 5, 72] +# uncomment if LCM is installed as library and installed, and get them from __init__.py +lcm_version = '0.1.12' +lcm_version_date = '2018-08-23' class LcmException(Exception): pass +class TaskRegistry: + """ + Implements a registry of task needed for later cancelation, look for related tasks that must be completed before + etc. It stores a four level dict + First level is the topic, ns, vim_account, sdn + Second level is the _id + Third level is the operation id + Fourth level is a descriptive name, the value is the task class + """ + + def __init__(self): + self.task_registry = { + "ns": {}, + "vim_account": {}, + "sdn": {}, + } + + def register(self, topic, _id, op_id, task_name, task): + """ + Register a new task + :param topic: Can be "ns", "vim_account", "sdn" + :param _id: _id of the related item + :param op_id: id of the operation of the related item + :param task_name: Task descriptive name, as create, instantiate, terminate. Must be unique in this op_id + :param task: Task class + :return: none + """ + if _id not in self.task_registry[topic]: + self.task_registry[topic][_id] = OrderedDict() + if op_id not in self.task_registry[topic][_id]: + self.task_registry[topic][_id][op_id] = {task_name: task} + else: + self.task_registry[topic][_id][op_id][task_name] = task + # print("registering task", topic, _id, op_id, task_name, task) + + def remove(self, topic, _id, op_id, task_name=None): + """ + When task is ended, it should removed. It ignores missing tasks + :param topic: Can be "ns", "vim_account", "sdn" + :param _id: _id of the related item + :param op_id: id of the operation of the related item + :param task_name: Task descriptive name. If note it deletes all + :return: + """ + if not self.task_registry[topic].get(_id) or not self.task_registry[topic][_id].get(op_id): + return + if not task_name: + # print("deleting tasks", topic, _id, op_id, self.task_registry[topic][_id][op_id]) + del self.task_registry[topic][_id][op_id] + elif task_name in self.task_registry[topic][_id][op_id]: + # print("deleting tasks", topic, _id, op_id, task_name, self.task_registry[topic][_id][op_id][task_name]) + del self.task_registry[topic][_id][op_id][task_name] + if not self.task_registry[topic][_id][op_id]: + del self.task_registry[topic][_id][op_id] + if not self.task_registry[topic][_id]: + del self.task_registry[topic][_id] + + def lookfor_related(self, topic, _id, my_op_id=None): + task_list = [] + task_name_list = [] + if _id not in self.task_registry[topic]: + return "", task_name_list + for op_id in reversed(self.task_registry[topic][_id]): + if my_op_id: + if my_op_id == op_id: + my_op_id = None # so that the next task is taken + continue + + for task_name, task in self.task_registry[topic][_id][op_id].items(): + task_list.append(task) + task_name_list.append(task_name) + break + return ", ".join(task_name_list), task_list + + def cancel(self, topic, _id, target_op_id=None, target_task_name=None): + """ + Cancel all active tasks of a concrete ns, vim_account, sdn identified for _id. If op_id is supplied only this is + cancelled, and the same with task_name + """ + if not self.task_registry[topic].get(_id): + return + for op_id in reversed(self.task_registry[topic][_id]): + if target_op_id and target_op_id != op_id: + continue + for task_name, task in self.task_registry[topic][_id][op_id].items(): + if target_task_name and target_task_name != task_name: + continue + result = task.cancel() + if result: + self.logger.debug("{} _id={} order_id={} task={} cancelled".format(topic, _id, op_id, task_name)) + + class Lcm: def __init__(self, config_file): @@ -50,9 +147,7 @@ class Lcm: self.pings_not_received = 1 # contains created tasks/futures to be able to cancel - self.lcm_ns_tasks = {} - self.lcm_vim_tasks = {} - self.lcm_sdn_tasks = {} + self.lcm_tasks = TaskRegistry() # logging self.logger = logging.getLogger('lcm') # load configuration @@ -74,12 +169,12 @@ class Lcm: config["database"]["logger_name"] = "lcm.db" config["storage"]["logger_name"] = "lcm.fs" config["message"]["logger_name"] = "lcm.msg" - if "logfile" in config["global"]: + if config["global"].get("logfile"): file_handler = logging.handlers.RotatingFileHandler(config["global"]["logfile"], maxBytes=100e6, backupCount=9, delay=0) file_handler.setFormatter(log_formatter_simple) self.logger.addHandler(file_handler) - else: + if not config["global"].get("nologging"): str_handler = logging.StreamHandler() str_handler.setFormatter(log_formatter_simple) self.logger.addHandler(str_handler) @@ -91,14 +186,14 @@ class Lcm: for k1, logname in {"message": "lcm.msg", "database": "lcm.db", "storage": "lcm.fs"}.items(): config[k1]["logger_name"] = logname logger_module = logging.getLogger(logname) - if "logfile" in config[k1]: + if config[k1].get("logfile"): file_handler = logging.handlers.RotatingFileHandler(config[k1]["logfile"], maxBytes=100e6, backupCount=9, delay=0) file_handler.setFormatter(log_formatter_simple) logger_module.addHandler(file_handler) - if "loglevel" in config[k1]: + if config[k1].get("loglevel"): logger_module.setLevel(config[k1]["loglevel"]) - + self.logger.critical("starting osm/lcm version {} {}".format(lcm_version, lcm_version_date)) self.n2vc = N2VC( log=self.logger, server=config['VCA']['host'], @@ -161,12 +256,6 @@ class Lcm: self.logger.critical("Error while conneting to osm/RO " + str(e), exc_info=True) raise LcmException(str(e)) - def update_db(self, item, _id, _desc): - try: - self.db.replace(item, _id, _desc) - except DbException as e: - self.logger.error("Updating {} _id={}: {}".format(item, _id, e)) - def update_db_2(self, item, _id, _desc): """ Updates database with _desc information. Upon success _desc is cleared @@ -188,16 +277,13 @@ class Lcm: logging_text = "Task vim_create={} ".format(vim_id) self.logger.debug(logging_text + "Enter") db_vim = None + db_vim_update = {} exc = None RO_sdn_id = None try: step = "Getting vim-id='{}' from db".format(vim_id) db_vim = self.db.get_one("vim_accounts", {"_id": vim_id}) - if "_admin" not in db_vim: - db_vim["_admin"] = {} - if "deployed" not in db_vim["_admin"]: - db_vim["_admin"]["deployed"] = {} - db_vim["_admin"]["deployed"]["RO"] = None + db_vim_update["_admin.deployed.RO"] = None if vim_content.get("config") and vim_content["config"].get("sdn-controller"): step = "Getting sdn-controller-id='{}' from db".format(vim_content["config"]["sdn-controller"]) db_sdn = self.db.get_one("sdns", {"_id": vim_content["config"]["sdn-controller"]}) @@ -208,6 +294,8 @@ class Lcm: vim_content["config"]["sdn-controller"])) step = "Creating vim at RO" + db_vim_update["_admin.detailed-status"] = step + self.update_db_2("vim_accounts", vim_id, db_vim_update) RO = ROclient.ROClient(self.loop, **self.ro_config) vim_RO = deepcopy(vim_content) vim_RO.pop("_id", None) @@ -222,10 +310,12 @@ class Lcm: vim_RO["config"]["sdn-controller"] = RO_sdn_id desc = await RO.create("vim", descriptor=vim_RO) RO_vim_id = desc["uuid"] - db_vim["_admin"]["deployed"]["RO"] = RO_vim_id - self.update_db("vim_accounts", vim_id, db_vim) + db_vim_update["_admin.deployed.RO"] = RO_vim_id step = "Creating vim_account at RO" + db_vim_update["_admin.detailed-status"] = step + self.update_db_2("vim_accounts", vim_id, db_vim_update) + vim_account_RO = {"vim_tenant_name": vim_content["vim_tenant_name"], "vim_username": vim_content["vim_user"], "vim_password": vim_content["vim_password"] @@ -236,12 +326,14 @@ class Lcm: del vim_account_RO["config"]["sdn-controller"] if "sdn-port-mapping" in vim_account_RO["config"]: del vim_account_RO["config"]["sdn-port-mapping"] - await RO.attach_datacenter(RO_vim_id, descriptor=vim_account_RO) - db_vim["_admin"]["operationalState"] = "ENABLED" - self.update_db("vim_accounts", vim_id, db_vim) + desc = await RO.attach_datacenter(RO_vim_id, descriptor=vim_account_RO) + db_vim_update["_admin.deployed.RO-account"] = desc["uuid"] + db_vim_update["_admin.operationalState"] = "ENABLED" + db_vim_update["_admin.detailed-status"] = "Done" - self.logger.debug(logging_text + "Exit Ok RO_vim_id".format(RO_vim_id)) - return RO_vim_id + # await asyncio.sleep(15) # TODO remove. This is for test + self.logger.debug(logging_text + "Exit Ok RO_vim_id={}".format(RO_vim_id)) + return except (ROclient.ROClientException, DbException) as e: self.logger.error(logging_text + "Exit Exception {}".format(e)) @@ -251,9 +343,11 @@ class Lcm: exc = e finally: if exc and db_vim: - db_vim["_admin"]["operationalState"] = "ERROR" - db_vim["_admin"]["detailed-status"] = "ERROR {}: {}".format(step, exc) - self.update_db("vim_accounts", vim_id, db_vim) + db_vim_update["_admin.operationalState"] = "ERROR" + db_vim_update["_admin.detailed-status"] = "ERROR {}: {}".format(step, exc) + if db_vim_update: + self.update_db_2("vim_accounts", vim_id, db_vim_update) + self.lcm_tasks.remove("vim_account", vim_id, order_id) async def vim_edit(self, vim_content, order_id): vim_id = vim_content["_id"] @@ -262,13 +356,33 @@ class Lcm: db_vim = None exc = None RO_sdn_id = None + RO_vim_id = None + db_vim_update = {} step = "Getting vim-id='{}' from db".format(vim_id) try: db_vim = self.db.get_one("vim_accounts", {"_id": vim_id}) + + # look if previous tasks in process + task_name, task_dependency = self.lcm_tasks.lookfor_related("vim_account", vim_id, order_id) + if task_dependency: + step = "Waiting for related tasks to be completed: {}".format(task_name) + self.logger.debug(logging_text + step) + # TODO write this to database + await asyncio.wait(task_dependency, timeout=3600) + if db_vim.get("_admin") and db_vim["_admin"].get("deployed") and db_vim["_admin"]["deployed"].get("RO"): if vim_content.get("config") and vim_content["config"].get("sdn-controller"): step = "Getting sdn-controller-id='{}' from db".format(vim_content["config"]["sdn-controller"]) db_sdn = self.db.get_one("sdns", {"_id": vim_content["config"]["sdn-controller"]}) + + # look if previous tasks in process + task_name, task_dependency = self.lcm_tasks.lookfor_related("sdn", db_sdn["_id"]) + if task_dependency: + step = "Waiting for related tasks to be completed: {}".format(task_name) + self.logger.debug(logging_text + step) + # TODO write this to database + await asyncio.wait(task_dependency, timeout=3600) + if db_sdn.get("_admin") and db_sdn["_admin"].get("deployed") and db_sdn["_admin"]["deployed"].get( "RO"): RO_sdn_id = db_sdn["_admin"]["deployed"]["RO"] @@ -312,11 +426,10 @@ class Lcm: # vim_account must be edited always even if empty in order to ensure changes are translated to RO # vim_thread. RO will remove and relaunch a new thread for this vim_account await RO.edit("vim_account", RO_vim_id, descriptor=vim_account_RO) - db_vim["_admin"]["operationalState"] = "ENABLED" - self.update_db("vim_accounts", vim_id, db_vim) + db_vim_update["_admin.operationalState"] = "ENABLED" - self.logger.debug(logging_text + "Exit Ok RO_vim_id".format(RO_vim_id)) - return RO_vim_id + self.logger.debug(logging_text + "Exit Ok RO_vim_id={}".format(RO_vim_id)) + return except (ROclient.ROClientException, DbException) as e: self.logger.error(logging_text + "Exit Exception {}".format(e)) @@ -326,14 +439,17 @@ class Lcm: exc = e finally: if exc and db_vim: - db_vim["_admin"]["operationalState"] = "ERROR" - db_vim["_admin"]["detailed-status"] = "ERROR {}: {}".format(step, exc) - self.update_db("vim_accounts", vim_id, db_vim) + db_vim_update["_admin.operationalState"] = "ERROR" + db_vim_update["_admin.detailed-status"] = "ERROR {}: {}".format(step, exc) + if db_vim_update: + self.update_db_2("vim_accounts", vim_id, db_vim_update) + self.lcm_tasks.remove("vim_account", vim_id, order_id) async def vim_delete(self, vim_id, order_id): logging_text = "Task vim_delete={} ".format(vim_id) self.logger.debug(logging_text + "Enter") db_vim = None + db_vim_update = {} exc = None step = "Getting vim from db" try: @@ -360,10 +476,10 @@ class Lcm: raise else: # nothing to delete - self.logger.error(logging_text + "Skipping. There is not RO information at database") + self.logger.error(logging_text + "Nohing to remove at RO") self.db.del_one("vim_accounts", {"_id": vim_id}) - self.logger.debug("vim_delete task vim_id={} Exit Ok".format(vim_id)) - return None + self.logger.debug(logging_text + "Exit Ok") + return except (ROclient.ROClientException, DbException) as e: self.logger.error(logging_text + "Exit Exception {}".format(e)) @@ -372,25 +488,26 @@ class Lcm: self.logger.critical(logging_text + "Exit Exception {}".format(e), exc_info=True) exc = e finally: + self.lcm_tasks.remove("vim_account", vim_id, order_id) if exc and db_vim: - db_vim["_admin"]["operationalState"] = "ERROR" - db_vim["_admin"]["detailed-status"] = "ERROR {}: {}".format(step, exc) - self.update_db("vim_accounts", vim_id, db_vim) + db_vim_update["_admin.operationalState"] = "ERROR" + db_vim_update["_admin.detailed-status"] = "ERROR {}: {}".format(step, exc) + if db_vim_update: + self.update_db_2("vim_accounts", vim_id, db_vim_update) + self.lcm_tasks.remove("vim_account", vim_id, order_id) async def sdn_create(self, sdn_content, order_id): sdn_id = sdn_content["_id"] logging_text = "Task sdn_create={} ".format(sdn_id) self.logger.debug(logging_text + "Enter") db_sdn = None + db_sdn_update = {} + RO_sdn_id = None exc = None try: step = "Getting sdn from db" db_sdn = self.db.get_one("sdns", {"_id": sdn_id}) - if "_admin" not in db_sdn: - db_sdn["_admin"] = {} - if "deployed" not in db_sdn["_admin"]: - db_sdn["_admin"]["deployed"] = {} - db_sdn["_admin"]["deployed"]["RO"] = None + db_sdn_update["_admin.deployed.RO"] = None step = "Creating sdn at RO" RO = ROclient.ROClient(self.loop, **self.ro_config) @@ -402,11 +519,10 @@ class Lcm: sdn_RO.pop("description", None) desc = await RO.create("sdn", descriptor=sdn_RO) RO_sdn_id = desc["uuid"] - db_sdn["_admin"]["deployed"]["RO"] = RO_sdn_id - db_sdn["_admin"]["operationalState"] = "ENABLED" - self.update_db("sdns", sdn_id, db_sdn) - self.logger.debug(logging_text + "Exit Ok RO_sdn_id".format(RO_sdn_id)) - return RO_sdn_id + db_sdn_update["_admin.deployed.RO"] = RO_sdn_id + db_sdn_update["_admin.operationalState"] = "ENABLED" + self.logger.debug(logging_text + "Exit Ok RO_sdn_id={}".format(RO_sdn_id)) + return except (ROclient.ROClientException, DbException) as e: self.logger.error(logging_text + "Exit Exception {}".format(e)) @@ -416,15 +532,18 @@ class Lcm: exc = e finally: if exc and db_sdn: - db_sdn["_admin"]["operationalState"] = "ERROR" - db_sdn["_admin"]["detailed-status"] = "ERROR {}: {}".format(step, exc) - self.update_db("sdns", sdn_id, db_sdn) + db_sdn_update["_admin.operationalState"] = "ERROR" + db_sdn_update["_admin.detailed-status"] = "ERROR {}: {}".format(step, exc) + if db_sdn_update: + self.update_db_2("sdns", sdn_id, db_sdn_update) + self.lcm_tasks.remove("sdn", sdn_id, order_id) async def sdn_edit(self, sdn_content, order_id): sdn_id = sdn_content["_id"] logging_text = "Task sdn_edit={} ".format(sdn_id) self.logger.debug(logging_text + "Enter") db_sdn = None + db_sdn_update = {} exc = None step = "Getting sdn from db" try: @@ -441,11 +560,10 @@ class Lcm: sdn_RO.pop("description", None) if sdn_RO: await RO.edit("sdn", RO_sdn_id, descriptor=sdn_RO) - db_sdn["_admin"]["operationalState"] = "ENABLED" - self.update_db("sdns", sdn_id, db_sdn) + db_sdn_update["_admin.operationalState"] = "ENABLED" self.logger.debug(logging_text + "Exit Ok RO_sdn_id".format(RO_sdn_id)) - return RO_sdn_id + return except (ROclient.ROClientException, DbException) as e: self.logger.error(logging_text + "Exit Exception {}".format(e)) @@ -455,14 +573,17 @@ class Lcm: exc = e finally: if exc and db_sdn: - db_sdn["_admin"]["operationalState"] = "ERROR" - db_sdn["_admin"]["detailed-status"] = "ERROR {}: {}".format(step, exc) - self.update_db("sdns", sdn_id, db_sdn) + db_sdn["_admin.operationalState"] = "ERROR" + db_sdn["_admin.detailed-status"] = "ERROR {}: {}".format(step, exc) + if db_sdn_update: + self.update_db_2("sdns", sdn_id, db_sdn_update) + self.lcm_tasks.remove("sdn", sdn_id, order_id) async def sdn_delete(self, sdn_id, order_id): logging_text = "Task sdn_delete={} ".format(sdn_id) self.logger.debug(logging_text + "Enter") db_sdn = None + db_sdn_update = {} exc = None step = "Getting sdn from db" try: @@ -483,7 +604,7 @@ class Lcm: self.logger.error(logging_text + "Skipping. There is not RO information at database") self.db.del_one("sdns", {"_id": sdn_id}) self.logger.debug("sdn_delete task sdn_id={} Exit Ok".format(sdn_id)) - return None + return except (ROclient.ROClientException, DbException) as e: self.logger.error(logging_text + "Exit Exception {}".format(e)) @@ -493,9 +614,11 @@ class Lcm: exc = e finally: if exc and db_sdn: - db_sdn["_admin"]["operationalState"] = "ERROR" - db_sdn["_admin"]["detailed-status"] = "ERROR {}: {}".format(step, exc) - self.update_db("sdns", sdn_id, db_sdn) + db_sdn["_admin.operationalState"] = "ERROR" + db_sdn["_admin.detailed-status"] = "ERROR {}: {}".format(step, exc) + if db_sdn_update: + self.update_db_2("sdns", sdn_id, db_sdn_update) + self.lcm_tasks.remove("sdn", sdn_id, order_id) def vnfd2RO(self, vnfd, new_id=None): """ @@ -538,8 +661,7 @@ class Lcm: if ci_file: ci_file.close() - def n2vc_callback(self, model_name, application_name, status, message, db_nsr, db_nslcmop, member_vnf_index, - task=None): + def n2vc_callback(self, model_name, application_name, status, message, db_nsr, db_nslcmop, task=None): """ Callback both for charm status change and task completion :param model_name: Charm model name @@ -556,7 +678,6 @@ class Lcm: :param message: detailed message error :param db_nsr: nsr database content :param db_nslcmop: nslcmop database content - :param member_vnf_index: NSD member-vnf-index :param task: None for charm status change, or task for completion task callback :return: """ @@ -566,11 +687,15 @@ class Lcm: db_nslcmop_update = {} try: nsr_id = db_nsr["_id"] - nslcmop_id = db_nslcmop["_id"] nsr_lcm = db_nsr["_admin"]["deployed"] + nslcmop_id = db_nslcmop["_id"] ns_operation = db_nslcmop["lcmOperationType"] - logging_text = "Task ns={} {}={} [n2vc_callback] vnf_index={}".format(nsr_id, ns_operation, nslcmop_id, - member_vnf_index) + logging_text = "Task ns={} {}={} [n2vc_callback] application={}".format(nsr_id, ns_operation, nslcmop_id, + application_name) + vca_deployed = nsr_lcm["VCA"].get(application_name) + if not vca_deployed: + self.logger.error(logging_text + " Not present at nsr._admin.deployed.VCA") + return if task: if task.cancelled(): @@ -583,12 +708,12 @@ class Lcm: if exc: self.logger.error(logging_text + " task Exception={}".format(exc)) if ns_operation in ("instantiate", "terminate"): - nsr_lcm["VCA"][member_vnf_index]['operational-status'] = "error" - db_nsr_update["_admin.deployed.VCA.{}.operational-status".format(member_vnf_index)] = \ + vca_deployed['operational-status'] = "error" + db_nsr_update["_admin.deployed.VCA.{}.operational-status".format(application_name)] = \ "error" - nsr_lcm["VCA"][member_vnf_index]['detailed-status'] = str(exc) + vca_deployed['detailed-status'] = str(exc) db_nsr_update[ - "_admin.deployed.VCA.{}.detailed-status".format(member_vnf_index)] = str(exc) + "_admin.deployed.VCA.{}.detailed-status".format(application_name)] = str(exc) elif ns_operation == "action": db_nslcmop_update["operationState"] = "FAILED" db_nslcmop_update["detailed-status"] = str(exc) @@ -606,12 +731,12 @@ class Lcm: return elif status: self.logger.debug(logging_text + " Enter status={}".format(status)) - if nsr_lcm["VCA"][member_vnf_index]['operational-status'] == status: + if vca_deployed['operational-status'] == status: return # same status, ignore - nsr_lcm["VCA"][member_vnf_index]['operational-status'] = status - db_nsr_update["_admin.deployed.VCA.{}.operational-status".format(member_vnf_index)] = status - nsr_lcm["VCA"][member_vnf_index]['detailed-status'] = str(message) - db_nsr_update["_admin.deployed.VCA.{}.detailed-status".format(member_vnf_index)] = str(message) + vca_deployed['operational-status'] = status + db_nsr_update["_admin.deployed.VCA.{}.operational-status".format(application_name)] = status + vca_deployed['detailed-status'] = str(message) + db_nsr_update["_admin.deployed.VCA.{}.detailed-status".format(application_name)] = str(message) else: self.logger.critical(logging_text + " Enter with bad parameters", exc_info=True) return @@ -619,7 +744,7 @@ class Lcm: all_active = True status_map = {} n2vc_error_text = [] # contain text error list. If empty no one is in error status - for vnf_index, vca_info in nsr_lcm["VCA"].items(): + for _, vca_info in nsr_lcm["VCA"].items(): vca_status = vca_info["operational-status"] if vca_status not in status_map: # Initialize it @@ -628,13 +753,13 @@ class Lcm: if vca_status != "active": all_active = False - elif vca_status in ("error", "blocked"): - n2vc_error_text.append("member_vnf_index={} {}: {}".format(member_vnf_index, vca_status, - vca_info["detailed-status"])) + if vca_status in ("error", "blocked"): + n2vc_error_text.append("member_vnf_index={} vdu_id={} {}: {}".format(vca_info["member-vnf-index"], + vca_info["vdu_id"], vca_status, + vca_info["detailed-status"])) if all_active: - self.logger.debug("[n2vc_callback] ns_instantiate={} vnf_index={} All active".format(nsr_id, - member_vnf_index)) + self.logger.debug(logging_text + " All active") db_nsr_update["config-status"] = "configured" db_nsr_update["detailed-status"] = "done" db_nslcmop_update["operationState"] = "COMPLETED" @@ -658,7 +783,7 @@ class Lcm: db_nslcmop_update["detailed-status"] = cs except Exception as e: - self.logger.critical("[n2vc_callback] vnf_index={} Exception {}".format(member_vnf_index, e), exc_info=True) + self.logger.critical(logging_text + " Exception {}".format(e), exc_info=True) finally: try: if db_nslcmop_update: @@ -666,10 +791,9 @@ class Lcm: if db_nsr_update: self.update_db_2("nsrs", nsr_id, db_nsr_update) except Exception as e: - self.logger.critical("[n2vc_callback] vnf_index={} Update database Exception {}".format( - member_vnf_index, e), exc_info=True) + self.logger.critical(logging_text + " Update database Exception {}".format(e), exc_info=True) - def ns_params_2_RO(self, ns_params): + def ns_params_2_RO(self, ns_params, nsd, vnfd_dict): """ Creates a RO ns descriptor from OSM ns_instantite params :param ns_params: OSM instantiate params @@ -680,9 +804,8 @@ class Lcm: def vim_account_2_RO(vim_account): if vim_account in vim_2_RO: return vim_2_RO[vim_account] + db_vim = self.db.get_one("vim_accounts", {"_id": vim_account}) - # if db_vim["_admin"]["operationalState"] == "PROCESSING": - # #TODO check if VIM is creating and wait if db_vim["_admin"]["operationalState"] != "ENABLED": raise LcmException("VIM={} is not available. operationalState={}".format( vim_account, db_vim["_admin"]["operationalState"])) @@ -690,6 +813,18 @@ class Lcm: vim_2_RO[vim_account] = RO_vim_id return RO_vim_id + def ip_profile_2_RO(ip_profile): + RO_ip_profile = deepcopy((ip_profile)) + if "dns-server" in RO_ip_profile: + RO_ip_profile["dns-address"] = RO_ip_profile.pop("dns-server") + if RO_ip_profile.get("ip-version") == "ipv4": + RO_ip_profile["ip-version"] = "IPv4" + if RO_ip_profile.get("ip-version") == "ipv6": + RO_ip_profile["ip-version"] = "IPv6" + if "dhcp-params" in RO_ip_profile: + RO_ip_profile["dhcp"] = RO_ip_profile.pop("dhcp-params") + return RO_ip_profile + if not ns_params: return None RO_ns_params = { @@ -703,67 +838,99 @@ class Lcm: if ns_params.get("ssh-authorized-key"): RO_ns_params["cloud-config"] = {"key-pairs": ns_params["ssh-authorized-key"]} if ns_params.get("vnf"): - for vnf in ns_params["vnf"]: - RO_vnf = {} - if "vimAccountId" in vnf: - RO_vnf["datacenter"] = vim_account_2_RO(vnf["vimAccountId"]) + for vnf_params in ns_params["vnf"]: + for constituent_vnfd in nsd["constituent-vnfd"]: + if constituent_vnfd["member-vnf-index"] == vnf_params["member-vnf-index"]: + vnf_descriptor = vnfd_dict[constituent_vnfd["vnfd-id-ref"]] + break + else: + raise LcmException("Invalid instantiate parameter vnf:member-vnf-index={} is not present at nsd:" + "constituent-vnfd".format(vnf_params["member-vnf-index"])) + RO_vnf = {"vdus": {}, "networks": {}} + if vnf_params.get("vimAccountId"): + RO_vnf["datacenter"] = vim_account_2_RO(vnf_params["vimAccountId"]) + if vnf_params.get("vdu"): + for vdu_params in vnf_params["vdu"]: + RO_vnf["vdus"][vdu_params["id"]] = {} + if vdu_params.get("volume"): + RO_vnf["vdus"][vdu_params["id"]]["devices"] = {} + for volume_params in vdu_params["volume"]: + RO_vnf["vdus"][vdu_params["id"]]["devices"][volume_params["name"]] = {} + if volume_params.get("vim-volume-id"): + RO_vnf["vdus"][vdu_params["id"]]["devices"][volume_params["name"]]["vim_id"] = \ + volume_params["vim-volume-id"] + if vdu_params.get("interface"): + RO_vnf["vdus"][vdu_params["id"]]["interfaces"] = {} + for interface_params in vdu_params["interface"]: + RO_interface = {} + RO_vnf["vdus"][vdu_params["id"]]["interfaces"][interface_params["name"]] = RO_interface + if interface_params.get("ip-address"): + RO_interface["ip_address"] = interface_params["ip-address"] + if interface_params.get("mac-address"): + RO_interface["mac_address"] = interface_params["mac-address"] + if interface_params.get("floating-ip-required"): + RO_interface["floating-ip"] = interface_params["floating-ip-required"] + if vnf_params.get("internal-vld"): + for internal_vld_params in vnf_params["internal-vld"]: + RO_vnf["networks"][internal_vld_params["name"]] = {} + if internal_vld_params.get("vim-network-name"): + RO_vnf["networks"][internal_vld_params["name"]]["vim-network-name"] = \ + internal_vld_params["vim-network-name"] + if internal_vld_params.get("ip-profile"): + RO_vnf["networks"][internal_vld_params["name"]]["ip-profile"] = \ + ip_profile_2_RO(internal_vld_params["ip-profile"]) + if internal_vld_params.get("internal-connection-point"): + for icp_params in internal_vld_params["internal-connection-point"]: + # look for interface + iface_found = False + for vdu_descriptor in vnf_descriptor["vdu"]: + for vdu_interface in vdu_descriptor["interface"]: + if vdu_interface.get("internal-connection-point-ref") == icp_params["id-ref"]: + if vdu_descriptor["id"] not in RO_vnf["vdus"]: + RO_vnf["vdus"][vdu_descriptor["id"]] = {} + if "interfaces" not in RO_vnf["vdus"][vdu_descriptor["id"]]: + RO_vnf["vdus"][vdu_descriptor["id"]]["interfaces"] = {} + RO_ifaces = RO_vnf["vdus"][vdu_descriptor["id"]]["interfaces"] + if vdu_interface["name"] not in RO_ifaces: + RO_ifaces[vdu_interface["name"]] = {} + + RO_ifaces[vdu_interface["name"]]["ip_address"] = icp_params["ip-address"] + iface_found = True + break + if iface_found: + break + else: + raise LcmException("Invalid instantiate parameter vnf:member-vnf-index[{}]:" + "internal-vld:id-ref={} is not present at vnfd:internal-" + "connection-point".format(vnf_params["member-vnf-index"], + icp_params["id-ref"])) + + if not RO_vnf["vdus"]: + del RO_vnf["vdus"] + if not RO_vnf["networks"]: + del RO_vnf["networks"] if RO_vnf: - RO_ns_params["vnfs"][vnf["member-vnf-index"]] = RO_vnf + RO_ns_params["vnfs"][vnf_params["member-vnf-index"]] = RO_vnf if ns_params.get("vld"): - for vld in ns_params["vld"]: + for vld_params in ns_params["vld"]: RO_vld = {} - if "ip-profile" in vld: - RO_vld["ip-profile"] = vld["ip-profile"] - if "vim-network-name" in vld: + if "ip-profile" in vld_params: + RO_vld["ip-profile"] = ip_profile_2_RO(vld_params["ip-profile"]) + if "vim-network-name" in vld_params: RO_vld["sites"] = [] - if isinstance(vld["vim-network-name"], dict): - for vim_account, vim_net in vld["vim-network-name"].items(): + if isinstance(vld_params["vim-network-name"], dict): + for vim_account, vim_net in vld_params["vim-network-name"].items(): RO_vld["sites"].append({ "netmap-use": vim_net, "datacenter": vim_account_2_RO(vim_account) }) else: # isinstance str - RO_vld["sites"].append({"netmap-use": vld["vim-network-name"]}) + RO_vld["sites"].append({"netmap-use": vld_params["vim-network-name"]}) if RO_vld: - RO_ns_params["networks"][vld["name"]] = RO_vld + RO_ns_params["networks"][vld_params["name"]] = RO_vld return RO_ns_params - def ns_update_vnfr(self, db_vnfrs, ns_RO_info): - """ - Updates database vnfr with the RO info, e.g. ip_address, vim_id... Descriptor db_vnfrs is also updated - :param db_vnfrs: - :param ns_RO_info: - :return: - """ - for vnf_index, db_vnfr in db_vnfrs.items(): - vnfr_deployed = ns_RO_info.get(vnf_index) - if not vnfr_deployed: - continue - vnfr_update = {} - db_vnfr["ip-address"] = vnfr_update["ip-address"] = vnfr_deployed.get("ip_address") - for index, vdur in enumerate(db_vnfr["vdur"]): - vdu_deployed = vnfr_deployed["vdur"].get(vdur["vdu-id-ref"]) - if not vdu_deployed: - continue - vnfr_update["vdur.{}.vim-id".format(index)] = vdu_deployed.get("vim_id") - db_vnfr["vdur"][index]["vim-id"] = vnfr_update["vdur.{}.vim-id".format(index)] - vnfr_update["vdur.{}.ip-address".format(index)] = vdu_deployed.get("ip_address") - db_vnfr["vdur"][index]["ip-address"] = vnfr_update["vdur.{}.ip-address".format(index)] - for index2, interface in enumerate(vdur["interfaces"]): - iface_deployed = vdu_deployed["interfaces"].get(interface["name"]) - if not iface_deployed: - continue - db_vnfr["vdur"][index]["interfaces"][index2]["vim-id"] =\ - vnfr_update["vdur.{}.interfaces.{}.vim-id".format(index, index2)] = iface_deployed.get("vim_id") - db_vnfr["vdur"][index]["interfaces"][index2]["ip-address"] =\ - vnfr_update["vdur.{}.interfaces.{}.ip-address".format(index, index2)] = iface_deployed.get( - "ip_address") - db_vnfr["vdur"][index]["interfaces"][index2]["mac-address"] =\ - vnfr_update["vdur.{}.interfaces.{}.mac-address".format(index, index2)] = iface_deployed.get( - "mac_address") - self.update_db_2("vnfrs", db_vnfr["_id"], vnfr_update) - - def ns_update_vnfr_2(self, db_vnfrs, nsr_desc_RO): + def ns_update_vnfr(self, db_vnfrs, nsr_desc_RO): """ Updates database vnfr with the RO info, e.g. ip_address, vim_id... Descriptor db_vnfrs is also updated :param db_vnfrs: @@ -799,7 +966,7 @@ class Lcm: break else: - raise LcmException("ns_update_vnfr_2: Not found member_vnf_index={} at RO info".format(vnf_index)) + raise LcmException("ns_update_vnfr: Not found member_vnf_index={} at RO info".format(vnf_index)) async def create_monitoring(self, nsr_id, vnf_member_index, vnfd_desc): if not vnfd_desc.get("scaling-group-descriptor"): @@ -862,6 +1029,7 @@ class Lcm: db_nslcmop = self.db.get_one("nslcmops", {"_id": nslcmop_id}) step = "Getting nsr={} from db".format(nsr_id) db_nsr = self.db.get_one("nsrs", {"_id": nsr_id}) + ns_params = db_nsr.get("instantiate_params") nsd = db_nsr["nsd"] nsr_name = db_nsr["name"] # TODO short-name?? needed_vnfd = {} @@ -961,7 +1129,24 @@ class Lcm: if not RO_nsr_id: step = db_nsr_update["detailed-status"] = "Creating ns at RO" # self.logger.debug(logging_text + step) - RO_ns_params = self.ns_params_2_RO(db_nsr.get("instantiate_params")) + + # check if VIM is creating and wait look if previous tasks in process + task_name, task_dependency = self.lcm_tasks.lookfor_related("vim_account", ns_params["vimAccountId"]) + if task_dependency: + step = "Waiting for related tasks to be completed: {}".format(task_name) + self.logger.debug(logging_text + step) + await asyncio.wait(task_dependency, timeout=3600) + if ns_params.get("vnf"): + for vnf in ns_params["vnf"]: + if "vimAccountId" in vnf: + task_name, task_dependency = self.lcm_tasks.lookfor_related("vim_account", + vnf["vimAccountId"]) + if task_dependency: + step = "Waiting for related tasks to be completed: {}".format(task_name) + self.logger.debug(logging_text + step) + await asyncio.wait(task_dependency, timeout=3600) + + RO_ns_params = self.ns_params_2_RO(ns_params, nsd, needed_vnfd) desc = await RO.create("ns", descriptor=RO_ns_params, name=db_nsr["name"], scenario=RO_nsd_uuid) @@ -1018,8 +1203,7 @@ class Lcm: raise ROclient.ROClientException("Timeout waiting ns to be ready") step = "Updating VNFRs" - # self.ns_update_vnfr(db_vnfrs, ns_RO_info) - self.ns_update_vnfr_2(db_vnfrs, desc) + self.ns_update_vnfr(db_vnfrs, desc) db_nsr["detailed-status"] = "Configuring vnfr" self.update_db_2("nsrs", nsr_id, db_nsr_update) @@ -1027,10 +1211,12 @@ class Lcm: # The parameters we'll need to deploy a charm number_to_configure = 0 - def deploy(): + def deploy(vnf_index, vdu_id, mgmt_ip_address, config_primitive=None): """An inner function to deploy the charm from either vnf or vdu + vnf_index is mandatory. vdu_id can be None for a vnf configuration or the id for vdu configuration """ - + if not mgmt_ip_address: + raise LcmException("vnfd/vdu has not management ip address to configure it") # Login to the VCA. # if number_to_configure == 0: # self.logger.debug("Logging into N2VC...") @@ -1052,19 +1238,26 @@ class Lcm: ) # Setup the runtime parameters for this VNF - params['rw_mgmt_ip'] = db_vnfrs[vnf_index]["ip-address"] + params = {'rw_mgmt_ip': mgmt_ip_address} + if config_primitive: + params["initial-config-primitive"] = config_primitive # ns_name will be ignored in the current version of N2VC # but will be implemented for the next point release. model_name = 'default' + vdu_id_text = "vnfd" + if vdu_id: + vdu_id_text = vdu_id application_name = self.n2vc.FormatApplicationName( nsr_name, vnf_index, - vnfd['name'], + vdu_id_text ) if not nsr_lcm.get("VCA"): nsr_lcm["VCA"] = {} - nsr_lcm["VCA"][vnf_index] = db_nsr_update["_admin.deployed.VCA.{}".format(vnf_index)] = { + nsr_lcm["VCA"][application_name] = db_nsr_update["_admin.deployed.VCA.{}".format(application_name)] = { + "member-vnf-index": vnf_index, + "vdu_id": vdu_id, "model": model_name, "application": application_name, "operational-status": "init", @@ -1086,13 +1279,12 @@ class Lcm: self.n2vc_callback, # Callback for status changes db_nsr, # Callback parameter db_nslcmop, - vnf_index, # Callback parameter None, # Callback parameter (task) ) ) task.add_done_callback(functools.partial(self.n2vc_callback, model_name, application_name, None, None, - db_nsr, db_nslcmop, vnf_index)) - self.lcm_ns_tasks[nsr_id][nslcmop_id]["create_charm:" + vnf_index] = task + db_nsr, db_nslcmop)) + self.lcm_tasks.register("ns", nsr_id, nslcmop_id, "create_charm:" + application_name, task) step = "Looking for needed vnfd to configure" self.logger.debug(logging_text + step) @@ -1107,36 +1299,39 @@ class Lcm: if vnf_config and vnf_config.get("juju"): proxy_charm = vnf_config["juju"]["charm"] - params = {} + config_primitive = None if proxy_charm: if 'initial-config-primitive' in vnf_config: - params['initial-config-primitive'] = vnf_config['initial-config-primitive'] + config_primitive = vnf_config['initial-config-primitive'] # Login to the VCA. If there are multiple calls to login(), # subsequent calls will be a nop and return immediately. step = "connecting to N2VC to configure vnf {}".format(vnf_index) await self.n2vc.login() - deploy() + deploy(vnf_index, None, db_vnfrs[vnf_index]["ip-address"], config_primitive) number_to_configure += 1 # Deploy charms for each VDU that supports one. + vdu_index = 0 for vdu in vnfd['vdu']: vdu_config = vdu.get('vdu-configuration') proxy_charm = None - params = {} + config_primitive = None if vdu_config and vdu_config.get("juju"): proxy_charm = vdu_config["juju"]["charm"] if 'initial-config-primitive' in vdu_config: - params['initial-config-primitive'] = vdu_config['initial-config-primitive'] + config_primitive = vdu_config['initial-config-primitive'] if proxy_charm: step = "connecting to N2VC to configure vdu {} from vnf {}".format(vdu["id"], vnf_index) await self.n2vc.login() - deploy() + deploy(vnf_index, vdu["id"], db_vnfrs[vnf_index]["vdur"][vdu_index]["ip-address"], + config_primitive) number_to_configure += 1 + vdu_index += 1 if number_to_configure: db_nsr_update["config-status"] = "configuring" @@ -1184,6 +1379,7 @@ class Lcm: self.update_db_2("nsrs", nsr_id, db_nsr_update) if db_nslcmop_update: self.update_db_2("nslcmops", nslcmop_id, db_nslcmop_update) + self.lcm_tasks.remove("ns", nsr_id, nslcmop_id, "ns_instantiate") async def ns_terminate(self, nsr_id, nslcmop_id): logging_text = "Task ns={} terminate={} ".format(nsr_id, nslcmop_id) @@ -1219,24 +1415,23 @@ class Lcm: db_nsr_update["detailed-status"] = "Deleting charms" self.logger.debug(logging_text + step) self.update_db_2("nsrs", nsr_id, db_nsr_update) - for vnf_index, deploy_info in nsr_lcm["VCA"].items(): - if deploy_info and deploy_info.get("application"): + for application_name, deploy_info in nsr_lcm["VCA"].items(): + if deploy_info: # TODO it would be desirable having a and deploy_info.get("deployed"): task = asyncio.ensure_future( self.n2vc.RemoveCharms( deploy_info['model'], - deploy_info['application'], + application_name, # self.n2vc_callback, # db_nsr, # db_nslcmop, - # vnf_index, ) ) vca_task_list.append(task) - vca_task_dict[vnf_index] = task + vca_task_dict[application_name] = task # task.add_done_callback(functools.partial(self.n2vc_callback, deploy_info['model'], # deploy_info['application'], None, db_nsr, # db_nslcmop, vnf_index)) - self.lcm_ns_tasks[nsr_id][nslcmop_id]["delete_charm:" + vnf_index] = task + self.lcm_ns_tasks[nsr_id][nslcmop_id]["delete_charm:" + application_name] = task except Exception as e: self.logger.debug(logging_text + "Failed while deleting charms: {}".format(e)) @@ -1315,19 +1510,19 @@ class Lcm: self.update_db_2("nslcmops", nslcmop_id, db_nslcmop_update) self.update_db_2("nsrs", nsr_id, db_nsr_update) await asyncio.wait(vca_task_list, timeout=300) - for vnf_index, task in vca_task_dict.items(): + for application_name, task in vca_task_dict.items(): if task.cancelled(): - failed_detail.append("VCA[{}] Deletion has been cancelled".format(vnf_index)) + failed_detail.append("VCA[{}] Deletion has been cancelled".format(application_name)) elif task.done(): exc = task.exception() if exc: - failed_detail.append("VCA[{}] Deletion exception: {}".format(vnf_index, exc)) + failed_detail.append("VCA[{}] Deletion exception: {}".format(application_name, exc)) else: - db_nsr_update["_admin.deployed.VCA.{}".format(vnf_index)] = None + db_nsr_update["_admin.deployed.VCA.{}".format(application_name)] = None else: # timeout # TODO Should it be cancelled?!! task.cancel() - failed_detail.append("VCA[{}] Deletion timeout".format(vnf_index)) + failed_detail.append("VCA[{}] Deletion timeout".format(application_name)) if failed_detail: self.logger.error(logging_text + " ;".join(failed_detail)) @@ -1376,11 +1571,22 @@ class Lcm: self.update_db_2("nslcmops", nslcmop_id, db_nslcmop_update) if db_nsr_update: self.update_db_2("nsrs", nsr_id, db_nsr_update) + self.lcm_tasks.remove("ns", nsr_id, nslcmop_id, "ns_terminate") - async def _ns_execute_primitive(self, db_deployed, member_vnf_index, primitive, primitive_params): - vca_deployed = db_deployed["VCA"].get(member_vnf_index) + async def _ns_execute_primitive(self, db_deployed, nsr_name, member_vnf_index, vdu_id, primitive, primitive_params): + + vdu_id_text = "vnfd" + if vdu_id: + vdu_id_text = vdu_id + application_name = self.n2vc.FormatApplicationName( + nsr_name, + member_vnf_index, + vdu_id_text + ) + vca_deployed = db_deployed["VCA"].get(application_name) if not vca_deployed: - raise LcmException("charm for member_vnf_index={} is not deployed".format(member_vnf_index)) + raise LcmException("charm for member_vnf_index={} vdu_id={} is not deployed".format(member_vnf_index, + vdu_id)) model_name = vca_deployed.get("model") application_name = vca_deployed.get("application") if not model_name or not application_name: @@ -1437,12 +1643,15 @@ class Lcm: db_nslcmop = self.db.get_one("nslcmops", {"_id": nslcmop_id}) db_nsr = self.db.get_one("nsrs", {"_id": nsr_id}) nsr_lcm = db_nsr["_admin"].get("deployed") + nsr_name = db_nsr["name"] vnf_index = db_nslcmop["operationParams"]["member_vnf_index"] + vdu_id = db_nslcmop["operationParams"].get("vdu_id") # TODO check if ns is in a proper status primitive = db_nslcmop["operationParams"]["primitive"] primitive_params = db_nslcmop["operationParams"]["primitive_params"] - result, result_detail = await self._ns_execute_primitive(nsr_lcm, vnf_index, primitive, primitive_params) + result, result_detail = await self._ns_execute_primitive(nsr_lcm, nsr_name, vnf_index, vdu_id, primitive, + primitive_params) db_nslcmop_update = { "detailed-status": result_detail, "operationState": result, @@ -1469,6 +1678,7 @@ class Lcm: } if db_nslcmop_update: self.update_db_2("nslcmops", nslcmop_id, db_nslcmop_update) + self.lcm_tasks.remove("ns", nsr_id, nslcmop_id, "ns_action") async def ns_scale(self, nsr_id, nslcmop_id): logging_text = "Task ns={} scale={} ".format(nsr_id, nslcmop_id) @@ -1485,12 +1695,14 @@ class Lcm: step = "Getting nsr from database" db_nsr = self.db.get_one("nsrs", {"_id": nsr_id}) step = "Parsing scaling parameters" + db_nsr_update["operational-status"] = "scaling" + self.update_db_2("nsrs", nsr_id, db_nsr_update) nsr_lcm = db_nsr["_admin"].get("deployed") RO_nsr_id = nsr_lcm["RO"]["nsr_id"] vnf_index = db_nslcmop["operationParams"]["scaleVnfData"]["scaleByStepData"]["member-vnf-index"] scaling_group = db_nslcmop["operationParams"]["scaleVnfData"]["scaleByStepData"]["scaling-group-descriptor"] scaling_type = db_nslcmop["operationParams"]["scaleVnfData"]["scaleVnfType"] - scaling_policy = db_nslcmop["operationParams"]["scaleVnfData"]["scaleByStepData"].get("scaling-policy") + # scaling_policy = db_nslcmop["operationParams"]["scaleVnfData"]["scaleByStepData"].get("scaling-policy") step = "Getting vnfr from database" db_vnfr = self.db.get_one("vnfrs", {"member-vnf-index-ref": vnf_index, "nsr-id-ref": nsr_id}) @@ -1503,11 +1715,11 @@ class Lcm: else: raise LcmException("input parameter 'scaleByStepData':'scaling-group-descriptor':'{}' is not present " "at vnfd:scaling-group-descriptor".format(scaling_group)) - cooldown_time = 0 - for scaling_policy_descriptor in scaling_descriptor.get("scaling-policy", ()): - cooldown_time = scaling_policy_descriptor.get("cooldown-time", 0) - if scaling_policy and scaling_policy == scaling_policy_descriptor.get("name"): - break + # cooldown_time = 0 + # for scaling_policy_descriptor in scaling_descriptor.get("scaling-policy", ()): + # cooldown_time = scaling_policy_descriptor.get("cooldown-time", 0) + # if scaling_policy and scaling_policy == scaling_policy_descriptor.get("name"): + # break # TODO check if ns is in a proper status step = "Sending scale order to RO" @@ -1660,8 +1872,7 @@ class Lcm: raise ROclient.ROClientException("Timeout waiting ns to be ready") step = "Updating VNFRs" - # self.ns_update_vnfr({db_vnfr["member-vnf-index-ref"]: db_vnfr}, ns_RO_info) - self.ns_update_vnfr_2({db_vnfr["member-vnf-index-ref"]: db_vnfr}, desc) + self.ns_update_vnfr({db_vnfr["member-vnf-index-ref"]: db_vnfr}, desc) # update VDU_SCALING_INFO with the obtained ip_addresses if vdu_scaling_info["scaling_direction"] == "OUT": @@ -1720,11 +1931,12 @@ class Lcm: db_nslcmop_update["statusEnteredTime"] = time() db_nslcmop_update["detailed-status"] = "done" db_nsr_update["detailed-status"] = "done" + db_nsr_update["operational-status"] = "running" try: await self.msg.aiowrite("ns", "scaled", {"nsr_id": nsr_id, "nslcmop_id": nslcmop_id}) - if cooldown_time: - await asyncio.sleep(cooldown_time) - await self.msg.aiowrite("ns", "scaled-cooldown-time", {"nsr_id": nsr_id, "nslcmop_id": nslcmop_id}) + # if cooldown_time: + # await asyncio.sleep(cooldown_time) + # await self.msg.aiowrite("ns", "scaled-cooldown-time", {"nsr_id": nsr_id, "nslcmop_id": nslcmop_id}) except Exception as e: self.logger.error(logging_text + "kafka_write notification Exception {}".format(e)) self.logger.debug(logging_text + "Exit Ok") @@ -1740,44 +1952,24 @@ class Lcm: self.logger.critical(logging_text + "Exit Exception {} {}".format(type(e).__name__, e), exc_info=True) finally: if exc: - db_nsr_update = None if db_nslcmop: db_nslcmop_update = { "detailed-status": "FAILED {}: {}".format(step, exc), "operationState": "FAILED", "statusEnteredTime": time(), } + if db_nsr: + db_nsr_update["operational-status"] = "FAILED {}: {}".format(step, exc), + db_nsr_update["detailed-status"] = "failed" if db_nslcmop_update: self.update_db_2("nslcmops", nslcmop_id, db_nslcmop_update) if db_nsr_update: self.update_db_2("nsrs", nsr_id, db_nsr_update) + self.lcm_tasks.remove("ns", nsr_id, nslcmop_id, "ns_scale") async def test(self, param=None): self.logger.debug("Starting/Ending test task: {}".format(param)) - def cancel_tasks(self, topic, _id): - """ - Cancel all active tasks of a concrete nsr or vim identified for _id - :param topic: can be ns or vim_account - :param _id: nsr or vim identity - :return: None, or raises an exception if not possible - """ - if topic == "ns": - lcm_tasks = self.lcm_ns_tasks - elif topic == "vim_account": - lcm_tasks = self.lcm_vim_tasks - elif topic == "sdn": - lcm_tasks = self.lcm_sdn_tasks - - if not lcm_tasks.get(_id): - return - for order_id, tasks_set in lcm_tasks[_id].items(): - for task_name, task in tasks_set.items(): - result = task.cancel() - if result: - self.logger.debug("{} _id={} order_id={} task={} cancelled".format(topic, _id, order_id, task_name)) - lcm_tasks[_id] = {} - async def kafka_ping(self): self.logger.debug("Task kafka_ping Enter") consecutive_errors = 0 @@ -1850,20 +2042,16 @@ class Lcm: nslcmop_id = nslcmop["_id"] nsr_id = nslcmop["nsInstanceId"] task = asyncio.ensure_future(self.ns_instantiate(nsr_id, nslcmop_id)) - if nsr_id not in self.lcm_ns_tasks: - self.lcm_ns_tasks[nsr_id] = {} - self.lcm_ns_tasks[nsr_id][nslcmop_id] = {"ns_instantiate": task} + self.lcm_tasks.register("ns", nsr_id, nslcmop_id, "ns_instantiate", task) continue elif command == "terminate": # self.logger.debug("Deleting NS {}".format(nsr_id)) nslcmop = params nslcmop_id = nslcmop["_id"] nsr_id = nslcmop["nsInstanceId"] - self.cancel_tasks(topic, nsr_id) + self.lcm_tasks.cancel(topic, nsr_id) task = asyncio.ensure_future(self.ns_terminate(nsr_id, nslcmop_id)) - if nsr_id not in self.lcm_ns_tasks: - self.lcm_ns_tasks[nsr_id] = {} - self.lcm_ns_tasks[nsr_id][nslcmop_id] = {"ns_terminate": task} + self.lcm_tasks.register("ns", nsr_id, nslcmop_id, "ns_terminate", task) continue elif command == "action": # self.logger.debug("Update NS {}".format(nsr_id)) @@ -1871,9 +2059,7 @@ class Lcm: nslcmop_id = nslcmop["_id"] nsr_id = nslcmop["nsInstanceId"] task = asyncio.ensure_future(self.ns_action(nsr_id, nslcmop_id)) - if nsr_id not in self.lcm_ns_tasks: - self.lcm_ns_tasks[nsr_id] = {} - self.lcm_ns_tasks[nsr_id][nslcmop_id] = {"ns_action": task} + self.lcm_tasks.register("ns", nsr_id, nslcmop_id, "ns_action", task) continue elif command == "scale": # self.logger.debug("Update NS {}".format(nsr_id)) @@ -1881,9 +2067,7 @@ class Lcm: nslcmop_id = nslcmop["_id"] nsr_id = nslcmop["nsInstanceId"] task = asyncio.ensure_future(self.ns_scale(nsr_id, nslcmop_id)) - if nsr_id not in self.lcm_ns_tasks: - self.lcm_ns_tasks[nsr_id] = {} - self.lcm_ns_tasks[nsr_id][nslcmop_id] = {"ns_scale": task} + self.lcm_tasks.register("ns", nsr_id, nslcmop_id, "ns_scale", task) continue elif command == "show": try: @@ -1899,20 +2083,18 @@ class Lcm: continue elif command == "deleted": continue # TODO cleaning of task just in case should be done + elif command in ("terminated", "instantiated", "scaled", "actioned"): # "scaled-cooldown-time" + continue elif topic == "vim_account": vim_id = params["_id"] if command == "create": task = asyncio.ensure_future(self.vim_create(params, order_id)) - if vim_id not in self.lcm_vim_tasks: - self.lcm_vim_tasks[vim_id] = {} - self.lcm_vim_tasks[vim_id][order_id] = {"vim_create": task} + self.lcm_tasks.register("vim_account", vim_id, order_id, "vim_create", task) continue elif command == "delete": - self.cancel_tasks(topic, vim_id) + self.lcm_tasks.cancel(topic, vim_id) task = asyncio.ensure_future(self.vim_delete(vim_id, order_id)) - if vim_id not in self.lcm_vim_tasks: - self.lcm_vim_tasks[vim_id] = {} - self.lcm_vim_tasks[vim_id][order_id] = {"vim_delete": task} + self.lcm_tasks.register("vim_account", vim_id, order_id, "vim_delete", task) continue elif command == "show": print("not implemented show with vim_account") @@ -1920,30 +2102,22 @@ class Lcm: continue elif command == "edit": task = asyncio.ensure_future(self.vim_edit(params, order_id)) - if vim_id not in self.lcm_vim_tasks: - self.lcm_vim_tasks[vim_id] = {} - self.lcm_vim_tasks[vim_id][order_id] = {"vim_edit": task} + self.lcm_tasks.register("vim_account", vim_id, order_id, "vim_edit", task) continue elif topic == "sdn": _sdn_id = params["_id"] if command == "create": task = asyncio.ensure_future(self.sdn_create(params, order_id)) - if _sdn_id not in self.lcm_sdn_tasks: - self.lcm_sdn_tasks[_sdn_id] = {} - self.lcm_sdn_tasks[_sdn_id][order_id] = {"sdn_create": task} + self.lcm_tasks.register("sdn", _sdn_id, order_id, "sdn_create", task) continue elif command == "delete": - self.cancel_tasks(topic, _sdn_id) + self.lcm_tasks.cancel(topic, _sdn_id) task = asyncio.ensure_future(self.sdn_delete(_sdn_id, order_id)) - if _sdn_id not in self.lcm_sdn_tasks: - self.lcm_sdn_tasks[_sdn_id] = {} - self.lcm_sdn_tasks[_sdn_id][order_id] = {"sdn_delete": task} + self.lcm_tasks.register("sdn", _sdn_id, order_id, "sdn_delete", task) continue elif command == "edit": task = asyncio.ensure_future(self.sdn_edit(params, order_id)) - if _sdn_id not in self.lcm_sdn_tasks: - self.lcm_sdn_tasks[_sdn_id] = {} - self.lcm_sdn_tasks[_sdn_id][order_id] = {"sdn_edit": task} + self.lcm_tasks.register("sdn", _sdn_id, order_id, "sdn_edit", task) continue self.logger.critical("unknown topic {} and command '{}'".format(topic, command)) except Exception as e: @@ -1972,14 +2146,14 @@ class Lcm: )) # TODO # self.logger.debug("Terminating cancelling creation tasks") - # self.cancel_tasks("ALL", "create") + # self.lcm_tasks.cancel("ALL", "create") # timeout = 200 # while self.is_pending_tasks(): # self.logger.debug("Task kafka_read terminating. Waiting for tasks termination") # await asyncio.sleep(2, loop=self.loop) # timeout -= 2 # if not timeout: - # self.cancel_tasks("ALL", "ALL") + # self.lcm_tasks.cancel("ALL", "ALL") self.loop.close() self.loop = None if self.db: