+ step = "Creating vim at RO"
+ RO = ROclient.ROClient(self.loop, **self.ro_config)
+ vim_RO = deepcopy(vim_content)
+ vim_RO.pop("_id", None)
+ vim_RO.pop("_admin", None)
+ vim_RO.pop("schema_version", None)
+ vim_RO.pop("schema_type", None)
+ vim_RO.pop("vim_tenant_name", None)
+ vim_RO["type"] = vim_RO.pop("vim_type")
+ vim_RO.pop("vim_user", None)
+ vim_RO.pop("vim_password", None)
+ desc = await RO.create("vim", descriptor=vim_RO)
+ RO_vim_id = desc["uuid"]
+ db_vim["_admin"]["deploy"]["RO"] = RO_vim_id
+ self.update_db("vims", vim_id, db_vim)
+
+ step = "Attach vim to RO tenant"
+ vim_RO = {"vim_tenant_name": vim_content["vim_tenant_name"],
+ "vim_username": vim_content["vim_user"],
+ "vim_password": vim_content["vim_password"],
+ "config": vim_content["config"]
+ }
+ desc = await RO.attach_datacenter(RO_vim_id , descriptor=vim_RO)
+ db_vim["_admin"]["operationalState"] = "ENABLED"
+ self.update_db("vims", vim_id, db_vim)
+
+ self.logger.debug(logging_text + "Exit Ok RO_vim_id".format(RO_vim_id))
+ return RO_vim_id
+
+ except (ROclient.ROClientException, DbException) as e:
+ self.logger.error(logging_text + "Exit Exception {}".format(e))
+ exc = e
+ except Exception as e:
+ self.logger.critical(logging_text + "Exit Exception {}".format(e), exc_info=True)
+ 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("vims", vim_id, db_vim)
+
+ async def edit_vim(self, vim_content, order_id):
+ vim_id = vim_content["_id"]
+ logging_text = "Task edit_vim={} ".format(vim_id)
+ self.logger.debug(logging_text + "Enter")
+ db_vim = None
+ exc = None
+ step = "Getting vim from db"
+ try:
+ db_vim = self.db.get_one("vims", {"_id": vim_id})
+ if db_vim.get("_admin") and db_vim["_admin"].get("deploy") and db_vim["_admin"]["deploy"].get("RO"):
+ RO_vim_id = db_vim["_admin"]["deploy"]["RO"]
+ step = "Editing vim at RO"
+ RO = ROclient.ROClient(self.loop, **self.ro_config)
+ vim_RO = deepcopy(vim_content)
+ vim_RO.pop("_id", None)
+ vim_RO.pop("_admin", None)
+ vim_RO.pop("schema_version", None)
+ vim_RO.pop("schema_type", None)
+ vim_RO.pop("vim_tenant_name", None)
+ vim_RO["type"] = vim_RO.pop("vim_type")
+ vim_RO.pop("vim_user", None)
+ vim_RO.pop("vim_password", None)
+ if vim_RO:
+ desc = await RO.edit("vim", RO_vim_id, descriptor=vim_RO)
+
+ step = "Editing vim-account at RO tenant"
+ vim_RO = {}
+ for k in ("vim_tenant_name", "vim_password", "config"):
+ if k in vim_content:
+ vim_RO[k] = vim_content[k]
+ if "vim_user" in vim_content:
+ vim_content["vim_username"] = vim_content["vim_user"]
+ if vim_RO:
+ desc = await RO.edit("vim_account", RO_vim_id, descriptor=vim_RO)
+ db_vim["_admin"]["operationalState"] = "ENABLED"
+ self.update_db("vims", vim_id, db_vim)
+
+ self.logger.debug(logging_text + "Exit Ok RO_vim_id".format(RO_vim_id))
+ return RO_vim_id
+
+ except (ROclient.ROClientException, DbException) as e:
+ self.logger.error(logging_text + "Exit Exception {}".format(e))
+ exc = e
+ except Exception as e:
+ self.logger.critical(logging_text + "Exit Exception {}".format(e), exc_info=True)
+ 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("vims", vim_id, db_vim)
+
+ async def delete_vim(self, vim_id, order_id):
+ logging_text = "Task delete_vim={} ".format(vim_id)
+ self.logger.debug(logging_text + "Enter")
+ db_vim = None
+ exc = None
+ step = "Getting vim from db"
+ try:
+ db_vim = self.db.get_one("vims", {"_id": vim_id})
+ if db_vim.get("_admin") and db_vim["_admin"].get("deploy") and db_vim["_admin"]["deploy"].get("RO"):
+ RO_vim_id = db_vim["_admin"]["deploy"]["RO"]
+ RO = ROclient.ROClient(self.loop, **self.ro_config)
+ step = "Detaching vim from RO tenant"
+ try:
+ await RO.detach_datacenter(RO_vim_id)
+ except ROclient.ROClientException as e:
+ if e.http_code == 404: # not found
+ self.logger.debug(logging_text + "RO_vim_id={} already detached".format(RO_vim_id))
+ else:
+ raise
+
+ step = "Deleting vim from RO"
+ try:
+ await RO.delete("vim", RO_vim_id)
+ except ROclient.ROClientException as e:
+ if e.http_code == 404: # not found
+ self.logger.debug(logging_text + "RO_vim_id={} already deleted".format(RO_vim_id))
+ else:
+ raise
+ else:
+ # nothing to delete
+ self.logger.error(logging_text + "Skipping. There is not RO information at database")
+ self.db.del_one("vims", {"_id": vim_id})
+ self.logger.debug("delete_vim task vim_id={} Exit Ok".format(vim_id))
+ return None
+
+ except (ROclient.ROClientException, DbException) as e:
+ self.logger.error(logging_text + "Exit Exception {}".format(e))
+ exc = e
+ except Exception as e:
+ self.logger.critical(logging_text + "Exit Exception {}".format(e), exc_info=True)
+ 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("vims", vim_id, db_vim)
+
+ async def create_sdn(self, sdn_content, order_id):
+ sdn_id = sdn_content["_id"]
+ logging_text = "Task create_sdn={} ".format(sdn_id)
+ self.logger.debug(logging_text + "Enter")
+ db_sdn = 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 "deploy" not in db_sdn["_admin"]:
+ db_sdn["_admin"]["deploy"] = {}
+ db_sdn["_admin"]["deploy"]["RO"] = None
+
+ step = "Creating sdn at RO"
+ RO = ROclient.ROClient(self.loop, **self.ro_config)
+ sdn_RO = deepcopy(sdn_content)
+ sdn_RO.pop("_id", None)
+ sdn_RO.pop("_admin", None)
+ sdn_RO.pop("schema_version", None)
+ sdn_RO.pop("schema_type", None)
+ desc = await RO.create("sdn", descriptor=sdn_RO)
+ RO_sdn_id = desc["uuid"]
+ db_sdn["_admin"]["deploy"]["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
+
+ except (ROclient.ROClientException, DbException) as e:
+ self.logger.error(logging_text + "Exit Exception {}".format(e))
+ exc = e
+ except Exception as e:
+ self.logger.critical(logging_text + "Exit Exception {}".format(e), exc_info=True)
+ 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)
+
+ async def edit_sdn(self, sdn_content, order_id):
+ sdn_id = sdn_content["_id"]
+ logging_text = "Task edit_sdn={} ".format(sdn_id)
+ self.logger.debug(logging_text + "Enter")
+ db_sdn = None
+ exc = None
+ step = "Getting sdn from db"
+ try:
+ db_sdn = self.db.get_one("sdns", {"_id": sdn_id})
+ if db_sdn.get("_admin") and db_sdn["_admin"].get("deploy") and db_sdn["_admin"]["deploy"].get("RO"):
+ RO_sdn_id = db_sdn["_admin"]["deploy"]["RO"]
+ RO = ROclient.ROClient(self.loop, **self.ro_config)
+ step = "Editing sdn at RO"
+ sdn_RO = deepcopy(sdn_content)
+ sdn_RO.pop("_id", None)
+ sdn_RO.pop("_admin", None)
+ sdn_RO.pop("schema_version", None)
+ sdn_RO.pop("schema_type", None)
+ if sdn_RO:
+ desc = await RO.edit("sdn", RO_sdn_id, descriptor=sdn_RO)
+ 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
+
+ except (ROclient.ROClientException, DbException) as e:
+ self.logger.error(logging_text + "Exit Exception {}".format(e))
+ exc = e
+ except Exception as e:
+ self.logger.critical(logging_text + "Exit Exception {}".format(e), exc_info=True)
+ 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)
+
+ async def delete_sdn(self, sdn_id, order_id):
+ logging_text = "Task delete_sdn={} ".format(sdn_id)
+ self.logger.debug(logging_text + "Enter")
+ db_sdn = None
+ exc = None
+ step = "Getting sdn from db"
+ try:
+ db_sdn = self.db.get_one("sdns", {"_id": sdn_id})
+ if db_sdn.get("_admin") and db_sdn["_admin"].get("deploy") and db_sdn["_admin"]["deploy"].get("RO"):
+ RO_sdn_id = db_sdn["_admin"]["deploy"]["RO"]
+ RO = ROclient.ROClient(self.loop, **self.ro_config)
+ step = "Deleting sdn from RO"
+ try:
+ await RO.delete("sdn", RO_sdn_id)
+ except ROclient.ROClientException as e:
+ if e.http_code == 404: # not found
+ self.logger.debug(logging_text + "RO_sdn_id={} already deleted".format(RO_sdn_id))
+ else:
+ raise
+ else:
+ # nothing to delete
+ self.logger.error(logging_text + "Skipping. There is not RO information at database")
+ self.db.del_one("sdns", {"_id": sdn_id})
+ self.logger.debug("delete_sdn task sdn_id={} Exit Ok".format(sdn_id))
+ return None
+
+ except (ROclient.ROClientException, DbException) as e:
+ self.logger.error(logging_text + "Exit Exception {}".format(e))
+ exc = e
+ except Exception as e:
+ self.logger.critical(logging_text + "Exit Exception {}".format(e), exc_info=True)
+ 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)
+
+ def vnfd2RO(self, vnfd, new_id=None):
+ """
+ Converts creates a new vnfd descriptor for RO base on input OSM IM vnfd
+ :param vnfd: input vnfd
+ :param new_id: overrides vnf id if provided
+ :return: copy of vnfd
+ """
+ ci_file = None
+ try:
+ vnfd_RO = deepcopy(vnfd)
+ vnfd_RO.pop("_id", None)
+ vnfd_RO.pop("_admin", None)
+ if new_id:
+ vnfd_RO["id"] = new_id
+ for vdu in vnfd_RO["vdu"]:
+ if "cloud-init-file" in vdu:
+ base_folder = vnfd["_admin"]["storage"]
+ clout_init_file = "{}/{}/cloud_init/{}".format(
+ base_folder["folder"],
+ base_folder["pkg-dir"],
+ vdu["cloud-init-file"]
+ )
+ ci_file = self.fs.file_open(clout_init_file, "r")
+ # TODO: detect if binary or text. Propose to read as binary and try to decode to utf8. If fails convert to base 64 or similar
+ clout_init_content = ci_file.read()
+ ci_file.close()
+ ci_file = None
+ vdu.pop("cloud-init-file", None)
+ vdu["cloud-init"] = clout_init_content
+ return vnfd_RO
+ except FsException as e:
+ raise LcmException("Error reading file at vnfd {}: {} ".format(vnfd["_id"], e))
+ finally:
+ if ci_file:
+ ci_file.close()
+
+ def n2vc_callback(self, model_name, application_name, workload_status, db_nsr, vnf_member_index, task=None):
+ """Update the lcm database with the status of the charm.
+
+ Updates the VNF's operational status with the state of the charm:
+ - blocked: The unit needs manual intervention
+ - maintenance: The unit is actively deploying/configuring
+ - waiting: The unit is waiting for another charm to be ready
+ - active: The unit is deployed, configured, and ready
+ - error: The charm has failed and needs attention.
+ - terminated: The charm has been destroyed
+ - removing,
+ - removed
+
+ Updates the network service's config-status to reflect the state of all
+ charms.
+ """
+ nsr_id = None
+ try:
+ nsr_id = db_nsr["_id"]
+ nsr_lcm = db_nsr["_admin"]["deploy"]
+ if task:
+ if task.cancelled():
+ self.logger.debug("[n2vc_callback] create_ns={} vnf_index={} task Cancelled".format(nsr_id, vnf_member_index))
+ return
+
+ if task.done():
+ exc = task.exception()
+ if exc:
+ self.logger.error(
+ "[n2vc_callback] create_ns={} vnf_index={} task Exception={}".format(nsr_id, vnf_member_index, exc))
+ nsr_lcm["VCA"][vnf_member_index]['operational-status'] = "error"
+ nsr_lcm["VCA"][vnf_member_index]['detailed-status'] = str(exc)
+ else:
+ self.logger.debug("[n2vc_callback] create_ns={} vnf_index={} task Done".format(nsr_id, vnf_member_index))
+ # TODO it seams that task Done, but callback is still ongoing. For the moment comment this two lines
+ # nsr_lcm["VCA"][vnf_member_index]['operational-status'] = "active"
+ # nsr_lcm["VCA"][vnf_member_index]['detailed-status'] = ""
+ elif workload_status:
+ self.logger.debug("[n2vc_callback] create_ns={} vnf_index={} Enter workload_status={}".format(nsr_id, vnf_member_index, workload_status))
+ if nsr_lcm["VCA"][vnf_member_index]['operational-status'] == workload_status:
+ return # same status, ignore
+ nsr_lcm["VCA"][vnf_member_index]['operational-status'] = workload_status
+ # TODO N2VC some error message in case of error should be obtained from N2VC
+ nsr_lcm["VCA"][vnf_member_index]['detailed-status'] = ""
+ else:
+ self.logger.critical("[n2vc_callback] create_ns={} vnf_index={} Enter with bad parameters".format(nsr_id, vnf_member_index), exc_info=True)
+ return
+
+ some_failed = False
+ all_active = True
+ status_map = {}
+ for vnf_index, vca_info in nsr_lcm["VCA"].items():
+ vca_status = vca_info["operational-status"]
+ if vca_status not in status_map:
+ # Initialize it
+ status_map[vca_status] = 0
+ status_map[vca_status] += 1
+
+ if vca_status != "active":
+ all_active = False
+ if vca_status == "error":
+ some_failed = True
+ db_nsr["config-status"] = "failed"
+ db_nsr["detailed-status"] = "fail configuring vnf_index={} {}".format(vnf_member_index,
+ vca_info["detailed-status"])
+ break
+
+ if all_active:
+ self.logger.debug("[n2vc_callback] create_ns={} vnf_index={} All active".format(nsr_id, vnf_member_index))
+ db_nsr["config-status"] = "configured"
+ db_nsr["detailed-status"] = "done"
+ elif some_failed:
+ pass
+ else:
+ cs = "configuring: "
+ separator = ""
+ for status, num in status_map.items():
+ cs += separator + "{}: {}".format(status, num)
+ separator = ", "
+ db_nsr["config-status"] = cs
+ self.update_db("nsrs", nsr_id, db_nsr)
+
+ except Exception as e:
+ self.logger.critical("[n2vc_callback] create_ns={} vnf_index={} Exception {}".format(nsr_id, vnf_member_index, e), exc_info=True)
+
+ async def create_ns(self, nsr_id, order_id):
+ logging_text = "Task create_ns={} ".format(nsr_id)
+ self.logger.debug(logging_text + "Enter")
+ # get all needed from database
+ db_nsr = None
+ exc = None
+ step = "Getting nsr from db"
+ try:
+ db_nsr = self.db.get_one("nsrs", {"_id": nsr_id})
+ nsd = db_nsr["nsd"]
+ nsr_name = db_nsr["name"] # TODO short-name??
+ needed_vnfd = {}
projects / osm / RO.git / blobdiff