import logging.handlers
import traceback
import json
-from jinja2 import Environment, Template, meta, TemplateError, TemplateNotFound, TemplateSyntaxError
+from jinja2 import Environment, TemplateError, TemplateNotFound, StrictUndefined, UndefinedError
from osm_lcm import ROclient
from osm_lcm.ng_ro import NgRoClient, NgRoException
from osm_lcm.lcm_utils import LcmException, LcmExceptionNoMgmtIP, LcmBase, deep_get, get_iterable, populate_dict
+from osm_lcm.data_utils.nsd import get_vnf_profiles
+from osm_lcm.data_utils.vnfd import get_vnf_configuration, get_vdu_list, get_vdu_profile, \
+ get_ee_sorted_initial_config_primitive_list, get_ee_sorted_terminate_config_primitive_list, \
+ get_kdu_list, get_virtual_link_profiles, get_vdu, get_vdu_configuration, get_kdu_configuration, \
+ get_vdu_index, get_scaling_aspect, get_number_of_instances
+from osm_lcm.data_utils.list_utils import find_in_list
+from osm_lcm.data_utils.vnfr import get_osm_params
+from osm_lcm.data_utils.dict_utils import parse_yaml_strings
+from osm_lcm.data_utils.database.vim_account import VimAccountDB
from n2vc.k8s_helm_conn import K8sHelmConnector
+from n2vc.k8s_helm3_conn import K8sHelm3Connector
from n2vc.k8s_juju_conn import K8sJujuConnector
from osm_common.dbbase import DbException
from osm_common.fsbase import FsException
+from osm_lcm.data_utils.database.database import Database
+from osm_lcm.data_utils.filesystem.filesystem import Filesystem
+
from n2vc.n2vc_juju_conn import N2VCJujuConnector
from n2vc.exceptions import N2VCException, N2VCNotFound, K8sException
from osm_lcm.lcm_helm_conn import LCMHelmConn
from copy import copy, deepcopy
-from http import HTTPStatus
from time import time
from uuid import uuid4
-from functools import partial
+
from random import randint
__author__ = "Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>"
-class N2VCJujuConnectorLCM(N2VCJujuConnector):
-
- async def create_execution_environment(self, namespace: str, db_dict: dict, reuse_ee_id: str = None,
- progress_timeout: float = None, total_timeout: float = None,
- config: dict = None, artifact_path: str = None,
- vca_type: str = None) -> (str, dict):
- # admit two new parameters, artifact_path and vca_type
- if vca_type == "k8s_proxy_charm":
- ee_id = await self.n2vc.install_k8s_proxy_charm(
- charm_name=artifact_path[artifact_path.rfind("/") + 1:],
- namespace=namespace,
- artifact_path=artifact_path,
- db_dict=db_dict)
- return ee_id, None
- else:
- return await super().create_execution_environment(
- namespace=namespace, db_dict=db_dict, reuse_ee_id=reuse_ee_id,
- progress_timeout=progress_timeout, total_timeout=total_timeout)
-
- async def install_configuration_sw(self, ee_id: str, artifact_path: str, db_dict: dict,
- progress_timeout: float = None, total_timeout: float = None,
- config: dict = None, num_units: int = 1, vca_type: str = "lxc_proxy_charm"):
- if vca_type == "k8s_proxy_charm":
- return
- return await super().install_configuration_sw(
- ee_id=ee_id, artifact_path=artifact_path, db_dict=db_dict, progress_timeout=progress_timeout,
- total_timeout=total_timeout, config=config, num_units=num_units)
-
-
class NsLcm(LcmBase):
timeout_vca_on_error = 5 * 60 # Time for charm from first time at blocked,error status to mark as failed
timeout_ns_deploy = 2 * 3600 # default global timeout for deployment a ns
SUBOPERATION_STATUS_SKIP = -3
task_name_deploy_vca = "Deploying VCA"
- def __init__(self, db, msg, fs, lcm_tasks, config, loop, prometheus=None):
+ def __init__(self, msg, lcm_tasks, config, loop, prometheus=None):
"""
Init, Connect to database, filesystem storage, and messaging
:param config: two level dictionary with configuration. Top level should contain 'database', 'storage',
:return: None
"""
super().__init__(
- db=db,
msg=msg,
- fs=fs,
logger=logging.getLogger('lcm.ns')
)
+ self.db = Database().instance.db
+ self.fs = Filesystem().instance.fs
self.loop = loop
self.lcm_tasks = lcm_tasks
self.timeout = config["timeout"]
self.vca_config = config["VCA"].copy()
# create N2VC connector
- self.n2vc = N2VCJujuConnectorLCM(
- db=self.db,
- fs=self.fs,
+ self.n2vc = N2VCJujuConnector(
log=self.logger,
loop=self.loop,
url='{}:{}'.format(self.vca_config['host'], self.vca_config['port']),
username=self.vca_config.get('user', None),
vca_config=self.vca_config,
- on_update_db=self._on_update_n2vc_db
+ on_update_db=self._on_update_n2vc_db,
+ fs=self.fs,
+ db=self.db
)
self.conn_helm_ee = LCMHelmConn(
- db=self.db,
- fs=self.fs,
log=self.logger,
loop=self.loop,
url=None,
on_update_db=self._on_update_n2vc_db
)
- self.k8sclusterhelm = K8sHelmConnector(
+ self.k8sclusterhelm2 = K8sHelmConnector(
kubectl_command=self.vca_config.get("kubectlpath"),
helm_command=self.vca_config.get("helmpath"),
+ log=self.logger,
+ on_update_db=None,
+ fs=self.fs,
+ db=self.db
+ )
+
+ self.k8sclusterhelm3 = K8sHelm3Connector(
+ kubectl_command=self.vca_config.get("kubectlpath"),
+ helm_command=self.vca_config.get("helm3path"),
fs=self.fs,
log=self.logger,
db=self.db,
self.k8sclusterjuju = K8sJujuConnector(
kubectl_command=self.vca_config.get("kubectlpath"),
juju_command=self.vca_config.get("jujupath"),
- fs=self.fs,
log=self.logger,
- db=self.db,
+ loop=self.loop,
on_update_db=None,
+ vca_config=self.vca_config,
+ fs=self.fs,
+ db=self.db
)
self.k8scluster_map = {
- "helm-chart": self.k8sclusterhelm,
- "chart": self.k8sclusterhelm,
+ "helm-chart": self.k8sclusterhelm2,
+ "helm-chart-v3": self.k8sclusterhelm3,
+ "chart": self.k8sclusterhelm3,
"juju-bundle": self.k8sclusterjuju,
"juju": self.k8sclusterjuju,
}
"lxc_proxy_charm": self.n2vc,
"native_charm": self.n2vc,
"k8s_proxy_charm": self.n2vc,
- "helm": self.conn_helm_ee
+ "helm": self.conn_helm_ee,
+ "helm-v3": self.conn_helm_ee
}
self.prometheus = prometheus
# create RO client
- if self.ng_ro:
- self.RO = NgRoClient(self.loop, **self.ro_config)
- else:
- self.RO = ROclient.ROClient(self.loop, **self.ro_config)
+ self.RO = NgRoClient(self.loop, **self.ro_config)
+
+ @staticmethod
+ def increment_ip_mac(ip_mac, vm_index=1):
+ if not isinstance(ip_mac, str):
+ return ip_mac
+ try:
+ # try with ipv4 look for last dot
+ i = ip_mac.rfind(".")
+ if i > 0:
+ i += 1
+ return "{}{}".format(ip_mac[:i], int(ip_mac[i:]) + vm_index)
+ # try with ipv6 or mac look for last colon. Operate in hex
+ i = ip_mac.rfind(":")
+ if i > 0:
+ i += 1
+ # format in hex, len can be 2 for mac or 4 for ipv6
+ return ("{}{:0" + str(len(ip_mac) - i) + "x}").format(ip_mac[:i], int(ip_mac[i:], 16) + vm_index)
+ except Exception:
+ pass
+ return None
def _on_update_ro_db(self, nsrs_id, ro_descriptor):
except Exception as e:
self.logger.warn('Error updating NS state for ns={}: {}'.format(nsr_id, e))
+ @staticmethod
+ def _parse_cloud_init(cloud_init_text, additional_params, vnfd_id, vdu_id):
+ try:
+ env = Environment(undefined=StrictUndefined)
+ template = env.from_string(cloud_init_text)
+ return template.render(additional_params or {})
+ except UndefinedError as e:
+ raise LcmException("Variable {} at vnfd[id={}]:vdu[id={}]:cloud-init/cloud-init-"
+ "file, must be provided in the instantiation parameters inside the "
+ "'additionalParamsForVnf/Vdu' block".format(e, vnfd_id, vdu_id))
+ except (TemplateError, TemplateNotFound) as e:
+ raise LcmException("Error parsing Jinja2 to cloud-init content at vnfd[id={}]:vdu[id={}]: {}".
+ format(vnfd_id, vdu_id, e))
+
+ def _get_vdu_cloud_init_content(self, vdu, vnfd):
+ cloud_init_content = cloud_init_file = None
+ try:
+ if vdu.get("cloud-init-file"):
+ base_folder = vnfd["_admin"]["storage"]
+ cloud_init_file = "{}/{}/cloud_init/{}".format(base_folder["folder"], base_folder["pkg-dir"],
+ vdu["cloud-init-file"])
+ with self.fs.file_open(cloud_init_file, "r") as ci_file:
+ cloud_init_content = ci_file.read()
+ elif vdu.get("cloud-init"):
+ cloud_init_content = vdu["cloud-init"]
+
+ return cloud_init_content
+ except FsException as e:
+ raise LcmException("Error reading vnfd[id={}]:vdu[id={}]:cloud-init-file={}: {}".
+ format(vnfd["id"], vdu["id"], cloud_init_file, e))
+
+ def _get_vdu_additional_params(self, db_vnfr, vdu_id):
+ vdur = next(vdur for vdur in db_vnfr.get("vdur") if vdu_id == vdur["vdu-id-ref"])
+ additional_params = vdur.get("additionalParams")
+ return parse_yaml_strings(additional_params)
+
def vnfd2RO(self, vnfd, new_id=None, additionalParams=None, nsrId=None):
"""
Converts creates a new vnfd descriptor for RO base on input OSM IM vnfd
:param nsrId: Id of the NSR
:return: copy of vnfd
"""
- try:
- vnfd_RO = deepcopy(vnfd)
- # remove unused by RO configuration, monitoring, scaling and internal keys
- vnfd_RO.pop("_id", None)
- vnfd_RO.pop("_admin", None)
- vnfd_RO.pop("vnf-configuration", None)
- vnfd_RO.pop("monitoring-param", None)
- vnfd_RO.pop("scaling-group-descriptor", None)
- vnfd_RO.pop("kdu", None)
- vnfd_RO.pop("k8s-cluster", None)
- if new_id:
- vnfd_RO["id"] = new_id
-
- # parse cloud-init or cloud-init-file with the provided variables using Jinja2
- for vdu in get_iterable(vnfd_RO, "vdu"):
- cloud_init_file = None
- if vdu.get("cloud-init-file"):
- base_folder = vnfd["_admin"]["storage"]
- cloud_init_file = "{}/{}/cloud_init/{}".format(base_folder["folder"], base_folder["pkg-dir"],
- vdu["cloud-init-file"])
- with self.fs.file_open(cloud_init_file, "r") as ci_file:
- cloud_init_content = ci_file.read()
- vdu.pop("cloud-init-file", None)
- elif vdu.get("cloud-init"):
- cloud_init_content = vdu["cloud-init"]
- else:
- continue
-
- env = Environment()
- ast = env.parse(cloud_init_content)
- mandatory_vars = meta.find_undeclared_variables(ast)
- if mandatory_vars:
- for var in mandatory_vars:
- if not additionalParams or var not in additionalParams.keys():
- raise LcmException("Variable '{}' defined at vnfd[id={}]:vdu[id={}]:cloud-init/cloud-init-"
- "file, must be provided in the instantiation parameters inside the "
- "'additionalParamsForVnf' block".format(var, vnfd["id"], vdu["id"]))
- template = Template(cloud_init_content)
- cloud_init_content = template.render(additionalParams or {})
- vdu["cloud-init"] = cloud_init_content
-
- return vnfd_RO
- except FsException as e:
- raise LcmException("Error reading vnfd[id={}]:vdu[id={}]:cloud-init-file={}: {}".
- format(vnfd["id"], vdu["id"], cloud_init_file, e))
- except (TemplateError, TemplateNotFound, TemplateSyntaxError) as e:
- raise LcmException("Error parsing Jinja2 to cloud-init content at vnfd[id={}]:vdu[id={}]: {}".
- format(vnfd["id"], vdu["id"], e))
-
- def _ns_params_2_RO(self, ns_params, nsd, vnfd_dict, db_vnfrs, n2vc_key_list):
- """
- Creates a RO ns descriptor from OSM ns_instantiate params
- :param ns_params: OSM instantiate params
- :param vnfd_dict: database content of vnfds, indexed by id (not _id). {id: {vnfd_object}, ...}
- :param db_vnfrs: database content of vnfrs, indexed by member-vnf-index. {member-vnf-index: {vnfr_object}, ...}
- :return: The RO ns descriptor
- """
- vim_2_RO = {}
- wim_2_RO = {}
- # TODO feature 1417: Check that no instantiation is set over PDU
- # check if PDU forces a concrete vim-network-id and add it
- # check if PDU contains a SDN-assist info (dpid, switch, port) and pass it to RO
-
- 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"] != "ENABLED":
- raise LcmException("VIM={} is not available. operationalState={}".format(
- vim_account, db_vim["_admin"]["operationalState"]))
- RO_vim_id = db_vim["_admin"]["deployed"]["RO"]
- vim_2_RO[vim_account] = RO_vim_id
- return RO_vim_id
-
- def wim_account_2_RO(wim_account):
- if isinstance(wim_account, str):
- if wim_account in wim_2_RO:
- return wim_2_RO[wim_account]
-
- db_wim = self.db.get_one("wim_accounts", {"_id": wim_account})
- if db_wim["_admin"]["operationalState"] != "ENABLED":
- raise LcmException("WIM={} is not available. operationalState={}".format(
- wim_account, db_wim["_admin"]["operationalState"]))
- RO_wim_id = db_wim["_admin"]["deployed"]["RO-account"]
- wim_2_RO[wim_account] = RO_wim_id
- return RO_wim_id
- else:
- return wim_account
-
- def ip_profile_2_RO(ip_profile):
- RO_ip_profile = deepcopy((ip_profile))
- if "dns-server" in RO_ip_profile:
- if isinstance(RO_ip_profile["dns-server"], list):
- RO_ip_profile["dns-address"] = []
- for ds in RO_ip_profile.pop("dns-server"):
- RO_ip_profile["dns-address"].append(ds['address'])
- else:
- 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 = {
- # "name": ns_params["nsName"],
- # "description": ns_params.get("nsDescription"),
- "datacenter": vim_account_2_RO(ns_params["vimAccountId"]),
- "wim_account": wim_account_2_RO(ns_params.get("wimAccountId")),
- # "scenario": ns_params["nsdId"],
- }
- # set vim_account of each vnf if different from general vim_account.
- # Get this information from <vnfr> database content, key vim-account-id
- # Vim account can be set by placement_engine and it may be different from
- # the instantiate parameters (vnfs.member-vnf-index.datacenter).
- for vnf_index, vnfr in db_vnfrs.items():
- if vnfr.get("vim-account-id") and vnfr["vim-account-id"] != ns_params["vimAccountId"]:
- populate_dict(RO_ns_params, ("vnfs", vnf_index, "datacenter"), vim_account_2_RO(vnfr["vim-account-id"]))
-
- n2vc_key_list = n2vc_key_list or []
- for vnfd_ref, vnfd in vnfd_dict.items():
- vdu_needed_access = []
- mgmt_cp = None
- if vnfd.get("vnf-configuration"):
- ssh_required = deep_get(vnfd, ("vnf-configuration", "config-access", "ssh-access", "required"))
- if ssh_required and vnfd.get("mgmt-interface"):
- if vnfd["mgmt-interface"].get("vdu-id"):
- vdu_needed_access.append(vnfd["mgmt-interface"]["vdu-id"])
- elif vnfd["mgmt-interface"].get("cp"):
- mgmt_cp = vnfd["mgmt-interface"]["cp"]
-
- for vdu in vnfd.get("vdu", ()):
- if vdu.get("vdu-configuration"):
- ssh_required = deep_get(vdu, ("vdu-configuration", "config-access", "ssh-access", "required"))
- if ssh_required:
- vdu_needed_access.append(vdu["id"])
- elif mgmt_cp:
- for vdu_interface in vdu.get("interface"):
- if vdu_interface.get("external-connection-point-ref") and \
- vdu_interface["external-connection-point-ref"] == mgmt_cp:
- vdu_needed_access.append(vdu["id"])
- mgmt_cp = None
- break
+ vnfd_RO = deepcopy(vnfd)
+ # remove unused by RO configuration, monitoring, scaling and internal keys
+ vnfd_RO.pop("_id", None)
+ vnfd_RO.pop("_admin", None)
+ vnfd_RO.pop("vnf-configuration", None)
+ vnfd_RO.pop("monitoring-param", None)
+ vnfd_RO.pop("scaling-group-descriptor", None)
+ vnfd_RO.pop("kdu", None)
+ vnfd_RO.pop("k8s-cluster", None)
+ if new_id:
+ vnfd_RO["id"] = new_id
+
+ # parse cloud-init or cloud-init-file with the provided variables using Jinja2
+ for vdu in get_iterable(vnfd_RO, "vdu"):
+ vdu.pop("cloud-init-file", None)
+ vdu.pop("cloud-init", None)
+ return vnfd_RO
- if vdu_needed_access:
- for vnf_member in nsd.get("constituent-vnfd"):
- if vnf_member["vnfd-id-ref"] != vnfd_ref:
- continue
- for vdu in vdu_needed_access:
- populate_dict(RO_ns_params,
- ("vnfs", vnf_member["member-vnf-index"], "vdus", vdu, "mgmt_keys"),
- n2vc_key_list)
-
- if ns_params.get("vduImage"):
- RO_ns_params["vduImage"] = ns_params["vduImage"]
-
- if ns_params.get("ssh_keys"):
- RO_ns_params["cloud-config"] = {"key-pairs": ns_params["ssh_keys"]}
- for vnf_params in get_iterable(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
+ @staticmethod
+ def ip_profile_2_RO(ip_profile):
+ RO_ip_profile = deepcopy(ip_profile)
+ if "dns-server" in RO_ip_profile:
+ if isinstance(RO_ip_profile["dns-server"], list):
+ RO_ip_profile["dns-address"] = []
+ for ds in RO_ip_profile.pop("dns-server"):
+ RO_ip_profile["dns-address"].append(ds['address'])
else:
- raise LcmException("Invalid instantiate parameter vnf:member-vnf-index={} is not present at nsd:"
- "constituent-vnfd".format(vnf_params["member-vnf-index"]))
-
- for vdu_params in get_iterable(vnf_params, "vdu"):
- # TODO feature 1417: check that this VDU exist and it is not a PDU
- if vdu_params.get("volume"):
- for volume_params in vdu_params["volume"]:
- if volume_params.get("vim-volume-id"):
- populate_dict(RO_ns_params, ("vnfs", vnf_params["member-vnf-index"], "vdus",
- vdu_params["id"], "devices", volume_params["name"], "vim_id"),
- volume_params["vim-volume-id"])
- if vdu_params.get("interface"):
- for interface_params in vdu_params["interface"]:
- if interface_params.get("ip-address"):
- populate_dict(RO_ns_params, ("vnfs", vnf_params["member-vnf-index"], "vdus",
- vdu_params["id"], "interfaces", interface_params["name"],
- "ip_address"),
- interface_params["ip-address"])
- if interface_params.get("mac-address"):
- populate_dict(RO_ns_params, ("vnfs", vnf_params["member-vnf-index"], "vdus",
- vdu_params["id"], "interfaces", interface_params["name"],
- "mac_address"),
- interface_params["mac-address"])
- if interface_params.get("floating-ip-required"):
- populate_dict(RO_ns_params, ("vnfs", vnf_params["member-vnf-index"], "vdus",
- vdu_params["id"], "interfaces", interface_params["name"],
- "floating-ip"),
- interface_params["floating-ip-required"])
-
- for internal_vld_params in get_iterable(vnf_params, "internal-vld"):
- if internal_vld_params.get("vim-network-name"):
- populate_dict(RO_ns_params, ("vnfs", vnf_params["member-vnf-index"], "networks",
- internal_vld_params["name"], "vim-network-name"),
- internal_vld_params["vim-network-name"])
- if internal_vld_params.get("vim-network-id"):
- populate_dict(RO_ns_params, ("vnfs", vnf_params["member-vnf-index"], "networks",
- internal_vld_params["name"], "vim-network-id"),
- internal_vld_params["vim-network-id"])
- if internal_vld_params.get("ip-profile"):
- populate_dict(RO_ns_params, ("vnfs", vnf_params["member-vnf-index"], "networks",
- internal_vld_params["name"], "ip-profile"),
- ip_profile_2_RO(internal_vld_params["ip-profile"]))
- if internal_vld_params.get("provider-network"):
-
- populate_dict(RO_ns_params, ("vnfs", vnf_params["member-vnf-index"], "networks",
- internal_vld_params["name"], "provider-network"),
- internal_vld_params["provider-network"].copy())
-
- for icp_params in get_iterable(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 icp_params.get("ip-address"):
- populate_dict(RO_ns_params, ("vnfs", vnf_params["member-vnf-index"], "vdus",
- vdu_descriptor["id"], "interfaces",
- vdu_interface["name"], "ip_address"),
- icp_params["ip-address"])
-
- if icp_params.get("mac-address"):
- populate_dict(RO_ns_params, ("vnfs", vnf_params["member-vnf-index"], "vdus",
- vdu_descriptor["id"], "interfaces",
- vdu_interface["name"], "mac_address"),
- icp_params["mac-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"]))
-
- for vld_params in get_iterable(ns_params, "vld"):
- if "ip-profile" in vld_params:
- populate_dict(RO_ns_params, ("networks", vld_params["name"], "ip-profile"),
- ip_profile_2_RO(vld_params["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
+
+ def _get_ro_vim_id_for_vim_account(self, vim_account):
+ db_vim = self.db.get_one("vim_accounts", {"_id": vim_account})
+ if db_vim["_admin"]["operationalState"] != "ENABLED":
+ raise LcmException("VIM={} is not available. operationalState={}".format(
+ vim_account, db_vim["_admin"]["operationalState"]))
+ RO_vim_id = db_vim["_admin"]["deployed"]["RO"]
+ return RO_vim_id
+
+ def get_ro_wim_id_for_wim_account(self, wim_account):
+ if isinstance(wim_account, str):
+ db_wim = self.db.get_one("wim_accounts", {"_id": wim_account})
+ if db_wim["_admin"]["operationalState"] != "ENABLED":
+ raise LcmException("WIM={} is not available. operationalState={}".format(
+ wim_account, db_wim["_admin"]["operationalState"]))
+ RO_wim_id = db_wim["_admin"]["deployed"]["RO-account"]
+ return RO_wim_id
+ else:
+ return wim_account
- if vld_params.get("provider-network"):
+ def scale_vnfr(self, db_vnfr, vdu_create=None, vdu_delete=None, mark_delete=False):
- populate_dict(RO_ns_params, ("networks", vld_params["name"], "provider-network"),
- vld_params["provider-network"].copy())
-
- if "wimAccountId" in vld_params and vld_params["wimAccountId"] is not None:
- populate_dict(RO_ns_params, ("networks", vld_params["name"], "wim_account"),
- wim_account_2_RO(vld_params["wimAccountId"])),
- if vld_params.get("vim-network-name"):
- RO_vld_sites = []
- 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_params["vim-network-name"]})
- if RO_vld_sites:
- populate_dict(RO_ns_params, ("networks", vld_params["name"], "sites"), RO_vld_sites)
-
- if vld_params.get("vim-network-id"):
- RO_vld_sites = []
- if isinstance(vld_params["vim-network-id"], dict):
- for vim_account, vim_net in vld_params["vim-network-id"].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_params["vim-network-id"]})
- if RO_vld_sites:
- populate_dict(RO_ns_params, ("networks", vld_params["name"], "sites"), RO_vld_sites)
- if vld_params.get("ns-net"):
- if isinstance(vld_params["ns-net"], dict):
- for vld_id, instance_scenario_id in vld_params["ns-net"].items():
- RO_vld_ns_net = {"instance_scenario_id": instance_scenario_id, "osm_id": vld_id}
- populate_dict(RO_ns_params, ("networks", vld_params["name"], "use-network"), RO_vld_ns_net)
- if "vnfd-connection-point-ref" in vld_params:
- for cp_params in vld_params["vnfd-connection-point-ref"]:
- # look for interface
- for constituent_vnfd in nsd["constituent-vnfd"]:
- if constituent_vnfd["member-vnf-index"] == cp_params["member-vnf-index-ref"]:
- vnf_descriptor = vnfd_dict[constituent_vnfd["vnfd-id-ref"]]
- break
- else:
- raise LcmException(
- "Invalid instantiate parameter vld:vnfd-connection-point-ref:member-vnf-index-ref={} "
- "is not present at nsd:constituent-vnfd".format(cp_params["member-vnf-index-ref"]))
- match_cp = False
- for vdu_descriptor in vnf_descriptor["vdu"]:
- for interface_descriptor in vdu_descriptor["interface"]:
- if interface_descriptor.get("external-connection-point-ref") == \
- cp_params["vnfd-connection-point-ref"]:
- match_cp = True
- break
- if match_cp:
- break
- else:
- raise LcmException(
- "Invalid instantiate parameter vld:vnfd-connection-point-ref:member-vnf-index-ref={}:"
- "vnfd-connection-point-ref={} is not present at vnfd={}".format(
- cp_params["member-vnf-index-ref"],
- cp_params["vnfd-connection-point-ref"],
- vnf_descriptor["id"]))
- if cp_params.get("ip-address"):
- populate_dict(RO_ns_params, ("vnfs", cp_params["member-vnf-index-ref"], "vdus",
- vdu_descriptor["id"], "interfaces",
- interface_descriptor["name"], "ip_address"),
- cp_params["ip-address"])
- if cp_params.get("mac-address"):
- populate_dict(RO_ns_params, ("vnfs", cp_params["member-vnf-index-ref"], "vdus",
- vdu_descriptor["id"], "interfaces",
- interface_descriptor["name"], "mac_address"),
- cp_params["mac-address"])
- return RO_ns_params
-
- def scale_vnfr(self, db_vnfr, vdu_create=None, vdu_delete=None):
- # make a copy to do not change
- vdu_create = copy(vdu_create)
- vdu_delete = copy(vdu_delete)
-
- vdurs = db_vnfr.get("vdur")
- if vdurs is None:
- vdurs = []
- vdu_index = len(vdurs)
- while vdu_index:
- vdu_index -= 1
- vdur = vdurs[vdu_index]
- if vdur.get("pdu-type"):
- continue
- vdu_id_ref = vdur["vdu-id-ref"]
- if vdu_create and vdu_create.get(vdu_id_ref):
- for index in range(0, vdu_create[vdu_id_ref]):
- vdur = deepcopy(vdur)
- vdur["_id"] = str(uuid4())
- vdur["count-index"] += 1
- vdurs.insert(vdu_index+1+index, vdur)
- del vdu_create[vdu_id_ref]
- if vdu_delete and vdu_delete.get(vdu_id_ref):
- del vdurs[vdu_index]
- vdu_delete[vdu_id_ref] -= 1
- if not vdu_delete[vdu_id_ref]:
- del vdu_delete[vdu_id_ref]
- # check all operations are done
- if vdu_create or vdu_delete:
- raise LcmException("Error scaling OUT VNFR for {}. There is not any existing vnfr. Scaled to 0?".format(
- vdu_create))
+ db_vdu_push_list = []
+ db_update = {"_admin.modified": time()}
+ if vdu_create:
+ for vdu_id, vdu_count in vdu_create.items():
+ vdur = next((vdur for vdur in reversed(db_vnfr["vdur"]) if vdur["vdu-id-ref"] == vdu_id), None)
+ if not vdur:
+ raise LcmException("Error scaling OUT VNFR for {}. There is not any existing vnfr. Scaled to 0?".
+ format(vdu_id))
+
+ for count in range(vdu_count):
+ vdur_copy = deepcopy(vdur)
+ vdur_copy["status"] = "BUILD"
+ vdur_copy["status-detailed"] = None
+ vdur_copy["ip-address"]: None
+ vdur_copy["_id"] = str(uuid4())
+ vdur_copy["count-index"] += count + 1
+ vdur_copy["id"] = "{}-{}".format(vdur_copy["vdu-id-ref"], vdur_copy["count-index"])
+ vdur_copy.pop("vim_info", None)
+ for iface in vdur_copy["interfaces"]:
+ if iface.get("fixed-ip"):
+ iface["ip-address"] = self.increment_ip_mac(iface["ip-address"], count+1)
+ else:
+ iface.pop("ip-address", None)
+ if iface.get("fixed-mac"):
+ iface["mac-address"] = self.increment_ip_mac(iface["mac-address"], count+1)
+ else:
+ iface.pop("mac-address", None)
+ iface.pop("mgmt_vnf", None) # only first vdu can be managment of vnf
+ db_vdu_push_list.append(vdur_copy)
+ # self.logger.debug("scale out, adding vdu={}".format(vdur_copy))
if vdu_delete:
- raise LcmException("Error scaling IN VNFR for {}. There is not any existing vnfr. Scaled to 0?".format(
- vdu_delete))
-
- vnfr_update = {"vdur": vdurs}
- db_vnfr["vdur"] = vdurs
- self.update_db_2("vnfrs", db_vnfr["_id"], vnfr_update)
+ for vdu_id, vdu_count in vdu_delete.items():
+ if mark_delete:
+ indexes_to_delete = [iv[0] for iv in enumerate(db_vnfr["vdur"]) if iv[1]["vdu-id-ref"] == vdu_id]
+ db_update.update({"vdur.{}.status".format(i): "DELETING" for i in indexes_to_delete[-vdu_count:]})
+ else:
+ # it must be deleted one by one because common.db does not allow otherwise
+ vdus_to_delete = [v for v in reversed(db_vnfr["vdur"]) if v["vdu-id-ref"] == vdu_id]
+ for vdu in vdus_to_delete[:vdu_count]:
+ self.db.set_one("vnfrs", {"_id": db_vnfr["_id"]}, None, pull={"vdur": {"_id": vdu["_id"]}})
+ db_push = {"vdur": db_vdu_push_list} if db_vdu_push_list else None
+ self.db.set_one("vnfrs", {"_id": db_vnfr["_id"]}, db_update, push_list=db_push)
+ # modify passed dictionary db_vnfr
+ db_vnfr_ = self.db.get_one("vnfrs", {"_id": db_vnfr["_id"]})
+ db_vnfr["vdur"] = db_vnfr_["vdur"]
def ns_update_nsr(self, ns_update_nsr, db_nsr, nsr_desc_RO):
"""
vca["application"]
return ns_config_info
- @staticmethod
- def _get_initial_config_primitive_list(desc_primitive_list, vca_deployed, ee_descriptor_id):
- """
- Generates a list of initial-config-primitive based on the list provided by the descriptor. It includes internal
- primitives as verify-ssh-credentials, or config when needed
- :param desc_primitive_list: information of the descriptor
- :param vca_deployed: information of the deployed, needed for known if it is related to an NS, VNF, VDU and if
- this element contains a ssh public key
- :param ee_descriptor_id: execution environment descriptor id. It is the value of
- XXX_configuration.execution-environment-list.INDEX.id; it can be None
- :return: The modified list. Can ba an empty list, but always a list
- """
-
- primitive_list = desc_primitive_list or []
+ async def _instantiate_ng_ro(self, logging_text, nsr_id, nsd, db_nsr, db_nslcmop, db_vnfrs, db_vnfds,
+ n2vc_key_list, stage, start_deploy, timeout_ns_deploy):
- # filter primitives by ee_id
- primitive_list = [p for p in primitive_list if p.get("execution-environment-ref") == ee_descriptor_id]
+ db_vims = {}
- # sort by 'seq'
- if primitive_list:
- primitive_list.sort(key=lambda val: int(val['seq']))
+ def get_vim_account(vim_account_id):
+ nonlocal db_vims
+ if vim_account_id in db_vims:
+ return db_vims[vim_account_id]
+ db_vim = self.db.get_one("vim_accounts", {"_id": vim_account_id})
+ db_vims[vim_account_id] = db_vim
+ return db_vim
- # look for primitive config, and get the position. None if not present
- config_position = None
- for index, primitive in enumerate(primitive_list):
- if primitive["name"] == "config":
- config_position = index
- break
-
- # for NS, add always a config primitive if not present (bug 874)
- if not vca_deployed["member-vnf-index"] and config_position is None:
- primitive_list.insert(0, {"name": "config", "parameter": []})
- config_position = 0
- # TODO revise if needed: for VNF/VDU add verify-ssh-credentials after config
- if vca_deployed["member-vnf-index"] and config_position is not None and vca_deployed.get("ssh-public-key"):
- primitive_list.insert(config_position + 1, {"name": "verify-ssh-credentials", "parameter": []})
- return primitive_list
+ # modify target_vld info with instantiation parameters
+ def parse_vld_instantiation_params(target_vim, target_vld, vld_params, target_sdn):
+ if vld_params.get("ip-profile"):
+ target_vld["vim_info"][target_vim]["ip_profile"] = vld_params["ip-profile"]
+ if vld_params.get("provider-network"):
+ target_vld["vim_info"][target_vim]["provider_network"] = vld_params["provider-network"]
+ if "sdn-ports" in vld_params["provider-network"] and target_sdn:
+ target_vld["vim_info"][target_sdn]["sdn-ports"] = vld_params["provider-network"]["sdn-ports"]
+ if vld_params.get("wimAccountId"):
+ target_wim = "wim:{}".format(vld_params["wimAccountId"])
+ target_vld["vim_info"][target_wim] = {}
+ for param in ("vim-network-name", "vim-network-id"):
+ if vld_params.get(param):
+ if isinstance(vld_params[param], dict):
+ for vim, vim_net in vld_params[param]:
+ other_target_vim = "vim:" + vim
+ populate_dict(target_vld["vim_info"], (other_target_vim, param.replace("-", "_")), vim_net)
+ else: # isinstance str
+ target_vld["vim_info"][target_vim][param.replace("-", "_")] = vld_params[param]
+ if vld_params.get("common_id"):
+ target_vld["common_id"] = vld_params.get("common_id")
- async def _instantiate_ng_ro(self, logging_text, nsr_id, nsd, db_nsr, db_nslcmop, db_vnfrs, db_vnfds_ref,
- n2vc_key_list, stage, start_deploy, timeout_ns_deploy):
nslcmop_id = db_nslcmop["_id"]
target = {
"name": db_nsr["name"],
"image": deepcopy(db_nsr["image"]),
"flavor": deepcopy(db_nsr["flavor"]),
"action_id": nslcmop_id,
+ "cloud_init_content": {},
}
for image in target["image"]:
- image["vim_info"] = []
+ image["vim_info"] = {}
for flavor in target["flavor"]:
- flavor["vim_info"] = []
+ flavor["vim_info"] = {}
- ns_params = db_nslcmop.get("operationParams")
- ssh_keys = []
- if ns_params.get("ssh_keys"):
- ssh_keys += ns_params.get("ssh_keys")
- if n2vc_key_list:
- ssh_keys += n2vc_key_list
+ if db_nslcmop.get("lcmOperationType") != "instantiate":
+ # get parameters of instantiation:
+ db_nslcmop_instantiate = self.db.get_list("nslcmops", {"nsInstanceId": db_nslcmop["nsInstanceId"],
+ "lcmOperationType": "instantiate"})[-1]
+ ns_params = db_nslcmop_instantiate.get("operationParams")
+ else:
+ ns_params = db_nslcmop.get("operationParams")
+ ssh_keys_instantiation = ns_params.get("ssh_keys") or []
+ ssh_keys_all = ssh_keys_instantiation + (n2vc_key_list or [])
cp2target = {}
- for vld_index, vld in enumerate(nsd.get("vld")):
- target_vld = {"id": vld["id"],
- "name": vld["name"],
- "mgmt-network": vld.get("mgmt-network", False),
- "type": vld.get("type"),
- "vim_info": [{"vim-network-name": vld.get("vim-network-name"),
- "vim_account_id": ns_params["vimAccountId"]}],
- }
- for cp in vld["vnfd-connection-point-ref"]:
- cp2target["member_vnf:{}.{}".format(cp["member-vnf-index-ref"], cp["vnfd-connection-point-ref"])] = \
- "nsrs:{}:vld.{}".format(nsr_id, vld_index)
+ for vld_index, vld in enumerate(db_nsr.get("vld")):
+ target_vim = "vim:{}".format(ns_params["vimAccountId"])
+ target_vld = {
+ "id": vld["id"],
+ "name": vld["name"],
+ "mgmt-network": vld.get("mgmt-network", False),
+ "type": vld.get("type"),
+ "vim_info": {
+ target_vim: {
+ "vim_network_name": vld.get("vim-network-name"),
+ "vim_account_id": ns_params["vimAccountId"]
+ }
+ }
+ }
+ # check if this network needs SDN assist
+ if vld.get("pci-interfaces"):
+ db_vim = VimAccountDB.get_vim_account_with_id(target_vld["vim_info"][0]["vim_account_id"])
+ sdnc_id = db_vim["config"].get("sdn-controller")
+ if sdnc_id:
+ target_vld["vim_info"].append({"sdnc_id": sdnc_id})
+
+ nsd_vnf_profiles = get_vnf_profiles(nsd)
+ for nsd_vnf_profile in nsd_vnf_profiles:
+ for cp in nsd_vnf_profile["virtual-link-connectivity"]:
+ if cp["virtual-link-profile-id"] == vld["id"]:
+ cp2target["member_vnf:{}.{}".format(
+ cp["constituent-cpd-id"][0]["constituent-base-element-id"],
+ cp["constituent-cpd-id"][0]["constituent-cpd-id"]
+ )] = "nsrs:{}:vld.{}".format(nsr_id, vld_index)
+
+ # check at nsd descriptor, if there is an ip-profile
+ vld_params = {}
+ virtual_link_profiles = get_virtual_link_profiles(nsd)
+
+ for vlp in virtual_link_profiles:
+ ip_profile = find_in_list(nsd["ip-profiles"],
+ lambda profile: profile["name"] == vlp["ip-profile-ref"])
+ vld_params["ip-profile"] = ip_profile["ip-profile-params"]
+ # update vld_params with instantiation params
+ vld_instantiation_params = find_in_list(get_iterable(ns_params, "vld"),
+ lambda a_vld: a_vld["name"] in (vld["name"], vld["id"]))
+ if vld_instantiation_params:
+ vld_params.update(vld_instantiation_params)
+ parse_vld_instantiation_params(target_vim, target_vld, vld_params, None)
target["ns"]["vld"].append(target_vld)
+
for vnfr in db_vnfrs.values():
- vnfd = db_vnfds_ref[vnfr["vnfd-ref"]]
+ vnfd = find_in_list(db_vnfds, lambda db_vnf: db_vnf["id"] == vnfr["vnfd-ref"])
+ vnf_params = find_in_list(get_iterable(ns_params, "vnf"),
+ lambda a_vnf: a_vnf["member-vnf-index"] == vnfr["member-vnf-index-ref"])
target_vnf = deepcopy(vnfr)
+ target_vim = "vim:{}".format(vnfr["vim-account-id"])
for vld in target_vnf.get("vld", ()):
- # check if connected to a ns.vld
- vnf_cp = next((cp for cp in vnfd.get("connection-point", ()) if
- cp.get("internal-vld-ref") == vld["id"]), None)
+ # check if connected to a ns.vld, to fill target'
+ vnf_cp = find_in_list(vnfd.get("int-virtual-link-desc", ()),
+ lambda cpd: cpd.get("id") == vld["id"])
if vnf_cp:
ns_cp = "member_vnf:{}.{}".format(vnfr["member-vnf-index-ref"], vnf_cp["id"])
if cp2target.get(ns_cp):
vld["target"] = cp2target[ns_cp]
- vld["vim_info"] = [{"vim-network-name": vld.get("vim-network-name"),
- "vim_account_id": vnfr["vim-account-id"]}]
+ vld["vim_info"] = {target_vim: {"vim_network_name": vld.get("vim-network-name")}}
+ # check if this network needs SDN assist
+ target_sdn = None
+ if vld.get("pci-interfaces"):
+ db_vim = get_vim_account(vnfr["vim-account-id"])
+ sdnc_id = db_vim["config"].get("sdn-controller")
+ if sdnc_id:
+ sdn_vld = "vnfrs:{}:vld.{}".format(target_vnf["_id"], vld["id"])
+ target_sdn = "sdn:{}".format(sdnc_id)
+ vld["vim_info"][target_sdn] = {
+ "sdn": True, "target_vim": target_vim, "vlds": [sdn_vld], "type": vld.get("type")}
+
+ # check at vnfd descriptor, if there is an ip-profile
+ vld_params = {}
+ vnfd_vlp = find_in_list(
+ get_virtual_link_profiles(vnfd),
+ lambda a_link_profile: a_link_profile["id"] == vld["id"]
+ )
+ if vnfd_vlp and vnfd_vlp.get("virtual-link-protocol-data") and \
+ vnfd_vlp["virtual-link-protocol-data"].get("l3-protocol-data"):
+ ip_profile_source_data = vnfd_vlp["virtual-link-protocol-data"]["l3-protocol-data"]
+ ip_profile_dest_data = {}
+ if "ip-version" in ip_profile_source_data:
+ ip_profile_dest_data["ip-version"] = ip_profile_source_data["ip-version"]
+ if "cidr" in ip_profile_source_data:
+ ip_profile_dest_data["subnet-address"] = ip_profile_source_data["cidr"]
+ if "gateway-ip" in ip_profile_source_data:
+ ip_profile_dest_data["gateway-address"] = ip_profile_source_data["gateway-ip"]
+ if "dhcp-enabled" in ip_profile_source_data:
+ ip_profile_dest_data["dhcp-params"] = {
+ "enabled": ip_profile_source_data["dhcp-enabled"]
+ }
+
+ vld_params["ip-profile"] = ip_profile_dest_data
+ # update vld_params with instantiation params
+ if vnf_params:
+ vld_instantiation_params = find_in_list(get_iterable(vnf_params, "internal-vld"),
+ lambda i_vld: i_vld["name"] == vld["id"])
+ if vld_instantiation_params:
+ vld_params.update(vld_instantiation_params)
+ parse_vld_instantiation_params(target_vim, vld, vld_params, target_sdn)
+
+ vdur_list = []
for vdur in target_vnf.get("vdur", ()):
- vdur["vim_info"] = [{"vim_account_id": vnfr["vim-account-id"]}]
- vdud_index, vdud = next(k for k in enumerate(vnfd["vdu"]) if k[1]["id"] == vdur["vdu-id-ref"])
- # vdur["additionalParams"] = vnfr.get("additionalParamsForVnf") # TODO additional params for VDU
-
- if ssh_keys:
- if deep_get(vdud, ("vdu-configuration", "config-access", "ssh-access", "required")):
- vdur["ssh-keys"] = ssh_keys
- vdur["ssh-access-required"] = True
- elif deep_get(vnfd, ("vnf-configuration", "config-access", "ssh-access", "required")) and \
+ if vdur.get("status") == "DELETING" or vdur.get("pdu-type"):
+ continue # This vdu must not be created
+ vdur["vim_info"] = {"vim_account_id": vnfr["vim-account-id"]}
+
+ self.logger.debug("NS > ssh_keys > {}".format(ssh_keys_all))
+
+ if ssh_keys_all:
+ vdu_configuration = get_vdu_configuration(vnfd, vdur["vdu-id-ref"])
+ vnf_configuration = get_vnf_configuration(vnfd)
+ if vdu_configuration and vdu_configuration.get("config-access") and \
+ vdu_configuration.get("config-access").get("ssh-access"):
+ vdur["ssh-keys"] = ssh_keys_all
+ vdur["ssh-access-required"] = vdu_configuration["config-access"]["ssh-access"]["required"]
+ elif vnf_configuration and vnf_configuration.get("config-access") and \
+ vnf_configuration.get("config-access").get("ssh-access") and \
any(iface.get("mgmt-vnf") for iface in vdur["interfaces"]):
- vdur["ssh-keys"] = ssh_keys
- vdur["ssh-access-required"] = True
+ vdur["ssh-keys"] = ssh_keys_all
+ vdur["ssh-access-required"] = vnf_configuration["config-access"]["ssh-access"]["required"]
+ elif ssh_keys_instantiation and \
+ find_in_list(vdur["interfaces"], lambda iface: iface.get("mgmt-vnf")):
+ vdur["ssh-keys"] = ssh_keys_instantiation
+
+ self.logger.debug("NS > vdur > {}".format(vdur))
+ vdud = get_vdu(vnfd, vdur["vdu-id-ref"])
# cloud-init
if vdud.get("cloud-init-file"):
vdur["cloud-init"] = "{}:file:{}".format(vnfd["_id"], vdud.get("cloud-init-file"))
+ # read file and put content at target.cloul_init_content. Avoid ng_ro to use shared package system
+ if vdur["cloud-init"] not in target["cloud_init_content"]:
+ base_folder = vnfd["_admin"]["storage"]
+ cloud_init_file = "{}/{}/cloud_init/{}".format(base_folder["folder"], base_folder["pkg-dir"],
+ vdud.get("cloud-init-file"))
+ with self.fs.file_open(cloud_init_file, "r") as ci_file:
+ target["cloud_init_content"][vdur["cloud-init"]] = ci_file.read()
elif vdud.get("cloud-init"):
- vdur["cloud-init"] = "{}:vdu:{}".format(vnfd["_id"], vdud_index)
+ vdur["cloud-init"] = "{}:vdu:{}".format(vnfd["_id"], get_vdu_index(vnfd, vdur["vdu-id-ref"]))
+ # put content at target.cloul_init_content. Avoid ng_ro read vnfd descriptor
+ target["cloud_init_content"][vdur["cloud-init"]] = vdud["cloud-init"]
+ vdur["additionalParams"] = vdur.get("additionalParams") or {}
+ deploy_params_vdu = self._format_additional_params(vdur.get("additionalParams") or {})
+ deploy_params_vdu["OSM"] = get_osm_params(vnfr, vdur["vdu-id-ref"], vdur["count-index"])
+ vdur["additionalParams"] = deploy_params_vdu
# flavor
ns_flavor = target["flavor"][int(vdur["ns-flavor-id"])]
- if not next((vi for vi in ns_flavor["vim_info"] if
- vi and vi.get("vim_account_id") == vnfr["vim-account-id"]), None):
- ns_flavor["vim_info"].append({"vim_account_id": vnfr["vim-account-id"]})
+ if target_vim not in ns_flavor["vim_info"]:
+ ns_flavor["vim_info"][target_vim] = {}
# image
ns_image = target["image"][int(vdur["ns-image-id"])]
- if not next((vi for vi in ns_image["vim_info"] if
- vi and vi.get("vim_account_id") == vnfr["vim-account-id"]), None):
- ns_image["vim_info"].append({"vim_account_id": vnfr["vim-account-id"]})
-
- vdur["vim_info"] = [{"vim_account_id": vnfr["vim-account-id"]}]
+ if target_vim not in ns_image["vim_info"]:
+ ns_image["vim_info"][target_vim] = {}
+
+ vdur["vim_info"] = {target_vim: {}}
+ # instantiation parameters
+ # if vnf_params:
+ # vdu_instantiation_params = next((v for v in get_iterable(vnf_params, "vdu") if v["id"] ==
+ # vdud["id"]), None)
+ vdur_list.append(vdur)
+ target_vnf["vdur"] = vdur_list
target["vnf"].append(target_vnf)
desc = await self.RO.deploy(nsr_id, target)
+ self.logger.debug("RO return > {}".format(desc))
action_id = desc["action_id"]
- await self._wait_ng_ro(self, nsr_id, action_id, nslcmop_id, start_deploy, timeout_ns_deploy, stage)
+ await self._wait_ng_ro(nsr_id, action_id, nslcmop_id, start_deploy, timeout_ns_deploy, stage)
# Updating NSR
db_nsr_update = {
self.logger.debug(logging_text + "ns deployed at RO. RO_id={}".format(action_id))
return
- async def _wait_ng_ro(self, nsr_id, action_id, nslcmop_id, start_time, timeout, stage):
+ async def _wait_ng_ro(self, nsr_id, action_id, nslcmop_id=None, start_time=None, timeout=600, stage=None):
detailed_status_old = None
db_nsr_update = {}
+ start_time = start_time or time()
while time() <= start_time + timeout:
desc_status = await self.RO.status(nsr_id, action_id)
+ self.logger.debug("Wait NG RO > {}".format(desc_status))
if desc_status["status"] == "FAILED":
raise NgRoException(desc_status["details"])
elif desc_status["status"] == "BUILD":
- stage[2] = "VIM: ({})".format(desc_status["details"])
+ if stage:
+ stage[2] = "VIM: ({})".format(desc_status["details"])
elif desc_status["status"] == "DONE":
- stage[2] = "Deployed at VIM"
+ if stage:
+ stage[2] = "Deployed at VIM"
break
else:
assert False, "ROclient.check_ns_status returns unknown {}".format(desc_status["status"])
- if stage[2] != detailed_status_old:
+ if stage and nslcmop_id and stage[2] != detailed_status_old:
detailed_status_old = stage[2]
db_nsr_update["detailed-status"] = " ".join(stage)
self.update_db_2("nsrs", nsr_id, db_nsr_update)
self._write_op_status(nslcmop_id, stage)
- await asyncio.sleep(5, loop=self.loop)
+ await asyncio.sleep(15, loop=self.loop)
else: # timeout_ns_deploy
raise NgRoException("Timeout waiting ns to deploy")
"vnf": [],
"image": [],
"flavor": [],
+ "action_id": nslcmop_id
}
desc = await self.RO.deploy(nsr_id, target)
action_id = desc["action_id"]
# wait until done
delete_timeout = 20 * 60 # 20 minutes
- await self._wait_ng_ro(self, nsr_id, action_id, nslcmop_id, start_deploy, delete_timeout, stage)
+ await self._wait_ng_ro(nsr_id, action_id, nslcmop_id, start_deploy, delete_timeout, stage)
db_nsr_update["_admin.deployed.RO.nsr_delete_action_id"] = None
db_nsr_update["_admin.deployed.RO.nsr_status"] = "DELETED"
raise LcmException("; ".join(failed_detail))
return
- async def instantiate_RO(self, logging_text, nsr_id, nsd, db_nsr, db_nslcmop, db_vnfrs, db_vnfds_ref,
+ async def instantiate_RO(self, logging_text, nsr_id, nsd, db_nsr, db_nslcmop, db_vnfrs, db_vnfds,
n2vc_key_list, stage):
"""
Instantiate at RO
:param db_nsr: database content of ns record
:param db_nslcmop: database content of ns operation, in this case, 'instantiate'
:param db_vnfrs:
- :param db_vnfds_ref: database content of vnfds, indexed by id (not _id). {id: {vnfd_object}, ...}
+ :param db_vnfds: database content of vnfds, indexed by id (not _id). {id: {vnfd_object}, ...}
:param n2vc_key_list: ssh-public-key list to be inserted to management vdus via cloud-init
:param stage: list with 3 items: [general stage, tasks, vim_specific]. This task will write over vim_specific
:return: None or exception
"""
try:
- db_nsr_update = {}
- RO_descriptor_number = 0 # number of descriptors created at RO
- vnf_index_2_RO_id = {} # map between vnfd/nsd id to the id used at RO
- nslcmop_id = db_nslcmop["_id"]
start_deploy = time()
ns_params = db_nslcmop.get("operationParams")
if ns_params and ns_params.get("timeout_ns_deploy"):
else:
ns_params["vimAccountId"] == vnfr["vim-account-id"]
- if self.ng_ro:
- return await self._instantiate_ng_ro(logging_text, nsr_id, nsd, db_nsr, db_nslcmop, db_vnfrs,
- db_vnfds_ref, n2vc_key_list, stage, start_deploy,
- timeout_ns_deploy)
- # deploy RO
- # get vnfds, instantiate at RO
- for c_vnf in nsd.get("constituent-vnfd", ()):
- member_vnf_index = c_vnf["member-vnf-index"]
- vnfd = db_vnfds_ref[c_vnf['vnfd-id-ref']]
- vnfd_ref = vnfd["id"]
-
- stage[2] = "Creating vnfd='{}' member_vnf_index='{}' at RO".format(vnfd_ref, member_vnf_index)
- db_nsr_update["detailed-status"] = " ".join(stage)
- self.update_db_2("nsrs", nsr_id, db_nsr_update)
- self._write_op_status(nslcmop_id, stage)
-
- # self.logger.debug(logging_text + stage[2])
- vnfd_id_RO = "{}.{}.{}".format(nsr_id, RO_descriptor_number, member_vnf_index[:23])
- vnf_index_2_RO_id[member_vnf_index] = vnfd_id_RO
- RO_descriptor_number += 1
-
- # look position at deployed.RO.vnfd if not present it will be appended at the end
- for index, vnf_deployed in enumerate(db_nsr["_admin"]["deployed"]["RO"]["vnfd"]):
- if vnf_deployed["member-vnf-index"] == member_vnf_index:
- break
- else:
- index = len(db_nsr["_admin"]["deployed"]["RO"]["vnfd"])
- db_nsr["_admin"]["deployed"]["RO"]["vnfd"].append(None)
-
- # look if present
- RO_update = {"member-vnf-index": member_vnf_index}
- vnfd_list = await self.RO.get_list("vnfd", filter_by={"osm_id": vnfd_id_RO})
- if vnfd_list:
- RO_update["id"] = vnfd_list[0]["uuid"]
- self.logger.debug(logging_text + "vnfd='{}' member_vnf_index='{}' exists at RO. Using RO_id={}".
- format(vnfd_ref, member_vnf_index, vnfd_list[0]["uuid"]))
- else:
- vnfd_RO = self.vnfd2RO(vnfd, vnfd_id_RO, db_vnfrs[c_vnf["member-vnf-index"]].
- get("additionalParamsForVnf"), nsr_id)
- desc = await self.RO.create("vnfd", descriptor=vnfd_RO)
- RO_update["id"] = desc["uuid"]
- self.logger.debug(logging_text + "vnfd='{}' member_vnf_index='{}' created at RO. RO_id={}".format(
- vnfd_ref, member_vnf_index, desc["uuid"]))
- db_nsr_update["_admin.deployed.RO.vnfd.{}".format(index)] = RO_update
- db_nsr["_admin"]["deployed"]["RO"]["vnfd"][index] = RO_update
-
- # create nsd at RO
- nsd_ref = nsd["id"]
-
- stage[2] = "Creating nsd={} at RO".format(nsd_ref)
- db_nsr_update["detailed-status"] = " ".join(stage)
- self.update_db_2("nsrs", nsr_id, db_nsr_update)
- self._write_op_status(nslcmop_id, stage)
-
- # self.logger.debug(logging_text + stage[2])
- RO_osm_nsd_id = "{}.{}.{}".format(nsr_id, RO_descriptor_number, nsd_ref[:23])
- RO_descriptor_number += 1
- nsd_list = await self.RO.get_list("nsd", filter_by={"osm_id": RO_osm_nsd_id})
- if nsd_list:
- db_nsr_update["_admin.deployed.RO.nsd_id"] = RO_nsd_uuid = nsd_list[0]["uuid"]
- self.logger.debug(logging_text + "nsd={} exists at RO. Using RO_id={}".format(
- nsd_ref, RO_nsd_uuid))
- else:
- nsd_RO = deepcopy(nsd)
- nsd_RO["id"] = RO_osm_nsd_id
- nsd_RO.pop("_id", None)
- nsd_RO.pop("_admin", None)
- for c_vnf in nsd_RO.get("constituent-vnfd", ()):
- member_vnf_index = c_vnf["member-vnf-index"]
- c_vnf["vnfd-id-ref"] = vnf_index_2_RO_id[member_vnf_index]
- for c_vld in nsd_RO.get("vld", ()):
- for cp in c_vld.get("vnfd-connection-point-ref", ()):
- member_vnf_index = cp["member-vnf-index-ref"]
- cp["vnfd-id-ref"] = vnf_index_2_RO_id[member_vnf_index]
-
- desc = await self.RO.create("nsd", descriptor=nsd_RO)
- db_nsr_update["_admin.nsState"] = "INSTANTIATED"
- db_nsr_update["_admin.deployed.RO.nsd_id"] = RO_nsd_uuid = desc["uuid"]
- self.logger.debug(logging_text + "nsd={} created at RO. RO_id={}".format(nsd_ref, RO_nsd_uuid))
- self.update_db_2("nsrs", nsr_id, db_nsr_update)
-
- # Crate ns at RO
- stage[2] = "Creating nsd={} at RO".format(nsd_ref)
- db_nsr_update["detailed-status"] = " ".join(stage)
- self.update_db_2("nsrs", nsr_id, db_nsr_update)
- self._write_op_status(nslcmop_id, stage)
-
- # if present use it unless in error status
- RO_nsr_id = deep_get(db_nsr, ("_admin", "deployed", "RO", "nsr_id"))
- if RO_nsr_id:
- try:
- stage[2] = "Looking for existing ns at RO"
- db_nsr_update["detailed-status"] = " ".join(stage)
- self.update_db_2("nsrs", nsr_id, db_nsr_update)
- self._write_op_status(nslcmop_id, stage)
- # self.logger.debug(logging_text + stage[2] + " RO_ns_id={}".format(RO_nsr_id))
- desc = await self.RO.show("ns", RO_nsr_id)
-
- except ROclient.ROClientException as e:
- if e.http_code != HTTPStatus.NOT_FOUND:
- raise
- RO_nsr_id = db_nsr_update["_admin.deployed.RO.nsr_id"] = None
- if RO_nsr_id:
- ns_status, ns_status_info = self.RO.check_ns_status(desc)
- db_nsr_update["_admin.deployed.RO.nsr_status"] = ns_status
- if ns_status == "ERROR":
- stage[2] = "Deleting ns at RO. RO_ns_id={}".format(RO_nsr_id)
- self.logger.debug(logging_text + stage[2])
- await self.RO.delete("ns", RO_nsr_id)
- RO_nsr_id = db_nsr_update["_admin.deployed.RO.nsr_id"] = None
- if not RO_nsr_id:
- stage[2] = "Checking dependencies"
- db_nsr_update["detailed-status"] = " ".join(stage)
- self.update_db_2("nsrs", nsr_id, db_nsr_update)
- self._write_op_status(nslcmop_id, stage)
- # self.logger.debug(logging_text + stage[2])
-
- # 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:
- stage[2] = "Waiting for related tasks '{}' to be completed".format(task_name)
- self.logger.debug(logging_text + stage[2])
- 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:
- stage[2] = "Waiting for related tasks '{}' to be completed.".format(task_name)
- self.logger.debug(logging_text + stage[2])
- await asyncio.wait(task_dependency, timeout=3600)
-
- stage[2] = "Checking instantiation parameters."
- RO_ns_params = self._ns_params_2_RO(ns_params, nsd, db_vnfds_ref, db_vnfrs, n2vc_key_list)
- stage[2] = "Deploying ns at VIM."
- db_nsr_update["detailed-status"] = " ".join(stage)
- self.update_db_2("nsrs", nsr_id, db_nsr_update)
- self._write_op_status(nslcmop_id, stage)
-
- desc = await self.RO.create("ns", descriptor=RO_ns_params, name=db_nsr["name"], scenario=RO_nsd_uuid)
- RO_nsr_id = db_nsr_update["_admin.deployed.RO.nsr_id"] = desc["uuid"]
- db_nsr_update["_admin.nsState"] = "INSTANTIATED"
- db_nsr_update["_admin.deployed.RO.nsr_status"] = "BUILD"
- self.logger.debug(logging_text + "ns created at RO. RO_id={}".format(desc["uuid"]))
-
- # wait until NS is ready
- stage[2] = "Waiting VIM to deploy ns."
- db_nsr_update["detailed-status"] = " ".join(stage)
- self.update_db_2("nsrs", nsr_id, db_nsr_update)
- self._write_op_status(nslcmop_id, stage)
- detailed_status_old = None
- self.logger.debug(logging_text + stage[2] + " RO_ns_id={}".format(RO_nsr_id))
-
- old_desc = None
- while time() <= start_deploy + timeout_ns_deploy:
- desc = await self.RO.show("ns", RO_nsr_id)
+ return await self._instantiate_ng_ro(logging_text, nsr_id, nsd, db_nsr, db_nslcmop, db_vnfrs,
+ db_vnfds, n2vc_key_list, stage, start_deploy, timeout_ns_deploy)
+ except Exception as e:
+ stage[2] = "ERROR deploying at VIM"
+ self.set_vnfr_at_error(db_vnfrs, str(e))
+ self.logger.error("Error deploying at VIM {}".format(e),
+ exc_info=not isinstance(e, (ROclient.ROClientException, LcmException, DbException,
+ NgRoException)))
+ raise
- # deploymentStatus
- if desc != old_desc:
- # desc has changed => update db
- self._on_update_ro_db(nsrs_id=nsr_id, ro_descriptor=desc)
- old_desc = desc
+ async def wait_kdu_up(self, logging_text, nsr_id, vnfr_id, kdu_name):
+ """
+ Wait for kdu to be up, get ip address
+ :param logging_text: prefix use for logging
+ :param nsr_id:
+ :param vnfr_id:
+ :param kdu_name:
+ :return: IP address
+ """
- ns_status, ns_status_info = self.RO.check_ns_status(desc)
- db_nsr_update["_admin.deployed.RO.nsr_status"] = ns_status
- if ns_status == "ERROR":
- raise ROclient.ROClientException(ns_status_info)
- elif ns_status == "BUILD":
- stage[2] = "VIM: ({})".format(ns_status_info)
- elif ns_status == "ACTIVE":
- stage[2] = "Waiting for management IP address reported by the VIM. Updating VNFRs."
- try:
- self.ns_update_vnfr(db_vnfrs, desc)
- break
- except LcmExceptionNoMgmtIP:
- pass
- else:
- assert False, "ROclient.check_ns_status returns unknown {}".format(ns_status)
- if stage[2] != detailed_status_old:
- detailed_status_old = stage[2]
- db_nsr_update["detailed-status"] = " ".join(stage)
- self.update_db_2("nsrs", nsr_id, db_nsr_update)
- self._write_op_status(nslcmop_id, stage)
- await asyncio.sleep(5, loop=self.loop)
- else: # timeout_ns_deploy
- raise ROclient.ROClientException("Timeout waiting ns to be ready")
+ # self.logger.debug(logging_text + "Starting wait_kdu_up")
+ nb_tries = 0
- # Updating NSR
- self.ns_update_nsr(db_nsr_update, db_nsr, desc)
+ while nb_tries < 360:
+ db_vnfr = self.db.get_one("vnfrs", {"_id": vnfr_id})
+ kdur = next((x for x in get_iterable(db_vnfr, "kdur") if x.get("kdu-name") == kdu_name), None)
+ if not kdur:
+ raise LcmException("Not found vnfr_id={}, kdu_name={}".format(vnfr_id, kdu_name))
+ if kdur.get("status"):
+ if kdur["status"] in ("READY", "ENABLED"):
+ return kdur.get("ip-address")
+ else:
+ raise LcmException("target KDU={} is in error state".format(kdu_name))
- db_nsr_update["_admin.deployed.RO.operational-status"] = "running"
- # db_nsr["_admin.deployed.RO.detailed-status"] = "Deployed at VIM"
- stage[2] = "Deployed at VIM"
- db_nsr_update["detailed-status"] = " ".join(stage)
- self.update_db_2("nsrs", nsr_id, db_nsr_update)
- self._write_op_status(nslcmop_id, stage)
- # await self._on_update_n2vc_db("nsrs", {"_id": nsr_id}, "_admin.deployed", db_nsr_update)
- # self.logger.debug(logging_text + "Deployed at VIM")
- except (ROclient.ROClientException, LcmException, DbException, NgRoException) as e:
- stage[2] = "ERROR deploying at VIM"
- self.set_vnfr_at_error(db_vnfrs, str(e))
- raise
+ await asyncio.sleep(10, loop=self.loop)
+ nb_tries += 1
+ raise LcmException("Timeout waiting KDU={} instantiated".format(kdu_name))
async def wait_vm_up_insert_key_ro(self, logging_text, nsr_id, vnfr_id, vdu_id, vdu_index, pub_key=None, user=None):
"""
:return: IP address
"""
- # self.logger.debug(logging_text + "Starting wait_vm_up_insert_key_ro")
+ self.logger.debug(logging_text + "Starting wait_vm_up_insert_key_ro")
ro_nsr_id = None
ip_address = None
nb_tries = 0
if not vdur:
raise LcmException("Not found vnfr_id={}, vdu_id={}, vdu_index={}".format(vnfr_id, vdu_id,
vdu_index))
-
- if vdur.get("pdu-type") or vdur.get("status") == "ACTIVE":
+ # New generation RO stores information at "vim_info"
+ ng_ro_status = None
+ target_vim = None
+ if vdur.get("vim_info"):
+ target_vim = next(t for t in vdur["vim_info"]) # there should be only one key
+ ng_ro_status = vdur["vim_info"][target_vim].get("vim_status")
+ if vdur.get("pdu-type") or vdur.get("status") == "ACTIVE" or ng_ro_status == "ACTIVE":
ip_address = vdur.get("ip-address")
if not ip_address:
continue
target_vdu_id = vdur["vdu-id-ref"]
- elif vdur.get("status") == "ERROR":
+ elif vdur.get("status") == "ERROR" or ng_ro_status == "ERROR":
raise LcmException("Cannot inject ssh-key because target VM is in error state")
if not target_vdu_id:
# inject public key into machine
if pub_key and user:
- # wait until NS is deployed at RO
- if not ro_nsr_id:
- db_nsrs = self.db.get_one("nsrs", {"_id": nsr_id})
- ro_nsr_id = deep_get(db_nsrs, ("_admin", "deployed", "RO", "nsr_id"))
- if not ro_nsr_id:
- continue
-
- # self.logger.debug(logging_text + "Inserting RO key")
+ self.logger.debug(logging_text + "Inserting RO key")
+ self.logger.debug("SSH > PubKey > {}".format(pub_key))
if vdur.get("pdu-type"):
self.logger.error(logging_text + "Cannot inject ssh-ky to a PDU")
return ip_address
try:
ro_vm_id = "{}-{}".format(db_vnfr["member-vnf-index-ref"], target_vdu_id) # TODO add vdu_index
if self.ng_ro:
- target = {"action": "inject_ssh_key", "key": pub_key, "user": user,
- "vnf": [{"_id": vnfr_id, "vdur": [{"id": vdu_id}]}],
+ target = {"action": {"action": "inject_ssh_key", "key": pub_key, "user": user},
+ "vnf": [{"_id": vnfr_id, "vdur": [{"id": vdur["id"]}]}],
}
- await self.RO.deploy(nsr_id, target)
+ desc = await self.RO.deploy(nsr_id, target)
+ action_id = desc["action_id"]
+ await self._wait_ng_ro(nsr_id, action_id, timeout=600)
+ break
else:
+ # wait until NS is deployed at RO
+ if not ro_nsr_id:
+ db_nsrs = self.db.get_one("nsrs", {"_id": nsr_id})
+ ro_nsr_id = deep_get(db_nsrs, ("_admin", "deployed", "RO", "nsr_id"))
+ if not ro_nsr_id:
+ continue
result_dict = await self.RO.create_action(
item="ns",
item_id_name=ro_nsr_id,
"charms" if vca_type in ("native_charm", "lxc_proxy_charm", "k8s_proxy_charm") else "helm-charts",
vca_name
)
+
+ self.logger.debug("Artifact path > {}".format(artifact_path))
+
# get initial_config_primitive_list that applies to this element
initial_config_primitive_list = config_descriptor.get('initial-config-primitive')
+ self.logger.debug("Initial config primitive list > {}".format(initial_config_primitive_list))
+
# add config if not present for NS charm
ee_descriptor_id = ee_config_descriptor.get("id")
- initial_config_primitive_list = self._get_initial_config_primitive_list(initial_config_primitive_list,
- vca_deployed, ee_descriptor_id)
+ self.logger.debug("EE Descriptor > {}".format(ee_descriptor_id))
+ initial_config_primitive_list = get_ee_sorted_initial_config_primitive_list(initial_config_primitive_list,
+ vca_deployed, ee_descriptor_id)
+ self.logger.debug("Initial config primitive list #2 > {}".format(initial_config_primitive_list))
# n2vc_redesign STEP 3.1
# find old ee_id if exists
ee_id = vca_deployed.get("ee_id")
+ vim_account_id = (
+ deep_get(db_vnfr, ("vim-account-id",)) or
+ deep_get(deploy_params, ("OSM", "vim_account_id"))
+ )
+ vca_cloud, vca_cloud_credential = self.get_vca_cloud_and_credentials(vim_account_id)
+ vca_k8s_cloud, vca_k8s_cloud_credential = self.get_vca_k8s_cloud_and_credentials(vim_account_id)
# create or register execution environment in VCA
- if vca_type in ("lxc_proxy_charm", "k8s_proxy_charm", "helm"):
+ if vca_type in ("lxc_proxy_charm", "k8s_proxy_charm", "helm", "helm-v3"):
self._write_configuration_status(
nsr_id=nsr_id,
)
step = "create execution environment"
- self.logger.debug(logging_text + step)
- ee_id, credentials = await self.vca_map[vca_type].create_execution_environment(
- namespace=namespace,
- reuse_ee_id=ee_id,
- db_dict=db_dict,
- config=osm_config,
- artifact_path=artifact_path,
- vca_type=vca_type)
+ self.logger.debug(logging_text + step)
+
+ ee_id = None
+ credentials = None
+ if vca_type == "k8s_proxy_charm":
+ ee_id = await self.vca_map[vca_type].install_k8s_proxy_charm(
+ charm_name=artifact_path[artifact_path.rfind("/") + 1:],
+ namespace=namespace,
+ artifact_path=artifact_path,
+ db_dict=db_dict,
+ cloud_name=vca_k8s_cloud,
+ credential_name=vca_k8s_cloud_credential,
+ )
+ elif vca_type == "helm" or vca_type == "helm-v3":
+ ee_id, credentials = await self.vca_map[vca_type].create_execution_environment(
+ namespace=namespace,
+ reuse_ee_id=ee_id,
+ db_dict=db_dict,
+ config=osm_config,
+ artifact_path=artifact_path,
+ vca_type=vca_type
+ )
+ else:
+ ee_id, credentials = await self.vca_map[vca_type].create_execution_environment(
+ namespace=namespace,
+ reuse_ee_id=ee_id,
+ db_dict=db_dict,
+ cloud_name=vca_cloud,
+ credential_name=vca_cloud_credential,
+ )
elif vca_type == "native_charm":
step = "Waiting to VM being up and getting IP address"
step = "register execution environment {}".format(credentials)
self.logger.debug(logging_text + step)
ee_id = await self.vca_map[vca_type].register_execution_environment(
- credentials=credentials, namespace=namespace, db_dict=db_dict)
+ credentials=credentials,
+ namespace=namespace,
+ db_dict=db_dict,
+ cloud_name=vca_cloud,
+ credential_name=vca_cloud_credential,
+ )
# for compatibility with MON/POL modules, the need model and application name at database
# TODO ask MON/POL if needed to not assuming anymore the format "model_name.application_name"
if vdu_id == v["vdu-id-ref"]:
num_units = v.get("config-units") or 1
break
-
- await self.vca_map[vca_type].install_configuration_sw(
- ee_id=ee_id,
- artifact_path=artifact_path,
- db_dict=db_dict,
- config=config,
- num_units=num_units,
- vca_type=vca_type
- )
+ if vca_type != "k8s_proxy_charm":
+ await self.vca_map[vca_type].install_configuration_sw(
+ ee_id=ee_id,
+ artifact_path=artifact_path,
+ db_dict=db_dict,
+ config=config,
+ num_units=num_units,
+ )
# write in db flag of configuration_sw already installed
self.update_db_2("nsrs", nsr_id, {db_update_entry + "config_sw_installed": True})
vca_index=vca_index, vca_type=vca_type)
# if SSH access is required, then get execution environment SSH public
- if vca_type in ("lxc_proxy_charm", "helm"): # if native charm we have waited already to VM be UP
+ # if native charm we have waited already to VM be UP
+ if vca_type in ("k8s_proxy_charm", "lxc_proxy_charm", "helm", "helm-v3"):
pub_key = None
user = None
# self.logger.debug("get ssh key block")
# n2vc_redesign STEP 5.1
# wait for RO (ip-address) Insert pub_key into VM
if vnfr_id:
- rw_mgmt_ip = await self.wait_vm_up_insert_key_ro(logging_text, nsr_id, vnfr_id, vdu_id, vdu_index,
- user=user, pub_key=pub_key)
+ if kdu_name:
+ rw_mgmt_ip = await self.wait_kdu_up(logging_text, nsr_id, vnfr_id, kdu_name)
+ else:
+ rw_mgmt_ip = await self.wait_vm_up_insert_key_ro(logging_text, nsr_id, vnfr_id, vdu_id,
+ vdu_index, user=user, pub_key=pub_key)
else:
rw_mgmt_ip = None # This is for a NS configuration
# TODO register in database that primitive is done
# STEP 7 Configure metrics
- if vca_type == "helm":
+ if vca_type == "helm" or vca_type == "helm-v3":
prometheus_jobs = await self.add_prometheus_metrics(
ee_id=ee_id,
artifact_path=artifact_path,
# wait for any previous tasks in process
await self.lcm_tasks.waitfor_related_HA('ns', 'nslcmops', nslcmop_id)
- stage[1] = "Sync filesystem from database"
+ stage[1] = "Sync filesystem from database."
self.fs.sync() # TODO, make use of partial sync, only for the needed packages
# STEP 0: Reading database (nslcmops, nsrs, nsds, vnfrs, vnfds)
- stage[1] = "Reading from database"
+ stage[1] = "Reading from database."
# nsState="BUILDING", currentOperation="INSTANTIATING", currentOperationID=nslcmop_id
db_nsr_update["detailed-status"] = "creating"
db_nsr_update["operational-status"] = "init"
)
# read from db: operation
- stage[1] = "Getting nslcmop={} from db".format(nslcmop_id)
+ stage[1] = "Getting nslcmop={} from db.".format(nslcmop_id)
db_nslcmop = self.db.get_one("nslcmops", {"_id": nslcmop_id})
ns_params = db_nslcmop.get("operationParams")
if ns_params and ns_params.get("timeout_ns_deploy"):
timeout_ns_deploy = self.timeout.get("ns_deploy", self.timeout_ns_deploy)
# read from db: ns
- stage[1] = "Getting nsr={} from db".format(nsr_id)
+ stage[1] = "Getting nsr={} from db.".format(nsr_id)
db_nsr = self.db.get_one("nsrs", {"_id": nsr_id})
- stage[1] = "Getting nsd={} from db".format(db_nsr["nsd-id"])
+ stage[1] = "Getting nsd={} from db.".format(db_nsr["nsd-id"])
nsd = self.db.get_one("nsds", {"_id": db_nsr["nsd-id"]})
db_nsr["nsd"] = nsd
# nsr_name = db_nsr["name"] # TODO short-name??
# read from db: vnf's of this ns
- stage[1] = "Getting vnfrs from db"
+ stage[1] = "Getting vnfrs from db."
self.logger.debug(logging_text + stage[1])
db_vnfrs_list = self.db.get_list("vnfrs", {"nsr-id-ref": nsr_id})
# read from db: vnfd's for every vnf
- db_vnfds_ref = {} # every vnfd data indexed by vnf name
- db_vnfds = {} # every vnfd data indexed by vnf id
- db_vnfds_index = {} # every vnfd data indexed by vnf member-index
+ db_vnfds = [] # every vnfd data
# for each vnf in ns, read vnfd
for vnfr in db_vnfrs_list:
- db_vnfrs[vnfr["member-vnf-index-ref"]] = vnfr # vnf's dict indexed by member-index: '1', '2', etc
- vnfd_id = vnfr["vnfd-id"] # vnfd uuid for this vnf
- vnfd_ref = vnfr["vnfd-ref"] # vnfd name for this vnf
+ db_vnfrs[vnfr["member-vnf-index-ref"]] = vnfr
+ vnfd_id = vnfr["vnfd-id"]
+ vnfd_ref = vnfr["vnfd-ref"]
+
# if we haven't this vnfd, read it from db
if vnfd_id not in db_vnfds:
# read from db
- stage[1] = "Getting vnfd={} id='{}' from db".format(vnfd_id, vnfd_ref)
+ stage[1] = "Getting vnfd={} id='{}' from db.".format(vnfd_id, vnfd_ref)
self.logger.debug(logging_text + stage[1])
vnfd = self.db.get_one("vnfds", {"_id": vnfd_id})
# store vnfd
- db_vnfds_ref[vnfd_ref] = vnfd # vnfd's indexed by name
- db_vnfds[vnfd_id] = vnfd # vnfd's indexed by id
- db_vnfds_index[vnfr["member-vnf-index-ref"]] = db_vnfds[vnfd_id] # vnfd's indexed by member-index
+ db_vnfds.append(vnfd)
# Get or generates the _admin.deployed.VCA list
vca_deployed_list = None
# set state to INSTANTIATED. When instantiated NBI will not delete directly
db_nsr_update["_admin.nsState"] = "INSTANTIATED"
self.update_db_2("nsrs", nsr_id, db_nsr_update)
+ self.db.set_list("vnfrs", {"nsr-id-ref": nsr_id}, {"_admin.nsState": "INSTANTIATED"})
# n2vc_redesign STEP 2 Deploy Network Scenario
stage[0] = 'Stage 2/5: deployment of KDUs, VMs and execution environments.'
stage=stage
)
- stage[1] = "Deploying KDUs,"
+ stage[1] = "Deploying KDUs."
# self.logger.debug(logging_text + "Before deploy_kdus")
# Call to deploy_kdus in case exists the "vdu:kdu" param
await self.deploy_kdus(
db_nsr=db_nsr,
db_nslcmop=db_nslcmop,
db_vnfrs=db_vnfrs,
- db_vnfds_ref=db_vnfds_ref,
+ db_vnfds=db_vnfds,
n2vc_key_list=n2vc_key_list,
stage=stage
)
self.logger.debug(logging_text + stage[1])
nsi_id = None # TODO put nsi_id when this nsr belongs to a NSI
- # get_iterable() returns a value from a dict or empty tuple if key does not exist
- for c_vnf in get_iterable(nsd, "constituent-vnfd"):
- vnfd_id = c_vnf["vnfd-id-ref"]
- vnfd = db_vnfds_ref[vnfd_id]
- member_vnf_index = str(c_vnf["member-vnf-index"])
+ for vnf_profile in get_vnf_profiles(nsd):
+ vnfd_id = vnf_profile["vnfd-id"]
+ vnfd = find_in_list(db_vnfds, lambda a_vnf: a_vnf["id"] == vnfd_id)
+ member_vnf_index = str(vnf_profile["id"])
db_vnfr = db_vnfrs[member_vnf_index]
base_folder = vnfd["_admin"]["storage"]
vdu_id = None
kdu_name = None
# Get additional parameters
- deploy_params = {}
+ deploy_params = {"OSM": get_osm_params(db_vnfr)}
if db_vnfr.get("additionalParamsForVnf"):
- deploy_params = self._format_additional_params(db_vnfr["additionalParamsForVnf"].copy())
+ deploy_params.update(parse_yaml_strings(db_vnfr["additionalParamsForVnf"].copy()))
- descriptor_config = vnfd.get("vnf-configuration")
+ descriptor_config = get_vnf_configuration(vnfd)
if descriptor_config:
self._deploy_n2vc(
logging_text=logging_text + "member_vnf_index={} ".format(member_vnf_index),
)
# Deploy charms for each VDU that supports one.
- for vdud in get_iterable(vnfd, 'vdu'):
+ for vdud in get_vdu_list(vnfd):
vdu_id = vdud["id"]
- descriptor_config = vdud.get('vdu-configuration')
- vdur = next((x for x in db_vnfr["vdur"] if x["vdu-id-ref"] == vdu_id), None)
+ descriptor_config = get_vdu_configuration(vnfd, vdu_id)
+ vdur = find_in_list(db_vnfr["vdur"], lambda vdu: vdu["vdu-id-ref"] == vdu_id)
+
if vdur.get("additionalParams"):
- deploy_params_vdu = self._format_additional_params(vdur["additionalParams"])
+ deploy_params_vdu = parse_yaml_strings(vdur["additionalParams"])
else:
deploy_params_vdu = deploy_params
+ deploy_params_vdu["OSM"] = get_osm_params(db_vnfr, vdu_id, vdu_count_index=0)
+ vdud_count = get_vdu_profile(vnfd, vdu_id).get("max-number-of-instances", 1)
+
+ self.logger.debug("VDUD > {}".format(vdud))
+ self.logger.debug("Descriptor config > {}".format(descriptor_config))
if descriptor_config:
- # look for vdu index in the db_vnfr["vdu"] section
- # for vdur_index, vdur in enumerate(db_vnfr["vdur"]):
- # if vdur["vdu-id-ref"] == vdu_id:
- # break
- # else:
- # raise LcmException("Mismatch vdu_id={} not found in the vnfr['vdur'] list for "
- # "member_vnf_index={}".format(vdu_id, member_vnf_index))
- # vdu_name = vdur.get("name")
vdu_name = None
kdu_name = None
- for vdu_index in range(int(vdud.get("count", 1))):
+ for vdu_index in range(vdud_count):
# TODO vnfr_params["rw_mgmt_ip"] = vdur["ip-address"]
self._deploy_n2vc(
logging_text=logging_text + "member_vnf_index={}, vdu_id={}, vdu_index={} ".format(
task_instantiation_info=tasks_dict_info,
stage=stage
)
- for kdud in get_iterable(vnfd, 'kdu'):
+ for kdud in get_kdu_list(vnfd):
kdu_name = kdud["name"]
- descriptor_config = kdud.get('kdu-configuration')
+ descriptor_config = get_kdu_configuration(vnfd, kdu_name)
if descriptor_config:
vdu_id = None
vdu_index = 0
vdu_name = None
- # look for vdu index in the db_vnfr["vdu"] section
- # for vdur_index, vdur in enumerate(db_vnfr["vdur"]):
- # if vdur["vdu-id-ref"] == vdu_id:
- # break
- # else:
- # raise LcmException("Mismatch vdu_id={} not found in the vnfr['vdur'] list for "
- # "member_vnf_index={}".format(vdu_id, member_vnf_index))
- # vdu_name = vdur.get("name")
- # vdu_name = None
+ kdur = next(x for x in db_vnfr["kdur"] if x["kdu-name"] == kdu_name)
+ deploy_params_kdu = {"OSM": get_osm_params(db_vnfr)}
+ if kdur.get("additionalParams"):
+ deploy_params_kdu = parse_yaml_strings(kdur["additionalParams"])
self._deploy_n2vc(
logging_text=logging_text,
member_vnf_index=member_vnf_index,
vdu_index=vdu_index,
vdu_name=vdu_name,
- deploy_params=deploy_params,
+ deploy_params=deploy_params_kdu,
descriptor_config=descriptor_config,
base_folder=base_folder,
task_instantiation_info=tasks_dict_info,
vdu_name = None
# Get additional parameters
- deploy_params = {}
+ deploy_params = {"OSM": get_osm_params(db_vnfr)}
if db_nsr.get("additionalParamsForNs"):
- deploy_params = self._format_additional_params(db_nsr["additionalParamsForNs"].copy())
+ deploy_params.update(parse_yaml_strings(db_nsr["additionalParamsForNs"].copy()))
base_folder = nsd["_admin"]["storage"]
self._deploy_n2vc(
logging_text=logging_text,
if error_list:
error_detail = ". ".join(error_list)
self.logger.error(logging_text + error_detail)
- error_description_nslcmop = 'Stage: {}. Detail: {}'.format(stage[0], error_detail)
- error_description_nsr = 'Operation: INSTANTIATING.{}, Stage {}'.format(nslcmop_id, stage[0])
+ error_description_nslcmop = '{} Detail: {}'.format(stage[0], error_detail)
+ error_description_nsr = 'Operation: INSTANTIATING.{}, {}'.format(nslcmop_id, stage[0])
db_nsr_update["detailed-status"] = error_description_nsr + " Detail: " + error_detail
db_nslcmop_update["detailed-status"] = error_detail
db_nsr = self.db.get_one("nsrs", {"_id": nsr_id})
# for each defined NS relation, find the VCA's related
- for r in ns_relations:
+ for r in ns_relations.copy():
from_vca_ee_id = None
to_vca_ee_id = None
from_vca_endpoint = None
pass
# for each defined VNF relation, find the VCA's related
- for r in vnf_relations:
+ for r in vnf_relations.copy():
from_vca_ee_id = None
to_vca_ee_id = None
from_vca_endpoint = None
to_vca_endpoint = None
vca_list = deep_get(db_nsr, ('_admin', 'deployed', 'VCA'))
for vca in vca_list:
- if vca.get('vdu_id') == r.get('entities')[0].get('id') and vca.get('config_sw_installed'):
+ key_to_check = "vdu_id"
+ if vca.get("vdu_id") is None:
+ key_to_check = "vnfd_id"
+ if vca.get(key_to_check) == r.get('entities')[0].get('id') and vca.get('config_sw_installed'):
from_vca_ee_id = vca.get('ee_id')
from_vca_endpoint = r.get('entities')[0].get('endpoint')
- if vca.get('vdu_id') == r.get('entities')[1].get('id') and vca.get('config_sw_installed'):
+ if vca.get(key_to_check) == r.get('entities')[1].get('id') and vca.get('config_sw_installed'):
to_vca_ee_id = vca.get('ee_id')
to_vca_endpoint = r.get('entities')[1].get('endpoint')
if from_vca_ee_id and to_vca_ee_id:
if vca.get('vdu_id') == r.get('entities')[0].get('id'):
if vca_status.get('status') == 'BROKEN':
# peer broken: remove relation from list
- ns_relations.remove(r)
+ vnf_relations.remove(r)
if vca.get('vdu_id') == r.get('entities')[1].get('id'):
if vca_status.get('status') == 'BROKEN':
# peer broken: remove relation from list
- ns_relations.remove(r)
+ vnf_relations.remove(r)
except Exception:
# ignore
pass
self.logger.warn(logging_text + ' ERROR adding relations: {}'.format(e))
return False
- def _write_db_callback(self, task, item, _id, on_done=None, on_exc=None):
- """
- callback for kdu install intended to store the returned kdu_instance at database
- :return: None
- """
- db_update = {}
+ async def _install_kdu(self, nsr_id: str, nsr_db_path: str, vnfr_data: dict, kdu_index: int, kdud: dict,
+ vnfd: dict, k8s_instance_info: dict, k8params: dict = None, timeout: int = 600):
+
try:
- result = task.result()
- if on_done:
- db_update[on_done] = str(result)
+ k8sclustertype = k8s_instance_info["k8scluster-type"]
+ # Instantiate kdu
+ db_dict_install = {"collection": "nsrs",
+ "filter": {"_id": nsr_id},
+ "path": nsr_db_path}
+
+ kdu_instance = await self.k8scluster_map[k8sclustertype].install(
+ cluster_uuid=k8s_instance_info["k8scluster-uuid"],
+ kdu_model=k8s_instance_info["kdu-model"],
+ atomic=True,
+ params=k8params,
+ db_dict=db_dict_install,
+ timeout=timeout,
+ kdu_name=k8s_instance_info["kdu-name"],
+ namespace=k8s_instance_info["namespace"])
+ self.update_db_2("nsrs", nsr_id, {nsr_db_path + ".kdu-instance": kdu_instance})
+
+ # Obtain services to obtain management service ip
+ services = await self.k8scluster_map[k8sclustertype].get_services(
+ cluster_uuid=k8s_instance_info["k8scluster-uuid"],
+ kdu_instance=kdu_instance,
+ namespace=k8s_instance_info["namespace"])
+
+ # Obtain management service info (if exists)
+ vnfr_update_dict = {}
+ if services:
+ vnfr_update_dict["kdur.{}.services".format(kdu_index)] = services
+ mgmt_services = [service for service in kdud.get("service", []) if service.get("mgmt-service")]
+ for mgmt_service in mgmt_services:
+ for service in services:
+ if service["name"].startswith(mgmt_service["name"]):
+ # Mgmt service found, Obtain service ip
+ ip = service.get("external_ip", service.get("cluster_ip"))
+ if isinstance(ip, list) and len(ip) == 1:
+ ip = ip[0]
+
+ vnfr_update_dict["kdur.{}.ip-address".format(kdu_index)] = ip
+
+ # Check if must update also mgmt ip at the vnf
+ service_external_cp = mgmt_service.get("external-connection-point-ref")
+ if service_external_cp:
+ if deep_get(vnfd, ("mgmt-interface", "cp")) == service_external_cp:
+ vnfr_update_dict["ip-address"] = ip
+
+ break
+ else:
+ self.logger.warn("Mgmt service name: {} not found".format(mgmt_service["name"]))
+
+ vnfr_update_dict["kdur.{}.status".format(kdu_index)] = "READY"
+ self.update_db_2("vnfrs", vnfr_data.get("_id"), vnfr_update_dict)
+
+ kdu_config = kdud.get("kdu-configuration")
+ if kdu_config and kdu_config.get("initial-config-primitive") and kdu_config.get("juju") is None:
+ initial_config_primitive_list = kdu_config.get("initial-config-primitive")
+ initial_config_primitive_list.sort(key=lambda val: int(val["seq"]))
+
+ for initial_config_primitive in initial_config_primitive_list:
+ primitive_params_ = self._map_primitive_params(initial_config_primitive, {}, {})
+
+ await asyncio.wait_for(
+ self.k8scluster_map[k8sclustertype].exec_primitive(
+ cluster_uuid=k8s_instance_info["k8scluster-uuid"],
+ kdu_instance=kdu_instance,
+ primitive_name=initial_config_primitive["name"],
+ params=primitive_params_, db_dict={}),
+ timeout=timeout)
+
except Exception as e:
- if on_exc:
- db_update[on_exc] = str(e)
- if db_update:
+ # Prepare update db with error and raise exception
try:
- self.update_db_2(item, _id, db_update)
+ self.update_db_2("nsrs", nsr_id, {nsr_db_path + ".detailed-status": str(e)})
+ self.update_db_2("vnfrs", vnfr_data.get("_id"), {"kdur.{}.status".format(kdu_index): "ERROR"})
except Exception:
+ # ignore to keep original exception
pass
+ # reraise original error
+ raise
+
+ return kdu_instance
async def deploy_kdus(self, logging_text, nsr_id, nslcmop_id, db_vnfrs, db_vnfds, task_instantiation_info):
# Launch kdus if present in the descriptor
- k8scluster_id_2_uuic = {"helm-chart": {}, "juju-bundle": {}}
+ k8scluster_id_2_uuic = {"helm-chart-v3": {}, "helm-chart": {}, "juju-bundle": {}}
- def _get_cluster_id(cluster_id, cluster_type):
+ async def _get_cluster_id(cluster_id, cluster_type):
nonlocal k8scluster_id_2_uuic
if cluster_id in k8scluster_id_2_uuic[cluster_type]:
return k8scluster_id_2_uuic[cluster_type][cluster_id]
+ # check if K8scluster is creating and wait look if previous tasks in process
+ task_name, task_dependency = self.lcm_tasks.lookfor_related("k8scluster", cluster_id)
+ if task_dependency:
+ text = "Waiting for related tasks '{}' on k8scluster {} to be completed".format(task_name, cluster_id)
+ self.logger.debug(logging_text + text)
+ await asyncio.wait(task_dependency, timeout=3600)
+
db_k8scluster = self.db.get_one("k8sclusters", {"_id": cluster_id}, fail_on_empty=False)
if not db_k8scluster:
raise LcmException("K8s cluster {} cannot be found".format(cluster_id))
+
k8s_id = deep_get(db_k8scluster, ("_admin", cluster_type, "id"))
if not k8s_id:
- raise LcmException("K8s cluster '{}' has not been initilized for '{}'".format(cluster_id, cluster_type))
+ if cluster_type == "helm-chart-v3":
+ try:
+ # backward compatibility for existing clusters that have not been initialized for helm v3
+ k8s_credentials = yaml.safe_dump(db_k8scluster.get("credentials"))
+ k8s_id, uninstall_sw = await self.k8sclusterhelm3.init_env(k8s_credentials,
+ reuse_cluster_uuid=cluster_id)
+ db_k8scluster_update = {}
+ db_k8scluster_update["_admin.helm-chart-v3.error_msg"] = None
+ db_k8scluster_update["_admin.helm-chart-v3.id"] = k8s_id
+ db_k8scluster_update["_admin.helm-chart-v3.created"] = uninstall_sw
+ db_k8scluster_update["_admin.helm-chart-v3.operationalState"] = "ENABLED"
+ self.update_db_2("k8sclusters", cluster_id, db_k8scluster_update)
+ except Exception as e:
+ self.logger.error(logging_text + "error initializing helm-v3 cluster: {}".format(str(e)))
+ raise LcmException("K8s cluster '{}' has not been initialized for '{}'".format(cluster_id,
+ cluster_type))
+ else:
+ raise LcmException("K8s cluster '{}' has not been initialized for '{}'".
+ format(cluster_id, cluster_type))
k8scluster_id_2_uuic[cluster_type][cluster_id] = k8s_id
return k8s_id
index = 0
updated_cluster_list = []
+ updated_v3_cluster_list = []
for vnfr_data in db_vnfrs.values():
- for kdur in get_iterable(vnfr_data, "kdur"):
- desc_params = self._format_additional_params(kdur.get("additionalParams"))
+ for kdu_index, kdur in enumerate(get_iterable(vnfr_data, "kdur")):
+ # Step 0: Prepare and set parameters
+ desc_params = parse_yaml_strings(kdur.get("additionalParams"))
vnfd_id = vnfr_data.get('vnfd-id')
+ vnfd_with_id = find_in_list(db_vnfds, lambda vnfd: vnfd["_id"] == vnfd_id)
+ kdud = next(kdud for kdud in vnfd_with_id["kdu"] if kdud["name"] == kdur["kdu-name"])
namespace = kdur.get("k8s-namespace")
if kdur.get("helm-chart"):
- kdumodel = kdur["helm-chart"]
- k8sclustertype = "helm-chart"
+ kdumodel = kdur["helm-chart"]["kdu-model-locator"]
+ # Default version: helm3, if helm-version is v2 assign v2
+ k8sclustertype = "helm-chart-v3"
+ self.logger.debug("kdur: {}".format(kdur))
+ if kdur.get("helm-version") and kdur.get("helm-version") == "v2":
+ k8sclustertype = "helm-chart"
elif kdur.get("juju-bundle"):
- kdumodel = kdur["juju-bundle"]
+ kdumodel = kdur["juju-bundle"]["kdu-model-locator"]
k8sclustertype = "juju-bundle"
else:
raise LcmException("kdu type for kdu='{}.{}' is neither helm-chart nor "
format(vnfr_data["member-vnf-index-ref"], kdur["kdu-name"]))
# check if kdumodel is a file and exists
try:
- storage = deep_get(db_vnfds.get(vnfd_id), ('_admin', 'storage'))
+ vnfd_with_id = find_in_list(db_vnfds, lambda vnfd: vnfd["_id"] == vnfd_id)
+ storage = deep_get(vnfd_with_id, ('_admin', 'storage'))
if storage and storage.get('pkg-dir'): # may be not present if vnfd has not artifacts
# path format: /vnfdid/pkkdir/helm-charts|juju-bundles/kdumodel
filename = '{}/{}/{}s/{}'.format(storage["folder"], storage["pkg-dir"], k8sclustertype,
k8s_cluster_id = kdur["k8s-cluster"]["id"]
step = "Synchronize repos for k8s cluster '{}'".format(k8s_cluster_id)
- cluster_uuid = _get_cluster_id(k8s_cluster_id, k8sclustertype)
+ cluster_uuid = await _get_cluster_id(k8s_cluster_id, k8sclustertype)
- if k8sclustertype == "helm-chart" and cluster_uuid not in updated_cluster_list:
+ # Synchronize repos
+ if (k8sclustertype == "helm-chart" and cluster_uuid not in updated_cluster_list)\
+ or (k8sclustertype == "helm-chart-v3" and cluster_uuid not in updated_v3_cluster_list):
del_repo_list, added_repo_dict = await asyncio.ensure_future(
- self.k8sclusterhelm.synchronize_repos(cluster_uuid=cluster_uuid))
+ self.k8scluster_map[k8sclustertype].synchronize_repos(cluster_uuid=cluster_uuid))
if del_repo_list or added_repo_dict:
- unset = {'_admin.helm_charts_added.' + item: None for item in del_repo_list}
- updated = {'_admin.helm_charts_added.' +
- item: name for item, name in added_repo_dict.items()}
- self.logger.debug(logging_text + "repos synchronized on k8s cluster '{}' to_delete: {}, "
- "to_add: {}".format(k8s_cluster_id, del_repo_list,
- added_repo_dict))
+ if k8sclustertype == "helm-chart":
+ unset = {'_admin.helm_charts_added.' + item: None for item in del_repo_list}
+ updated = {'_admin.helm_charts_added.' +
+ item: name for item, name in added_repo_dict.items()}
+ updated_cluster_list.append(cluster_uuid)
+ elif k8sclustertype == "helm-chart-v3":
+ unset = {'_admin.helm_charts_v3_added.' + item: None for item in del_repo_list}
+ updated = {'_admin.helm_charts_v3_added.' +
+ item: name for item, name in added_repo_dict.items()}
+ updated_v3_cluster_list.append(cluster_uuid)
+ self.logger.debug(logging_text + "repos synchronized on k8s cluster "
+ "'{}' to_delete: {}, to_add: {}".
+ format(k8s_cluster_id, del_repo_list, added_repo_dict))
self.db.set_one("k8sclusters", {"_id": k8s_cluster_id}, updated, unset=unset)
- updated_cluster_list.append(cluster_uuid)
+ # Instantiate kdu
step = "Instantiating KDU {}.{} in k8s cluster {}".format(vnfr_data["member-vnf-index-ref"],
kdur["kdu-name"], k8s_cluster_id)
-
- k8s_instace_info = {"kdu-instance": None,
- "k8scluster-uuid": cluster_uuid,
- "k8scluster-type": k8sclustertype,
- "member-vnf-index": vnfr_data["member-vnf-index-ref"],
- "kdu-name": kdur["kdu-name"],
- "kdu-model": kdumodel,
- "namespace": namespace}
+ k8s_instance_info = {"kdu-instance": None,
+ "k8scluster-uuid": cluster_uuid,
+ "k8scluster-type": k8sclustertype,
+ "member-vnf-index": vnfr_data["member-vnf-index-ref"],
+ "kdu-name": kdur["kdu-name"],
+ "kdu-model": kdumodel,
+ "namespace": namespace}
db_path = "_admin.deployed.K8s.{}".format(index)
- db_nsr_update[db_path] = k8s_instace_info
+ db_nsr_update[db_path] = k8s_instance_info
self.update_db_2("nsrs", nsr_id, db_nsr_update)
-
- db_dict = {"collection": "nsrs",
- "filter": {"_id": nsr_id},
- "path": db_path}
-
+ vnfd_with_id = find_in_list(db_vnfds, lambda vnf: vnf["_id"] == vnfd_id)
task = asyncio.ensure_future(
- self.k8scluster_map[k8sclustertype].install(cluster_uuid=cluster_uuid, kdu_model=kdumodel,
- atomic=True, params=desc_params,
- db_dict=db_dict, timeout=600,
- kdu_name=kdur["kdu-name"], namespace=namespace))
-
- task.add_done_callback(partial(self._write_db_callback, item="nsrs", _id=nsr_id,
- on_done=db_path + ".kdu-instance",
- on_exc=db_path + ".detailed-status"))
+ self._install_kdu(nsr_id, db_path, vnfr_data, kdu_index, kdud, vnfd_with_id,
+ k8s_instance_info, k8params=desc_params, timeout=600))
self.lcm_tasks.register("ns", nsr_id, nslcmop_id, "instantiate_KDU-{}".format(index), task)
task_instantiation_info[task] = "Deploying KDU {}".format(kdur["kdu-name"])
vca_type = "native_charm"
elif ee_item.get("helm-chart"):
vca_name = ee_item['helm-chart']
- vca_type = "helm"
+ if ee_item.get("helm-version") and ee_item.get("helm-version") == "v2":
+ vca_type = "helm"
+ else:
+ vca_type = "helm-v3"
else:
self.logger.debug(logging_text + "skipping non juju neither charm configuration")
continue
db_nsr["_admin"]["deployed"]["VCA"].append(vca_deployed)
+ self.logger.debug("N2VC > NSR_ID > {}".format(nsr_id))
+ self.logger.debug("N2VC > DB_NSR > {}".format(db_nsr))
+ self.logger.debug("N2VC > VCA_DEPLOYED > {}".format(vca_deployed))
+
# Launch task
task_n2vc = asyncio.ensure_future(
self.instantiate_N2VC(
task_instantiation_info[task_n2vc] = self.task_name_deploy_vca + " {}.{}".format(
member_vnf_index or "", vdu_id or "")
- @staticmethod
- def _get_terminate_config_primitive(primitive_list, vca_deployed):
- """ Get a sorted terminate config primitive list. In case ee_descriptor_id is present at vca_deployed,
- it get only those primitives for this execution envirom"""
-
- primitive_list = primitive_list or []
- # filter primitives by ee_descriptor_id
- ee_descriptor_id = vca_deployed.get("ee_descriptor_id")
- primitive_list = [p for p in primitive_list if p.get("execution-environment-ref") == ee_descriptor_id]
-
- if primitive_list:
- primitive_list.sort(key=lambda val: int(val['seq']))
-
- return primitive_list
-
@staticmethod
def _create_nslcmop(nsr_id, operation, params):
"""
# 'detailed-status' : status message
# 'operationType': may be any type, in the case of scaling: 'PRE-SCALE' | 'POST-SCALE'
# Status and operation type are currently only used for 'scale', but NOT for 'terminate' sub-operations.
- def _add_suboperation(self, db_nslcmop, vnf_index, vdu_id, vdu_count_index, vdu_name, primitive,
+ def _add_suboperation(self, db_nslcmop, vnf_index, vdu_id, vdu_count_index, vdu_name, primitive,
mapped_primitive_params, operationState=None, detailed_status=None, operationType=None,
RO_nsr_id=None, RO_scaling_info=None):
if not db_nslcmop:
# execute terminate_primitives
if exec_primitives:
- terminate_primitives = self._get_terminate_config_primitive(
- config_descriptor.get("terminate-config-primitive"), vca_deployed)
+ terminate_primitives = get_ee_sorted_terminate_config_primitive_list(
+ config_descriptor.get("terminate-config-primitive"), vca_deployed.get("ee_descriptor_id"))
vdu_id = vca_deployed.get("vdu_id")
vdu_count_index = vca_deployed.get("vdu_count_index")
vdu_name = vca_deployed.get("vdu_name")
self.logger.debug(logging_text + stage[0])
stage[1] = "Looking execution environment that needs terminate."
self.logger.debug(logging_text + stage[1])
- # self.logger.debug("nsr_deployed: {}".format(nsr_deployed))
+
for vca_index, vca in enumerate(get_iterable(nsr_deployed, "VCA")):
- self.logger.debug("vca_index: {}, vca: {}".format(vca_index, vca))
config_descriptor = None
if not vca or not vca.get("ee_id"):
continue
vca_type = vca.get("type")
exec_terminate_primitives = (not operation_params.get("skip_terminate_primitives") and
vca.get("needed_terminate"))
- # For helm we must destroy_ee
- destroy_ee = "True" if vca_type == "helm" else "False"
+ # For helm we must destroy_ee. Also for native_charm, as juju_model cannot be deleted if there are
+ # pending native charms
+ destroy_ee = True if vca_type in ("helm", "helm-v3", "native_charm") else False
+ # self.logger.debug(logging_text + "vca_index: {}, ee_id: {}, vca_type: {} destroy_ee: {}".format(
+ # vca_index, vca.get("ee_id"), vca_type, destroy_ee))
task = asyncio.ensure_future(
self.destroy_N2VC(logging_text, db_nslcmop, vca, config_descriptor, vca_index,
destroy_ee, exec_terminate_primitives))
# wait for pending tasks of terminate primitives
if tasks_dict_info:
- self.logger.debug(logging_text + 'Waiting for terminate primitive pending tasks...')
+ self.logger.debug(logging_text + 'Waiting for tasks {}'.format(list(tasks_dict_info.keys())))
error_list = await self._wait_for_tasks(logging_text, tasks_dict_info,
min(self.timeout_charm_delete, timeout_ns_terminate),
stage, nslcmop_id)
+ tasks_dict_info.clear()
if error_list:
return # raise LcmException("; ".join(error_list))
- tasks_dict_info.clear()
# remove All execution environments at once
stage[0] = "Stage 3/3 delete all."
if error_list:
error_detail = "; ".join(error_list)
# self.logger.error(logging_text + error_detail)
- error_description_nslcmop = 'Stage: {}. Detail: {}'.format(stage[0], error_detail)
- error_description_nsr = 'Operation: TERMINATING.{}, Stage {}.'.format(nslcmop_id, stage[0])
+ error_description_nslcmop = '{} Detail: {}'.format(stage[0], error_detail)
+ error_description_nsr = 'Operation: TERMINATING.{}, {}.'.format(nslcmop_id, stage[0])
db_nsr_update["operational-status"] = "failed"
db_nsr_update["detailed-status"] = error_description_nsr + " Detail: " + error_detail
operation_state=nslcmop_operation_state,
other_update=db_nslcmop_update,
)
+ if ns_state == "NOT_INSTANTIATED":
+ try:
+ self.db.set_list("vnfrs", {"nsr-id-ref": nsr_id}, {"_admin.nsState": "NOT_INSTANTIATED"})
+ except DbException as e:
+ self.logger.warn(logging_text + 'Error writing VNFR status for nsr-id-ref: {} -> {}'.
+ format(nsr_id, e))
if operation_params:
autoremove = operation_params.get("autoremove", False)
if nslcmop_operation_state:
error_list.append(created_tasks_info[task])
error_detail_list.append(new_error)
if isinstance(exc, (str, DbException, N2VCException, ROclient.ROClientException, LcmException,
- K8sException)):
+ K8sException, NgRoException)):
self.logger.error(logging_text + new_error)
else:
exc_traceback = "".join(traceback.format_exception(None, exc, exc.__traceback__))
- self.logger.error(logging_text + created_tasks_info[task] + exc_traceback)
+ self.logger.error(logging_text + created_tasks_info[task] + " " + exc_traceback)
else:
self.logger.debug(logging_text + created_tasks_info[task] + ": Done")
stage[1] = "{}/{}.".format(num_done, num_tasks)
format(param_name, primitive_desc["name"]))
if isinstance(calculated_params[param_name], (dict, list, tuple)):
- calculated_params[param_name] = yaml.safe_dump(calculated_params[param_name], default_flow_style=True,
- width=256)
+ calculated_params[param_name] = yaml.safe_dump(calculated_params[param_name],
+ default_flow_style=True, width=256)
elif isinstance(calculated_params[param_name], str) and calculated_params[param_name].startswith("!!yaml "):
calculated_params[param_name] = calculated_params[param_name][7:]
+ if parameter.get("data-type") == "INTEGER":
+ try:
+ calculated_params[param_name] = int(calculated_params[param_name])
+ except ValueError: # error converting string to int
+ raise LcmException(
+ "Parameter {} of primitive {} must be integer".format(param_name, primitive_desc["name"]))
+ elif parameter.get("data-type") == "BOOLEAN":
+ calculated_params[param_name] = not ((str(calculated_params[param_name])).lower() == 'false')
# add always ns_config_info if primitive name is config
if primitive_desc["name"] == "config":
raise LcmException("charm for member_vnf_index={} vdu_id={}.{} kdu_name={} execution-environment-list.id={}"
" is not deployed".format(member_vnf_index, vdu_id, vdu_count_index, kdu_name,
ee_descriptor_id))
-
# get ee_id
ee_id = vca.get("ee_id")
vca_type = vca.get("type", "lxc_proxy_charm") # default value for backward compatibility - proxy charm
.format(member_vnf_index, vdu_id, kdu_name, vdu_count_index))
return ee_id, vca_type
- async def _ns_execute_primitive(self, ee_id, primitive, primitive_params, retries=0,
- retries_interval=30, timeout=None,
- vca_type=None, db_dict=None) -> (str, str):
+ async def _ns_execute_primitive(self, ee_id, primitive, primitive_params, retries=0, retries_interval=30,
+ timeout=None, vca_type=None, db_dict=None) -> (str, str):
try:
if primitive == "config":
primitive_params = {"params": primitive_params}
return 'FAIL', 'Error executing action {}: {}'.format(primitive, e)
async def action(self, nsr_id, nslcmop_id):
-
# Try to lock HA task here
task_is_locked_by_me = self.lcm_tasks.lock_HA('ns', 'nslcmops', nslcmop_id)
if not task_is_locked_by_me:
# look for primitive
config_primitive_desc = descriptor_configuration = None
if vdu_id:
- for vdu in get_iterable(db_vnfd, "vdu"):
- if vdu_id == vdu["id"]:
- descriptor_configuration = vdu.get("vdu-configuration")
- break
+ descriptor_configuration = get_vdu_configuration(db_vnfd, vdu_id)
elif kdu_name:
- for kdu in get_iterable(db_vnfd, "kdu"):
- if kdu_name == kdu["name"]:
- descriptor_configuration = kdu.get("kdu-configuration")
- break
+ descriptor_configuration = get_kdu_configuration(db_vnfd, kdu_name)
elif vnf_index:
- descriptor_configuration = db_vnfd.get("vnf-configuration")
+ descriptor_configuration = get_vnf_configuration(db_vnfd)
else:
descriptor_configuration = db_nsd.get("ns-configuration")
config_primitive_desc = config_primitive
break
- if not config_primitive_desc and not (kdu_name and primitive in ("upgrade", "rollback", "status")):
- raise LcmException("Primitive {} not found at [ns|vnf|vdu]-configuration:config-primitive ".
- format(primitive))
- primitive_name = config_primitive_desc.get("execution-environment-primitive", primitive)
- ee_descriptor_id = config_primitive_desc.get("execution-environment-ref")
+ if not config_primitive_desc:
+ if not (kdu_name and primitive in ("upgrade", "rollback", "status")):
+ raise LcmException("Primitive {} not found at [ns|vnf|vdu]-configuration:config-primitive ".
+ format(primitive))
+ primitive_name = primitive
+ ee_descriptor_id = None
+ else:
+ primitive_name = config_primitive_desc.get("execution-environment-primitive", primitive)
+ ee_descriptor_id = config_primitive_desc.get("execution-environment-ref")
if vnf_index:
if vdu_id:
vdur = next((x for x in db_vnfr["vdur"] if x["vdu-id-ref"] == vdu_id), None)
- desc_params = self._format_additional_params(vdur.get("additionalParams"))
+ desc_params = parse_yaml_strings(vdur.get("additionalParams"))
elif kdu_name:
kdur = next((x for x in db_vnfr["kdur"] if x["kdu-name"] == kdu_name), None)
- desc_params = self._format_additional_params(kdur.get("additionalParams"))
+ desc_params = parse_yaml_strings(kdur.get("additionalParams"))
else:
- desc_params = self._format_additional_params(db_vnfr.get("additionalParamsForVnf"))
+ desc_params = parse_yaml_strings(db_vnfr.get("additionalParamsForVnf"))
else:
- desc_params = self._format_additional_params(db_nsr.get("additionalParamsForNs"))
-
- if kdu_name:
- kdu_action = True if not deep_get(kdu, ("kdu-configuration", "juju")) else False
+ desc_params = parse_yaml_strings(db_nsr.get("additionalParamsForNs"))
+ if kdu_name and get_kdu_configuration(db_vnfd, kdu_name):
+ kdu_configuration = get_kdu_configuration(db_vnfd, kdu_name)
+ actions = set()
+ for primitive in kdu_configuration["initial-config-primitive"]:
+ actions.add(primitive["name"])
+ for primitive in kdu_configuration["config-primitive"]:
+ actions.add(primitive["name"])
+ kdu_action = True if primitive_name in actions else False
# TODO check if ns is in a proper status
if kdu_name and (primitive_name in ("upgrade", "rollback", "status") or kdu_action):
detailed_status = ''
nslcmop_operation_state = 'FAILED'
else:
- ee_id, vca_type = self._look_for_deployed_vca(nsr_deployed["VCA"],
- member_vnf_index=vnf_index,
- vdu_id=vdu_id,
- vdu_count_index=vdu_count_index,
+ ee_id, vca_type = self._look_for_deployed_vca(nsr_deployed["VCA"], member_vnf_index=vnf_index,
+ vdu_id=vdu_id, vdu_count_index=vdu_count_index,
ee_descriptor_id=ee_descriptor_id)
db_nslcmop_notif = {"collection": "nslcmops",
"filter": {"_id": nslcmop_id},
other_update=db_nsr_update
)
- self._write_op_status(
- op_id=nslcmop_id,
- stage="",
- error_message=error_description_nslcmop,
- operation_state=nslcmop_operation_state,
- other_update=db_nslcmop_update,
- )
+ self._write_op_status(op_id=nslcmop_id, stage="", error_message=error_description_nslcmop,
+ operation_state=nslcmop_operation_state, other_update=db_nslcmop_update)
if nslcmop_operation_state:
try:
return nslcmop_operation_state, detailed_status
async def scale(self, nsr_id, nslcmop_id):
-
# Try to lock HA task here
task_is_locked_by_me = self.lcm_tasks.lock_HA('ns', 'nslcmops', nslcmop_id)
if not task_is_locked_by_me:
return
logging_text = "Task ns={} scale={} ".format(nsr_id, nslcmop_id)
+ stage = ['', '', '']
+ # ^ stage, step, VIM progress
self.logger.debug(logging_text + "Enter")
# get all needed from database
db_nsr = None
- db_nslcmop = None
db_nslcmop_update = {}
- nslcmop_operation_state = None
db_nsr_update = {}
exc = None
# in case of error, indicates what part of scale was failed to put nsr at error status
scale_process = None
old_operational_status = ""
old_config_status = ""
- vnfr_scaled = False
try:
# wait for any previous tasks in process
step = "Waiting for previous operations to terminate"
await self.lcm_tasks.waitfor_related_HA('ns', 'nslcmops', nslcmop_id)
-
- self._write_ns_status(
- nsr_id=nsr_id,
- ns_state=None,
- current_operation="SCALING",
- current_operation_id=nslcmop_id
- )
+ self._write_ns_status(nsr_id=nsr_id, ns_state=None,
+ current_operation="SCALING", current_operation_id=nslcmop_id)
step = "Getting nslcmop from database"
self.logger.debug(step + " after having waited for previous tasks to be completed")
db_nslcmop = self.db.get_one("nslcmops", {"_id": nslcmop_id})
+
step = "Getting nsr from database"
db_nsr = self.db.get_one("nsrs", {"_id": nsr_id})
-
old_operational_status = db_nsr["operational-status"]
old_config_status = db_nsr["config-status"]
+
step = "Parsing scaling parameters"
- # self.logger.debug(step)
db_nsr_update["operational-status"] = "scaling"
self.update_db_2("nsrs", nsr_id, db_nsr_update)
nsr_deployed = db_nsr["_admin"].get("deployed")
# vdu_name = db_nslcmop["operationParams"].get("vdu_name")
#######
- RO_nsr_id = nsr_deployed["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")
-
# for backward compatibility
if nsr_deployed and isinstance(nsr_deployed.get("VCA"), dict):
nsr_deployed["VCA"] = list(nsr_deployed["VCA"].values())
step = "Getting vnfr from database"
db_vnfr = self.db.get_one("vnfrs", {"member-vnf-index-ref": vnf_index, "nsr-id-ref": nsr_id})
+
step = "Getting vnfd from database"
db_vnfd = self.db.get_one("vnfds", {"_id": db_vnfr["vnfd-id"]})
step = "Getting scaling-group-descriptor"
- for scaling_descriptor in db_vnfd["scaling-group-descriptor"]:
- if scaling_descriptor["name"] == scaling_group:
- break
- else:
+ scaling_descriptor = find_in_list(
+ get_scaling_aspect(
+ db_vnfd
+ ),
+ lambda scale_desc: scale_desc["name"] == scaling_group
+ )
+ if not scaling_descriptor:
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
-
- # TODO check if ns is in a proper status
step = "Sending scale order to VIM"
+ # TODO check if ns is in a proper status
nb_scale_op = 0
if not db_nsr["_admin"].get("scaling-group"):
self.update_db_2("nsrs", nsr_id, {"_admin.scaling-group": [{"name": scaling_group, "nb-scale-op": 0}]})
RO_scaling_info = []
vdu_scaling_info = {"scaling_group_name": scaling_group, "vdu": []}
if scaling_type == "SCALE_OUT":
+ if "aspect-delta-details" not in scaling_descriptor:
+ raise LcmException(
+ "Aspect delta details not fount in scaling descriptor {}".format(
+ scaling_descriptor["name"]
+ )
+ )
# count if max-instance-count is reached
- max_instance_count = scaling_descriptor.get("max-instance-count", 10)
- # self.logger.debug("MAX_INSTANCE_COUNT is {}".format(max_instance_count))
- if nb_scale_op >= max_instance_count:
- raise LcmException("reached the limit of {} (max-instance-count) "
- "scaling-out operations for the "
- "scaling-group-descriptor '{}'".format(nb_scale_op, scaling_group))
-
- nb_scale_op += 1
+ deltas = scaling_descriptor.get("aspect-delta-details")["deltas"]
+
vdu_scaling_info["scaling_direction"] = "OUT"
vdu_scaling_info["vdu-create"] = {}
- for vdu_scale_info in scaling_descriptor["vdu"]:
- RO_scaling_info.append({"osm_vdu_id": vdu_scale_info["vdu-id-ref"], "member-vnf-index": vnf_index,
- "type": "create", "count": vdu_scale_info.get("count", 1)})
- vdu_scaling_info["vdu-create"][vdu_scale_info["vdu-id-ref"]] = vdu_scale_info.get("count", 1)
+ for delta in deltas:
+ for vdu_delta in delta["vdu-delta"]:
+ vdud = get_vdu(db_vnfd, vdu_delta["id"])
+ vdu_index = get_vdu_index(db_vnfr, vdu_delta["id"])
+ cloud_init_text = self._get_vdu_cloud_init_content(vdud, db_vnfd)
+ if cloud_init_text:
+ additional_params = self._get_vdu_additional_params(db_vnfr, vdud["id"]) or {}
+ cloud_init_list = []
+
+ vdu_profile = get_vdu_profile(db_vnfd, vdu_delta["id"])
+ max_instance_count = 10
+ if vdu_profile and "max-number-of-instances" in vdu_profile:
+ max_instance_count = vdu_profile.get("max-number-of-instances", 10)
+
+ deafult_instance_num = get_number_of_instances(db_vnfd, vdud["id"])
+
+ nb_scale_op += vdu_delta.get("number-of-instances", 1)
+
+ if nb_scale_op + deafult_instance_num > max_instance_count:
+ raise LcmException(
+ "reached the limit of {} (max-instance-count) "
+ "scaling-out operations for the "
+ "scaling-group-descriptor '{}'".format(nb_scale_op, scaling_group)
+ )
+ for x in range(vdu_delta.get("number-of-instances", 1)):
+ if cloud_init_text:
+ # TODO Information of its own ip is not available because db_vnfr is not updated.
+ additional_params["OSM"] = get_osm_params(
+ db_vnfr,
+ vdu_delta["id"],
+ vdu_index + x
+ )
+ cloud_init_list.append(
+ self._parse_cloud_init(
+ cloud_init_text,
+ additional_params,
+ db_vnfd["id"],
+ vdud["id"]
+ )
+ )
+ RO_scaling_info.append(
+ {
+ "osm_vdu_id": vdu_delta["id"],
+ "member-vnf-index": vnf_index,
+ "type": "create",
+ "count": vdu_delta.get("number-of-instances", 1)
+ }
+ )
+ if cloud_init_list:
+ RO_scaling_info[-1]["cloud_init"] = cloud_init_list
+ vdu_scaling_info["vdu-create"][vdu_delta["id"]] = vdu_delta.get("number-of-instances", 1)
elif scaling_type == "SCALE_IN":
- # count if min-instance-count is reached
- min_instance_count = 0
if "min-instance-count" in scaling_descriptor and scaling_descriptor["min-instance-count"] is not None:
min_instance_count = int(scaling_descriptor["min-instance-count"])
- if nb_scale_op <= min_instance_count:
- raise LcmException("reached the limit of {} (min-instance-count) scaling-in operations for the "
- "scaling-group-descriptor '{}'".format(nb_scale_op, scaling_group))
- nb_scale_op -= 1
+
vdu_scaling_info["scaling_direction"] = "IN"
vdu_scaling_info["vdu-delete"] = {}
- for vdu_scale_info in scaling_descriptor["vdu"]:
- RO_scaling_info.append({"osm_vdu_id": vdu_scale_info["vdu-id-ref"], "member-vnf-index": vnf_index,
- "type": "delete", "count": vdu_scale_info.get("count", 1)})
- vdu_scaling_info["vdu-delete"][vdu_scale_info["vdu-id-ref"]] = vdu_scale_info.get("count", 1)
+ deltas = scaling_descriptor.get("aspect-delta-details")["deltas"]
+ for delta in deltas:
+ for vdu_delta in delta["vdu-delta"]:
+ min_instance_count = 0
+ vdu_profile = get_vdu_profile(db_vnfd, vdu_delta["id"])
+ if vdu_profile and "min-number-of-instances" in vdu_profile:
+ min_instance_count = vdu_profile["min-number-of-instances"]
+
+ deafult_instance_num = get_number_of_instances(db_vnfd, vdu_delta["id"])
+
+ nb_scale_op -= vdu_delta.get("number-of-instances", 1)
+ if nb_scale_op + deafult_instance_num < min_instance_count:
+ raise LcmException(
+ "reached the limit of {} (min-instance-count) scaling-in operations for the "
+ "scaling-group-descriptor '{}'".format(nb_scale_op, scaling_group)
+ )
+ RO_scaling_info.append({"osm_vdu_id": vdu_delta["id"], "member-vnf-index": vnf_index,
+ "type": "delete", "count": vdu_delta.get("number-of-instances", 1)})
+ vdu_scaling_info["vdu-delete"][vdu_delta["id"]] = vdu_delta.get("number-of-instances", 1)
# update VDU_SCALING_INFO with the VDUs to delete ip_addresses
- vdu_create = vdu_scaling_info.get("vdu-create")
vdu_delete = copy(vdu_scaling_info.get("vdu-delete"))
if vdu_scaling_info["scaling_direction"] == "IN":
for vdur in reversed(db_vnfr["vdur"]):
if vdu_delete.get(vdur["vdu-id-ref"]):
vdu_delete[vdur["vdu-id-ref"]] -= 1
vdu_scaling_info["vdu"].append({
- "name": vdur["name"],
+ "name": vdur.get("name") or vdur.get("vdu-name"),
"vdu_id": vdur["vdu-id-ref"],
"interface": []
})
"ip_address": interface["ip-address"],
"mac_address": interface.get("mac-address"),
})
- vdu_delete = vdu_scaling_info.pop("vdu-delete")
+ # vdu_delete = vdu_scaling_info.pop("vdu-delete")
# PRE-SCALE BEGIN
step = "Executing pre-scale vnf-config-primitive"
scale_process = None
# PRE-SCALE END
+ db_nsr_update["_admin.scaling-group.{}.nb-scale-op".format(admin_scale_index)] = nb_scale_op
+ db_nsr_update["_admin.scaling-group.{}.time".format(admin_scale_index)] = time()
+
# SCALE RO - BEGIN
- # Should this block be skipped if 'RO_nsr_id' == None ?
- # if (RO_nsr_id and RO_scaling_info):
if RO_scaling_info:
scale_process = "RO"
- # Scale RO retry check: Check if this sub-operation has been executed before
- op_index = self._check_or_add_scale_suboperation(
- db_nslcmop, vnf_index, None, None, 'SCALE-RO', RO_nsr_id, RO_scaling_info)
- if op_index == self.SUBOPERATION_STATUS_SKIP:
- # Skip sub-operation
- result = 'COMPLETED'
- result_detail = 'Done'
- self.logger.debug(logging_text + "Skipped sub-operation RO, result {} {}".format(
- result, result_detail))
- else:
- if op_index == self.SUBOPERATION_STATUS_NEW:
- # New sub-operation: Get index of this sub-operation
- op_index = len(db_nslcmop.get('_admin', {}).get('operations')) - 1
- self.logger.debug(logging_text + "New sub-operation RO")
- else:
- # retry: Get registered params for this existing sub-operation
- op = db_nslcmop.get('_admin', {}).get('operations', [])[op_index]
- RO_nsr_id = op.get('RO_nsr_id')
- RO_scaling_info = op.get('RO_scaling_info')
- self.logger.debug(logging_text + "Sub-operation RO retry for primitive {}".format(
- vnf_config_primitive))
-
- RO_desc = await self.RO.create_action("ns", RO_nsr_id, {"vdu-scaling": RO_scaling_info})
- db_nsr_update["_admin.scaling-group.{}.nb-scale-op".format(admin_scale_index)] = nb_scale_op
- db_nsr_update["_admin.scaling-group.{}.time".format(admin_scale_index)] = time()
- # wait until ready
- RO_nslcmop_id = RO_desc["instance_action_id"]
- db_nslcmop_update["_admin.deploy.RO"] = RO_nslcmop_id
-
- RO_task_done = False
- step = detailed_status = "Waiting RO_task_id={} to complete the scale action.".format(RO_nslcmop_id)
- detailed_status_old = None
- self.logger.debug(logging_text + step)
-
- deployment_timeout = 1 * 3600 # One hour
- while deployment_timeout > 0:
- if not RO_task_done:
- desc = await self.RO.show("ns", item_id_name=RO_nsr_id, extra_item="action",
- extra_item_id=RO_nslcmop_id)
-
- # deploymentStatus
- self._on_update_ro_db(nsrs_id=nsr_id, ro_descriptor=desc)
-
- ns_status, ns_status_info = self.RO.check_action_status(desc)
- if ns_status == "ERROR":
- raise ROclient.ROClientException(ns_status_info)
- elif ns_status == "BUILD":
- detailed_status = step + "; {}".format(ns_status_info)
- elif ns_status == "ACTIVE":
- RO_task_done = True
- step = detailed_status = "Waiting ns ready at RO. RO_id={}".format(RO_nsr_id)
- self.logger.debug(logging_text + step)
- else:
- assert False, "ROclient.check_action_status returns unknown {}".format(ns_status)
- else:
-
- if ns_status == "ERROR":
- raise ROclient.ROClientException(ns_status_info)
- elif ns_status == "BUILD":
- detailed_status = step + "; {}".format(ns_status_info)
- elif ns_status == "ACTIVE":
- step = detailed_status = \
- "Waiting for management IP address reported by the VIM. Updating VNFRs"
- if not vnfr_scaled:
- self.scale_vnfr(db_vnfr, vdu_create=vdu_create, vdu_delete=vdu_delete)
- vnfr_scaled = True
- try:
- desc = await self.RO.show("ns", RO_nsr_id)
-
- # deploymentStatus
- self._on_update_ro_db(nsrs_id=nsr_id, ro_descriptor=desc)
-
- # nsr_deployed["nsr_ip"] = RO.get_ns_vnf_info(desc)
- self.ns_update_vnfr({db_vnfr["member-vnf-index-ref"]: db_vnfr}, desc)
- break
- except LcmExceptionNoMgmtIP:
- pass
- else:
- assert False, "ROclient.check_ns_status returns unknown {}".format(ns_status)
- if detailed_status != detailed_status_old:
- self._update_suboperation_status(
- db_nslcmop, op_index, 'COMPLETED', detailed_status)
- detailed_status_old = db_nslcmop_update["detailed-status"] = detailed_status
- self.update_db_2("nslcmops", nslcmop_id, db_nslcmop_update)
-
- await asyncio.sleep(5, loop=self.loop)
- deployment_timeout -= 5
- if deployment_timeout <= 0:
- self._update_suboperation_status(
- db_nslcmop, nslcmop_id, op_index, 'FAILED', "Timeout when waiting for ns to get ready")
- raise ROclient.ROClientException("Timeout waiting ns to be ready")
-
- # update VDU_SCALING_INFO with the obtained ip_addresses
- if vdu_scaling_info["scaling_direction"] == "OUT":
- for vdur in reversed(db_vnfr["vdur"]):
- if vdu_scaling_info["vdu-create"].get(vdur["vdu-id-ref"]):
- vdu_scaling_info["vdu-create"][vdur["vdu-id-ref"]] -= 1
- vdu_scaling_info["vdu"].append({
- "name": vdur["name"],
- "vdu_id": vdur["vdu-id-ref"],
- "interface": []
- })
- for interface in vdur["interfaces"]:
- vdu_scaling_info["vdu"][-1]["interface"].append({
- "name": interface["name"],
- "ip_address": interface["ip-address"],
- "mac_address": interface.get("mac-address"),
- })
- del vdu_scaling_info["vdu-create"]
-
- self._update_suboperation_status(db_nslcmop, op_index, 'COMPLETED', 'Done')
- # SCALE RO - END
+ if self.ro_config.get("ng"):
+ await self._scale_ng_ro(logging_text, db_nsr, db_nslcmop, db_vnfr, vdu_scaling_info, stage)
+ vdu_scaling_info.pop("vdu-create", None)
+ vdu_scaling_info.pop("vdu-delete", None)
scale_process = None
if db_nsr_update:
else old_operational_status
db_nsr_update["config-status"] = old_config_status
return
- except (ROclient.ROClientException, DbException, LcmException) as e:
+ except (ROclient.ROClientException, DbException, LcmException, NgRoException) as e:
self.logger.error(logging_text + "Exit Exception {}".format(e))
exc = e
except asyncio.CancelledError:
exc = traceback.format_exc()
self.logger.critical(logging_text + "Exit Exception {} {}".format(type(e).__name__, e), exc_info=True)
finally:
- self._write_ns_status(
- nsr_id=nsr_id,
- ns_state=None,
- current_operation="IDLE",
- current_operation_id=None
- )
+ self._write_ns_status(nsr_id=nsr_id, ns_state=None, current_operation="IDLE", current_operation_id=None)
if exc:
db_nslcmop_update["detailed-status"] = error_description_nslcmop = "FAILED {}: {}".format(step, exc)
nslcmop_operation_state = "FAILED"
nslcmop_operation_state = "COMPLETED"
db_nslcmop_update["detailed-status"] = "Done"
- self._write_op_status(
- op_id=nslcmop_id,
- stage="",
- error_message=error_description_nslcmop,
- operation_state=nslcmop_operation_state,
- other_update=db_nslcmop_update,
- )
+ self._write_op_status(op_id=nslcmop_id, stage="", error_message=error_description_nslcmop,
+ operation_state=nslcmop_operation_state, other_update=db_nslcmop_update)
if db_nsr:
- self._write_ns_status(
- nsr_id=nsr_id,
- ns_state=None,
- current_operation="IDLE",
- current_operation_id=None,
- other_update=db_nsr_update
- )
+ self._write_ns_status(nsr_id=nsr_id, ns_state=None, current_operation="IDLE",
+ current_operation_id=None, other_update=db_nsr_update)
if nslcmop_operation_state:
try:
- await self.msg.aiowrite("ns", "scaled", {"nsr_id": nsr_id, "nslcmop_id": nslcmop_id,
- "operationState": nslcmop_operation_state},
- loop=self.loop)
- # if cooldown_time:
- # await asyncio.sleep(cooldown_time, loop=self.loop)
- # await self.msg.aiowrite("ns","scaled-cooldown-time", {"nsr_id": nsr_id, "nslcmop_id": nslcmop_id})
+ msg = {"nsr_id": nsr_id, "nslcmop_id": nslcmop_id, "operationState": nslcmop_operation_state}
+ await self.msg.aiowrite("ns", "scaled", msg, loop=self.loop)
except Exception as e:
self.logger.error(logging_text + "kafka_write notification Exception {}".format(e))
self.logger.debug(logging_text + "Exit")
self.lcm_tasks.remove("ns", nsr_id, nslcmop_id, "ns_scale")
+ async def _scale_ng_ro(self, logging_text, db_nsr, db_nslcmop, db_vnfr, vdu_scaling_info, stage):
+ nsr_id = db_nslcmop["nsInstanceId"]
+ db_nsd = self.db.get_one("nsds", {"_id": db_nsr["nsd-id"]})
+ db_vnfrs = {}
+
+ # read from db: vnfd's for every vnf
+ db_vnfds = []
+
+ # for each vnf in ns, read vnfd
+ for vnfr in self.db.get_list("vnfrs", {"nsr-id-ref": nsr_id}):
+ db_vnfrs[vnfr["member-vnf-index-ref"]] = vnfr
+ vnfd_id = vnfr["vnfd-id"] # vnfd uuid for this vnf
+ # if we haven't this vnfd, read it from db
+ if not find_in_list(db_vnfds, lambda a_vnfd: a_vnfd["id"] == vnfd_id):
+ # read from db
+ vnfd = self.db.get_one("vnfds", {"_id": vnfd_id})
+ db_vnfds.append(vnfd)
+ n2vc_key = self.n2vc.get_public_key()
+ n2vc_key_list = [n2vc_key]
+ self.scale_vnfr(db_vnfr, vdu_scaling_info.get("vdu-create"), vdu_scaling_info.get("vdu-delete"),
+ mark_delete=True)
+ # db_vnfr has been updated, update db_vnfrs to use it
+ db_vnfrs[db_vnfr["member-vnf-index-ref"]] = db_vnfr
+ await self._instantiate_ng_ro(logging_text, nsr_id, db_nsd, db_nsr, db_nslcmop, db_vnfrs,
+ db_vnfds, n2vc_key_list, stage=stage, start_deploy=time(),
+ timeout_ns_deploy=self.timeout_ns_deploy)
+ if vdu_scaling_info.get("vdu-delete"):
+ self.scale_vnfr(db_vnfr, None, vdu_scaling_info["vdu-delete"], mark_delete=False)
+
async def add_prometheus_metrics(self, ee_id, artifact_path, ee_config_descriptor, vnfr_id, nsr_id, target_ip):
if not self.prometheus:
return
job_dict = {jl["job_name"]: jl for jl in job_list}
if await self.prometheus.update(job_dict):
return list(job_dict.keys())
+
+ def get_vca_cloud_and_credentials(self, vim_account_id: str) -> (str, str):
+ """
+ Get VCA Cloud and VCA Cloud Credentials for the VIM account
+
+ :param: vim_account_id: VIM Account ID
+
+ :return: (cloud_name, cloud_credential)
+ """
+ config = VimAccountDB.get_vim_account_with_id(vim_account_id).get("config", {})
+ return config.get("vca_cloud"), config.get("vca_cloud_credential")
+
+ def get_vca_k8s_cloud_and_credentials(self, vim_account_id: str) -> (str, str):
+ """
+ Get VCA K8s Cloud and VCA K8s Cloud Credentials for the VIM account
+
+ :param: vim_account_id: VIM Account ID
+
+ :return: (cloud_name, cloud_credential)
+ """
+ config = VimAccountDB.get_vim_account_with_id(vim_account_id).get("config", {})
+ return config.get("vca_k8s_cloud"), config.get("vca_k8s_cloud_credential")