1 # -*- coding: utf-8 -*-
4 # Copyright 2018 Telefonica S.A.
6 # Licensed under the Apache License, Version 2.0 (the "License"); you may
7 # not use this file except in compliance with the License. You may obtain
8 # a copy of the License at
10 # http://www.apache.org/licenses/LICENSE-2.0
12 # Unless required by applicable law or agreed to in writing, software
13 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
14 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
15 # License for the specific language governing permissions and limitations
21 from typing
import Any
, Dict
, List
24 import logging
.handlers
36 from osm_lcm
import ROclient
37 from osm_lcm
.data_utils
.lcm_config
import LcmCfg
38 from osm_lcm
.data_utils
.nsr
import (
41 get_deployed_vca_list
,
44 from osm_lcm
.data_utils
.vca
import (
53 from osm_lcm
.ng_ro
import NgRoClient
, NgRoException
54 from osm_lcm
.lcm_utils
import (
60 check_juju_bundle_existence
,
61 get_charm_artifact_path
,
65 from osm_lcm
.data_utils
.nsd
import (
66 get_ns_configuration_relation_list
,
70 from osm_lcm
.data_utils
.vnfd
import (
76 get_ee_sorted_initial_config_primitive_list
,
77 get_ee_sorted_terminate_config_primitive_list
,
79 get_virtual_link_profiles
,
84 get_number_of_instances
,
86 get_kdu_resource_profile
,
87 find_software_version
,
90 from osm_lcm
.data_utils
.list_utils
import find_in_list
91 from osm_lcm
.data_utils
.vnfr
import (
95 get_volumes_from_instantiation_params
,
97 from osm_lcm
.data_utils
.dict_utils
import parse_yaml_strings
98 from osm_lcm
.data_utils
.database
.vim_account
import VimAccountDB
99 from n2vc
.definitions
import RelationEndpoint
100 from n2vc
.k8s_helm3_conn
import K8sHelm3Connector
101 from n2vc
.k8s_juju_conn
import K8sJujuConnector
103 from osm_common
.dbbase
import DbException
104 from osm_common
.fsbase
import FsException
106 from osm_lcm
.data_utils
.database
.database
import Database
107 from osm_lcm
.data_utils
.filesystem
.filesystem
import Filesystem
108 from osm_lcm
.data_utils
.wim
import (
110 get_target_wim_attrs
,
111 select_feasible_wim_account
,
114 from n2vc
.n2vc_juju_conn
import N2VCJujuConnector
115 from n2vc
.exceptions
import N2VCException
, N2VCNotFound
, K8sException
117 from osm_lcm
.lcm_helm_conn
import LCMHelmConn
118 from osm_lcm
.osm_config
import OsmConfigBuilder
119 from osm_lcm
.prometheus
import parse_job
121 from copy
import copy
, deepcopy
122 from time
import time
123 from uuid
import uuid4
125 from random
import SystemRandom
127 __author__
= "Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>"
130 class NsLcm(LcmBase
):
131 SUBOPERATION_STATUS_NOT_FOUND
= -1
132 SUBOPERATION_STATUS_NEW
= -2
133 SUBOPERATION_STATUS_SKIP
= -3
134 EE_TLS_NAME
= "ee-tls"
135 task_name_deploy_vca
= "Deploying VCA"
136 rel_operation_types
= {
145 def __init__(self
, msg
, lcm_tasks
, config
: LcmCfg
):
147 Init, Connect to database, filesystem storage, and messaging
148 :param config: two level dictionary with configuration. Top level should contain 'database', 'storage',
151 super().__init
__(msg
=msg
, logger
=logging
.getLogger("lcm.ns"))
153 self
.db
= Database().instance
.db
154 self
.fs
= Filesystem().instance
.fs
155 self
.lcm_tasks
= lcm_tasks
156 self
.timeout
= config
.timeout
157 self
.ro_config
= config
.RO
158 self
.vca_config
= config
.VCA
160 # create N2VC connector
161 self
.n2vc
= N2VCJujuConnector(
163 on_update_db
=self
._on
_update
_n
2vc
_db
,
168 self
.conn_helm_ee
= LCMHelmConn(
170 vca_config
=self
.vca_config
,
171 on_update_db
=self
._on
_update
_n
2vc
_db
,
174 self
.k8sclusterhelm3
= K8sHelm3Connector(
175 kubectl_command
=self
.vca_config
.kubectlpath
,
176 helm_command
=self
.vca_config
.helm3path
,
183 self
.k8sclusterjuju
= K8sJujuConnector(
184 kubectl_command
=self
.vca_config
.kubectlpath
,
185 juju_command
=self
.vca_config
.jujupath
,
187 on_update_db
=self
._on
_update
_k
8s
_db
,
192 self
.k8scluster_map
= {
193 "helm-chart-v3": self
.k8sclusterhelm3
,
194 "chart": self
.k8sclusterhelm3
,
195 "juju-bundle": self
.k8sclusterjuju
,
196 "juju": self
.k8sclusterjuju
,
200 "lxc_proxy_charm": self
.n2vc
,
201 "native_charm": self
.n2vc
,
202 "k8s_proxy_charm": self
.n2vc
,
203 "helm": self
.conn_helm_ee
,
204 "helm-v3": self
.conn_helm_ee
,
208 self
.RO
= NgRoClient(**self
.ro_config
.to_dict())
210 self
.op_status_map
= {
211 "instantiation": self
.RO
.status
,
212 "termination": self
.RO
.status
,
213 "migrate": self
.RO
.status
,
214 "healing": self
.RO
.recreate_status
,
215 "verticalscale": self
.RO
.status
,
216 "start_stop_rebuild": self
.RO
.status
,
220 def increment_ip_mac(ip_mac
, vm_index
=1):
221 if not isinstance(ip_mac
, str):
224 # try with ipv4 look for last dot
225 i
= ip_mac
.rfind(".")
228 return "{}{}".format(ip_mac
[:i
], int(ip_mac
[i
:]) + vm_index
)
229 # try with ipv6 or mac look for last colon. Operate in hex
230 i
= ip_mac
.rfind(":")
233 # format in hex, len can be 2 for mac or 4 for ipv6
234 return ("{}{:0" + str(len(ip_mac
) - i
) + "x}").format(
235 ip_mac
[:i
], int(ip_mac
[i
:], 16) + vm_index
241 async def _on_update_n2vc_db(self
, table
, filter, path
, updated_data
, vca_id
=None):
242 # remove last dot from path (if exists)
243 if path
.endswith("."):
246 # self.logger.debug('_on_update_n2vc_db(table={}, filter={}, path={}, updated_data={}'
247 # .format(table, filter, path, updated_data))
249 nsr_id
= filter.get("_id")
251 # read ns record from database
252 nsr
= self
.db
.get_one(table
="nsrs", q_filter
=filter)
253 current_ns_status
= nsr
.get("nsState")
255 # get vca status for NS
256 status_dict
= await self
.n2vc
.get_status(
257 namespace
="." + nsr_id
, yaml_format
=False, vca_id
=vca_id
262 db_dict
["vcaStatus"] = status_dict
264 # update configurationStatus for this VCA
266 vca_index
= int(path
[path
.rfind(".") + 1 :])
269 target_dict
=nsr
, key_list
=("_admin", "deployed", "VCA")
271 vca_status
= vca_list
[vca_index
].get("status")
273 configuration_status_list
= nsr
.get("configurationStatus")
274 config_status
= configuration_status_list
[vca_index
].get("status")
276 if config_status
== "BROKEN" and vca_status
!= "failed":
277 db_dict
["configurationStatus"][vca_index
] = "READY"
278 elif config_status
!= "BROKEN" and vca_status
== "failed":
279 db_dict
["configurationStatus"][vca_index
] = "BROKEN"
280 except Exception as e
:
281 # not update configurationStatus
282 self
.logger
.debug("Error updating vca_index (ignore): {}".format(e
))
284 # if nsState = 'READY' check if juju is reporting some error => nsState = 'DEGRADED'
285 # if nsState = 'DEGRADED' check if all is OK
287 if current_ns_status
in ("READY", "DEGRADED"):
288 error_description
= ""
290 if status_dict
.get("machines"):
291 for machine_id
in status_dict
.get("machines"):
292 machine
= status_dict
.get("machines").get(machine_id
)
293 # check machine agent-status
294 if machine
.get("agent-status"):
295 s
= machine
.get("agent-status").get("status")
298 error_description
+= (
299 "machine {} agent-status={} ; ".format(
303 # check machine instance status
304 if machine
.get("instance-status"):
305 s
= machine
.get("instance-status").get("status")
308 error_description
+= (
309 "machine {} instance-status={} ; ".format(
314 if status_dict
.get("applications"):
315 for app_id
in status_dict
.get("applications"):
316 app
= status_dict
.get("applications").get(app_id
)
317 # check application status
318 if app
.get("status"):
319 s
= app
.get("status").get("status")
322 error_description
+= (
323 "application {} status={} ; ".format(app_id
, s
)
326 if error_description
:
327 db_dict
["errorDescription"] = error_description
328 if current_ns_status
== "READY" and is_degraded
:
329 db_dict
["nsState"] = "DEGRADED"
330 if current_ns_status
== "DEGRADED" and not is_degraded
:
331 db_dict
["nsState"] = "READY"
334 self
.update_db_2("nsrs", nsr_id
, db_dict
)
336 except (asyncio
.CancelledError
, asyncio
.TimeoutError
):
338 except Exception as e
:
339 self
.logger
.warn("Error updating NS state for ns={}: {}".format(nsr_id
, e
))
341 async def _on_update_k8s_db(
342 self
, cluster_uuid
, kdu_instance
, filter=None, vca_id
=None, cluster_type
="juju"
345 Updating vca status in NSR record
346 :param cluster_uuid: UUID of a k8s cluster
347 :param kdu_instance: The unique name of the KDU instance
348 :param filter: To get nsr_id
349 :cluster_type: The cluster type (juju, k8s)
353 # self.logger.debug("_on_update_k8s_db(cluster_uuid={}, kdu_instance={}, filter={}"
354 # .format(cluster_uuid, kdu_instance, filter))
356 nsr_id
= filter.get("_id")
358 vca_status
= await self
.k8scluster_map
[cluster_type
].status_kdu(
359 cluster_uuid
=cluster_uuid
,
360 kdu_instance
=kdu_instance
,
362 complete_status
=True,
368 db_dict
["vcaStatus"] = {nsr_id
: vca_status
}
371 f
"Obtained VCA status for cluster type '{cluster_type}': {vca_status}"
375 self
.update_db_2("nsrs", nsr_id
, db_dict
)
376 except (asyncio
.CancelledError
, asyncio
.TimeoutError
):
378 except Exception as e
:
379 self
.logger
.warn("Error updating NS state for ns={}: {}".format(nsr_id
, e
))
382 def _parse_cloud_init(cloud_init_text
, additional_params
, vnfd_id
, vdu_id
):
385 undefined
=StrictUndefined
,
386 autoescape
=select_autoescape(default_for_string
=True, default
=True),
388 template
= env
.from_string(cloud_init_text
)
389 return template
.render(additional_params
or {})
390 except UndefinedError
as e
:
392 "Variable {} at vnfd[id={}]:vdu[id={}]:cloud-init/cloud-init-"
393 "file, must be provided in the instantiation parameters inside the "
394 "'additionalParamsForVnf/Vdu' block".format(e
, vnfd_id
, vdu_id
)
396 except (TemplateError
, TemplateNotFound
) as e
:
398 "Error parsing Jinja2 to cloud-init content at vnfd[id={}]:vdu[id={}]: {}".format(
403 def _get_vdu_cloud_init_content(self
, vdu
, vnfd
):
404 cloud_init_content
= cloud_init_file
= None
406 if vdu
.get("cloud-init-file"):
407 base_folder
= vnfd
["_admin"]["storage"]
408 if base_folder
["pkg-dir"]:
409 cloud_init_file
= "{}/{}/cloud_init/{}".format(
410 base_folder
["folder"],
411 base_folder
["pkg-dir"],
412 vdu
["cloud-init-file"],
415 cloud_init_file
= "{}/Scripts/cloud_init/{}".format(
416 base_folder
["folder"],
417 vdu
["cloud-init-file"],
419 with self
.fs
.file_open(cloud_init_file
, "r") as ci_file
:
420 cloud_init_content
= ci_file
.read()
421 elif vdu
.get("cloud-init"):
422 cloud_init_content
= vdu
["cloud-init"]
424 return cloud_init_content
425 except FsException
as e
:
427 "Error reading vnfd[id={}]:vdu[id={}]:cloud-init-file={}: {}".format(
428 vnfd
["id"], vdu
["id"], cloud_init_file
, e
432 def _get_vdu_additional_params(self
, db_vnfr
, vdu_id
):
434 (vdur
for vdur
in db_vnfr
.get("vdur") if vdu_id
== vdur
["vdu-id-ref"]), {}
436 additional_params
= vdur
.get("additionalParams")
437 return parse_yaml_strings(additional_params
)
440 def ip_profile_2_RO(ip_profile
):
441 RO_ip_profile
= deepcopy(ip_profile
)
442 if "dns-server" in RO_ip_profile
:
443 if isinstance(RO_ip_profile
["dns-server"], list):
444 RO_ip_profile
["dns-address"] = []
445 for ds
in RO_ip_profile
.pop("dns-server"):
446 RO_ip_profile
["dns-address"].append(ds
["address"])
448 RO_ip_profile
["dns-address"] = RO_ip_profile
.pop("dns-server")
449 if RO_ip_profile
.get("ip-version") == "ipv4":
450 RO_ip_profile
["ip-version"] = "IPv4"
451 if RO_ip_profile
.get("ip-version") == "ipv6":
452 RO_ip_profile
["ip-version"] = "IPv6"
453 if "dhcp-params" in RO_ip_profile
:
454 RO_ip_profile
["dhcp"] = RO_ip_profile
.pop("dhcp-params")
457 def scale_vnfr(self
, db_vnfr
, vdu_create
=None, vdu_delete
=None, mark_delete
=False):
458 db_vdu_push_list
= []
460 db_update
= {"_admin.modified": time()}
462 for vdu_id
, vdu_count
in vdu_create
.items():
466 for vdur
in reversed(db_vnfr
["vdur"])
467 if vdur
["vdu-id-ref"] == vdu_id
472 # Read the template saved in the db:
474 "No vdur in the database. Using the vdur-template to scale"
476 vdur_template
= db_vnfr
.get("vdur-template")
477 if not vdur_template
:
479 "Error scaling OUT VNFR for {}. No vnfr or template exists".format(
483 vdur
= vdur_template
[0]
484 # Delete a template from the database after using it
487 {"_id": db_vnfr
["_id"]},
489 pull
={"vdur-template": {"_id": vdur
["_id"]}},
491 for count
in range(vdu_count
):
492 vdur_copy
= deepcopy(vdur
)
493 vdur_copy
["status"] = "BUILD"
494 vdur_copy
["status-detailed"] = None
495 vdur_copy
["ip-address"] = None
496 vdur_copy
["_id"] = str(uuid4())
497 vdur_copy
["count-index"] += count
+ 1
498 vdur_copy
["id"] = "{}-{}".format(
499 vdur_copy
["vdu-id-ref"], vdur_copy
["count-index"]
501 vdur_copy
.pop("vim_info", None)
502 for iface
in vdur_copy
["interfaces"]:
503 if iface
.get("fixed-ip"):
504 iface
["ip-address"] = self
.increment_ip_mac(
505 iface
["ip-address"], count
+ 1
508 iface
.pop("ip-address", None)
509 if iface
.get("fixed-mac"):
510 iface
["mac-address"] = self
.increment_ip_mac(
511 iface
["mac-address"], count
+ 1
514 iface
.pop("mac-address", None)
518 ) # only first vdu can be managment of vnf
519 db_vdu_push_list
.append(vdur_copy
)
520 # self.logger.debug("scale out, adding vdu={}".format(vdur_copy))
522 if len(db_vnfr
["vdur"]) == 1:
523 # The scale will move to 0 instances
525 "Scaling to 0 !, creating the template with the last vdur"
527 template_vdur
= [db_vnfr
["vdur"][0]]
528 for vdu_id
, vdu_count
in vdu_delete
.items():
530 indexes_to_delete
= [
532 for iv
in enumerate(db_vnfr
["vdur"])
533 if iv
[1]["vdu-id-ref"] == vdu_id
537 "vdur.{}.status".format(i
): "DELETING"
538 for i
in indexes_to_delete
[-vdu_count
:]
542 # it must be deleted one by one because common.db does not allow otherwise
545 for v
in reversed(db_vnfr
["vdur"])
546 if v
["vdu-id-ref"] == vdu_id
548 for vdu
in vdus_to_delete
[:vdu_count
]:
551 {"_id": db_vnfr
["_id"]},
553 pull
={"vdur": {"_id": vdu
["_id"]}},
557 db_push
["vdur"] = db_vdu_push_list
559 db_push
["vdur-template"] = template_vdur
562 db_vnfr
["vdur-template"] = template_vdur
563 self
.db
.set_one("vnfrs", {"_id": db_vnfr
["_id"]}, db_update
, push_list
=db_push
)
564 # modify passed dictionary db_vnfr
565 db_vnfr_
= self
.db
.get_one("vnfrs", {"_id": db_vnfr
["_id"]})
566 db_vnfr
["vdur"] = db_vnfr_
["vdur"]
568 def ns_update_nsr(self
, ns_update_nsr
, db_nsr
, nsr_desc_RO
):
570 Updates database nsr with the RO info for the created vld
571 :param ns_update_nsr: dictionary to be filled with the updated info
572 :param db_nsr: content of db_nsr. This is also modified
573 :param nsr_desc_RO: nsr descriptor from RO
574 :return: Nothing, LcmException is raised on errors
577 for vld_index
, vld
in enumerate(get_iterable(db_nsr
, "vld")):
578 for net_RO
in get_iterable(nsr_desc_RO
, "nets"):
579 if vld
["id"] != net_RO
.get("ns_net_osm_id"):
581 vld
["vim-id"] = net_RO
.get("vim_net_id")
582 vld
["name"] = net_RO
.get("vim_name")
583 vld
["status"] = net_RO
.get("status")
584 vld
["status-detailed"] = net_RO
.get("error_msg")
585 ns_update_nsr
["vld.{}".format(vld_index
)] = vld
589 "ns_update_nsr: Not found vld={} at RO info".format(vld
["id"])
592 def set_vnfr_at_error(self
, db_vnfrs
, error_text
):
594 for db_vnfr
in db_vnfrs
.values():
595 vnfr_update
= {"status": "ERROR"}
596 for vdu_index
, vdur
in enumerate(get_iterable(db_vnfr
, "vdur")):
597 if "status" not in vdur
:
598 vdur
["status"] = "ERROR"
599 vnfr_update
["vdur.{}.status".format(vdu_index
)] = "ERROR"
601 vdur
["status-detailed"] = str(error_text
)
603 "vdur.{}.status-detailed".format(vdu_index
)
605 self
.update_db_2("vnfrs", db_vnfr
["_id"], vnfr_update
)
606 except DbException
as e
:
607 self
.logger
.error("Cannot update vnf. {}".format(e
))
609 def _get_ns_config_info(self
, nsr_id
):
611 Generates a mapping between vnf,vdu elements and the N2VC id
612 :param nsr_id: id of nsr to get last database _admin.deployed.VCA that contains this list
613 :return: a dictionary with {osm-config-mapping: {}} where its element contains:
614 "<member-vnf-index>": <N2VC-id> for a vnf configuration, or
615 "<member-vnf-index>.<vdu.id>.<vdu replica(0, 1,..)>": <N2VC-id> for a vdu configuration
617 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
618 vca_deployed_list
= db_nsr
["_admin"]["deployed"]["VCA"]
620 ns_config_info
= {"osm-config-mapping": mapping
}
621 for vca
in vca_deployed_list
:
622 if not vca
["member-vnf-index"]:
624 if not vca
["vdu_id"]:
625 mapping
[vca
["member-vnf-index"]] = vca
["application"]
629 vca
["member-vnf-index"], vca
["vdu_id"], vca
["vdu_count_index"]
631 ] = vca
["application"]
632 return ns_config_info
634 async def _instantiate_ng_ro(
650 def get_vim_account(vim_account_id
):
652 if vim_account_id
in db_vims
:
653 return db_vims
[vim_account_id
]
654 db_vim
= self
.db
.get_one("vim_accounts", {"_id": vim_account_id
})
655 db_vims
[vim_account_id
] = db_vim
658 # modify target_vld info with instantiation parameters
659 def parse_vld_instantiation_params(
660 target_vim
, target_vld
, vld_params
, target_sdn
662 if vld_params
.get("ip-profile"):
663 target_vld
["vim_info"][target_vim
]["ip_profile"] = vld_to_ro_ip_profile(
664 vld_params
["ip-profile"]
666 if vld_params
.get("provider-network"):
667 target_vld
["vim_info"][target_vim
]["provider_network"] = vld_params
[
670 if "sdn-ports" in vld_params
["provider-network"] and target_sdn
:
671 target_vld
["vim_info"][target_sdn
]["sdn-ports"] = vld_params
[
675 # check if WIM is needed; if needed, choose a feasible WIM able to connect VIMs
676 # if wim_account_id is specified in vld_params, validate if it is feasible.
677 wim_account_id
, db_wim
= select_feasible_wim_account(
678 db_nsr
, db_vnfrs
, target_vld
, vld_params
, self
.logger
682 # WIM is needed and a feasible one was found, populate WIM target and SDN ports
683 self
.logger
.info("WIM selected: {:s}".format(str(wim_account_id
)))
684 # update vld_params with correct WIM account Id
685 vld_params
["wimAccountId"] = wim_account_id
687 target_wim
= "wim:{}".format(wim_account_id
)
688 target_wim_attrs
= get_target_wim_attrs(nsr_id
, target_vld
, vld_params
)
689 sdn_ports
= get_sdn_ports(vld_params
, db_wim
)
690 if len(sdn_ports
) > 0:
691 target_vld
["vim_info"][target_wim
] = target_wim_attrs
692 target_vld
["vim_info"][target_wim
]["sdn-ports"] = sdn_ports
695 "Target VLD with WIM data: {:s}".format(str(target_vld
))
698 for param
in ("vim-network-name", "vim-network-id"):
699 if vld_params
.get(param
):
700 if isinstance(vld_params
[param
], dict):
701 for vim
, vim_net
in vld_params
[param
].items():
702 other_target_vim
= "vim:" + vim
704 target_vld
["vim_info"],
705 (other_target_vim
, param
.replace("-", "_")),
708 else: # isinstance str
709 target_vld
["vim_info"][target_vim
][
710 param
.replace("-", "_")
711 ] = vld_params
[param
]
712 if vld_params
.get("common_id"):
713 target_vld
["common_id"] = vld_params
.get("common_id")
715 # modify target["ns"]["vld"] with instantiation parameters to override vnf vim-account
716 def update_ns_vld_target(target
, ns_params
):
717 for vnf_params
in ns_params
.get("vnf", ()):
718 if vnf_params
.get("vimAccountId"):
722 for vnfr
in db_vnfrs
.values()
723 if vnf_params
["member-vnf-index"]
724 == vnfr
["member-vnf-index-ref"]
728 vdur
= next((vdur
for vdur
in target_vnf
.get("vdur", ())), None)
731 for a_index
, a_vld
in enumerate(target
["ns"]["vld"]):
732 target_vld
= find_in_list(
733 get_iterable(vdur
, "interfaces"),
734 lambda iface
: iface
.get("ns-vld-id") == a_vld
["name"],
737 vld_params
= find_in_list(
738 get_iterable(ns_params
, "vld"),
739 lambda v_vld
: v_vld
["name"] in (a_vld
["name"], a_vld
["id"]),
742 if vnf_params
.get("vimAccountId") not in a_vld
.get(
745 target_vim_network_list
= [
746 v
for _
, v
in a_vld
.get("vim_info").items()
748 target_vim_network_name
= next(
750 item
.get("vim_network_name", "")
751 for item
in target_vim_network_list
756 target
["ns"]["vld"][a_index
].get("vim_info").update(
758 "vim:{}".format(vnf_params
["vimAccountId"]): {
759 "vim_network_name": target_vim_network_name
,
765 for param
in ("vim-network-name", "vim-network-id"):
766 if vld_params
.get(param
) and isinstance(
767 vld_params
[param
], dict
769 for vim
, vim_net
in vld_params
[
772 other_target_vim
= "vim:" + vim
774 target
["ns"]["vld"][a_index
].get(
779 param
.replace("-", "_"),
784 nslcmop_id
= db_nslcmop
["_id"]
786 "name": db_nsr
["name"],
789 "image": deepcopy(db_nsr
["image"]),
790 "flavor": deepcopy(db_nsr
["flavor"]),
791 "action_id": nslcmop_id
,
792 "cloud_init_content": {},
794 for image
in target
["image"]:
795 image
["vim_info"] = {}
796 for flavor
in target
["flavor"]:
797 flavor
["vim_info"] = {}
798 if db_nsr
.get("shared-volumes"):
799 target
["shared-volumes"] = deepcopy(db_nsr
["shared-volumes"])
800 for shared_volumes
in target
["shared-volumes"]:
801 shared_volumes
["vim_info"] = {}
802 if db_nsr
.get("affinity-or-anti-affinity-group"):
803 target
["affinity-or-anti-affinity-group"] = deepcopy(
804 db_nsr
["affinity-or-anti-affinity-group"]
806 for affinity_or_anti_affinity_group
in target
[
807 "affinity-or-anti-affinity-group"
809 affinity_or_anti_affinity_group
["vim_info"] = {}
811 if db_nslcmop
.get("lcmOperationType") != "instantiate":
812 # get parameters of instantiation:
813 db_nslcmop_instantiate
= self
.db
.get_list(
816 "nsInstanceId": db_nslcmop
["nsInstanceId"],
817 "lcmOperationType": "instantiate",
820 ns_params
= db_nslcmop_instantiate
.get("operationParams")
822 ns_params
= db_nslcmop
.get("operationParams")
823 ssh_keys_instantiation
= ns_params
.get("ssh_keys") or []
824 ssh_keys_all
= ssh_keys_instantiation
+ (n2vc_key_list
or [])
827 for vld_index
, vld
in enumerate(db_nsr
.get("vld")):
828 target_vim
= "vim:{}".format(ns_params
["vimAccountId"])
832 "mgmt-network": vld
.get("mgmt-network", False),
833 "type": vld
.get("type"),
836 "vim_network_name": vld
.get("vim-network-name"),
837 "vim_account_id": ns_params
["vimAccountId"],
841 # check if this network needs SDN assist
842 if vld
.get("pci-interfaces"):
843 db_vim
= get_vim_account(ns_params
["vimAccountId"])
844 if vim_config
:= db_vim
.get("config"):
845 if sdnc_id
:= vim_config
.get("sdn-controller"):
846 sdn_vld
= "nsrs:{}:vld.{}".format(nsr_id
, vld
["id"])
847 target_sdn
= "sdn:{}".format(sdnc_id
)
848 target_vld
["vim_info"][target_sdn
] = {
850 "target_vim": target_vim
,
852 "type": vld
.get("type"),
855 nsd_vnf_profiles
= get_vnf_profiles(nsd
)
856 for nsd_vnf_profile
in nsd_vnf_profiles
:
857 for cp
in nsd_vnf_profile
["virtual-link-connectivity"]:
858 if cp
["virtual-link-profile-id"] == vld
["id"]:
860 "member_vnf:{}.{}".format(
861 cp
["constituent-cpd-id"][0][
862 "constituent-base-element-id"
864 cp
["constituent-cpd-id"][0]["constituent-cpd-id"],
866 ] = "nsrs:{}:vld.{}".format(nsr_id
, vld_index
)
868 # check at nsd descriptor, if there is an ip-profile
870 nsd_vlp
= find_in_list(
871 get_virtual_link_profiles(nsd
),
872 lambda a_link_profile
: a_link_profile
["virtual-link-desc-id"]
877 and nsd_vlp
.get("virtual-link-protocol-data")
878 and nsd_vlp
["virtual-link-protocol-data"].get("l3-protocol-data")
880 vld_params
["ip-profile"] = nsd_vlp
["virtual-link-protocol-data"][
884 # update vld_params with instantiation params
885 vld_instantiation_params
= find_in_list(
886 get_iterable(ns_params
, "vld"),
887 lambda a_vld
: a_vld
["name"] in (vld
["name"], vld
["id"]),
889 if vld_instantiation_params
:
890 vld_params
.update(vld_instantiation_params
)
891 parse_vld_instantiation_params(target_vim
, target_vld
, vld_params
, None)
892 target
["ns"]["vld"].append(target_vld
)
893 # Update the target ns_vld if vnf vim_account is overriden by instantiation params
894 update_ns_vld_target(target
, ns_params
)
896 for vnfr
in db_vnfrs
.values():
898 db_vnfds
, lambda db_vnf
: db_vnf
["id"] == vnfr
["vnfd-ref"]
900 vnf_params
= find_in_list(
901 get_iterable(ns_params
, "vnf"),
902 lambda a_vnf
: a_vnf
["member-vnf-index"] == vnfr
["member-vnf-index-ref"],
904 target_vnf
= deepcopy(vnfr
)
905 target_vim
= "vim:{}".format(vnfr
["vim-account-id"])
906 for vld
in target_vnf
.get("vld", ()):
907 # check if connected to a ns.vld, to fill target'
908 vnf_cp
= find_in_list(
909 vnfd
.get("int-virtual-link-desc", ()),
910 lambda cpd
: cpd
.get("id") == vld
["id"],
913 ns_cp
= "member_vnf:{}.{}".format(
914 vnfr
["member-vnf-index-ref"], vnf_cp
["id"]
916 if cp2target
.get(ns_cp
):
917 vld
["target"] = cp2target
[ns_cp
]
920 target_vim
: {"vim_network_name": vld
.get("vim-network-name")}
922 # check if this network needs SDN assist
924 if vld
.get("pci-interfaces"):
925 db_vim
= get_vim_account(vnfr
["vim-account-id"])
926 sdnc_id
= db_vim
["config"].get("sdn-controller")
928 sdn_vld
= "vnfrs:{}:vld.{}".format(target_vnf
["_id"], vld
["id"])
929 target_sdn
= "sdn:{}".format(sdnc_id
)
930 vld
["vim_info"][target_sdn
] = {
932 "target_vim": target_vim
,
934 "type": vld
.get("type"),
937 # check at vnfd descriptor, if there is an ip-profile
939 vnfd_vlp
= find_in_list(
940 get_virtual_link_profiles(vnfd
),
941 lambda a_link_profile
: a_link_profile
["id"] == vld
["id"],
945 and vnfd_vlp
.get("virtual-link-protocol-data")
946 and vnfd_vlp
["virtual-link-protocol-data"].get("l3-protocol-data")
948 vld_params
["ip-profile"] = vnfd_vlp
["virtual-link-protocol-data"][
951 # update vld_params with instantiation params
953 vld_instantiation_params
= find_in_list(
954 get_iterable(vnf_params
, "internal-vld"),
955 lambda i_vld
: i_vld
["name"] == vld
["id"],
957 if vld_instantiation_params
:
958 vld_params
.update(vld_instantiation_params
)
959 parse_vld_instantiation_params(target_vim
, vld
, vld_params
, target_sdn
)
962 for vdur
in target_vnf
.get("vdur", ()):
963 if vdur
.get("status") == "DELETING" or vdur
.get("pdu-type"):
964 continue # This vdu must not be created
965 vdur
["vim_info"] = {"vim_account_id": vnfr
["vim-account-id"]}
967 self
.logger
.debug("NS > ssh_keys > {}".format(ssh_keys_all
))
970 vdu_configuration
= get_configuration(vnfd
, vdur
["vdu-id-ref"])
971 vnf_configuration
= get_configuration(vnfd
, vnfd
["id"])
974 and vdu_configuration
.get("config-access")
975 and vdu_configuration
.get("config-access").get("ssh-access")
977 vdur
["ssh-keys"] = ssh_keys_all
978 vdur
["ssh-access-required"] = vdu_configuration
[
980 ]["ssh-access"]["required"]
983 and vnf_configuration
.get("config-access")
984 and vnf_configuration
.get("config-access").get("ssh-access")
985 and any(iface
.get("mgmt-vnf") for iface
in vdur
["interfaces"])
987 vdur
["ssh-keys"] = ssh_keys_all
988 vdur
["ssh-access-required"] = vnf_configuration
[
990 ]["ssh-access"]["required"]
991 elif ssh_keys_instantiation
and find_in_list(
992 vdur
["interfaces"], lambda iface
: iface
.get("mgmt-vnf")
994 vdur
["ssh-keys"] = ssh_keys_instantiation
996 self
.logger
.debug("NS > vdur > {}".format(vdur
))
998 vdud
= get_vdu(vnfd
, vdur
["vdu-id-ref"])
1000 if vdud
.get("cloud-init-file"):
1001 vdur
["cloud-init"] = "{}:file:{}".format(
1002 vnfd
["_id"], vdud
.get("cloud-init-file")
1004 # read file and put content at target.cloul_init_content. Avoid ng_ro to use shared package system
1005 if vdur
["cloud-init"] not in target
["cloud_init_content"]:
1006 base_folder
= vnfd
["_admin"]["storage"]
1007 if base_folder
["pkg-dir"]:
1008 cloud_init_file
= "{}/{}/cloud_init/{}".format(
1009 base_folder
["folder"],
1010 base_folder
["pkg-dir"],
1011 vdud
.get("cloud-init-file"),
1014 cloud_init_file
= "{}/Scripts/cloud_init/{}".format(
1015 base_folder
["folder"],
1016 vdud
.get("cloud-init-file"),
1018 with self
.fs
.file_open(cloud_init_file
, "r") as ci_file
:
1019 target
["cloud_init_content"][
1022 elif vdud
.get("cloud-init"):
1023 vdur
["cloud-init"] = "{}:vdu:{}".format(
1024 vnfd
["_id"], get_vdu_index(vnfd
, vdur
["vdu-id-ref"])
1026 # put content at target.cloul_init_content. Avoid ng_ro read vnfd descriptor
1027 target
["cloud_init_content"][vdur
["cloud-init"]] = vdud
[
1030 vdur
["additionalParams"] = vdur
.get("additionalParams") or {}
1031 deploy_params_vdu
= self
._format
_additional
_params
(
1032 vdur
.get("additionalParams") or {}
1034 deploy_params_vdu
["OSM"] = get_osm_params(
1035 vnfr
, vdur
["vdu-id-ref"], vdur
["count-index"]
1037 vdur
["additionalParams"] = deploy_params_vdu
1040 ns_flavor
= target
["flavor"][int(vdur
["ns-flavor-id"])]
1041 if target_vim
not in ns_flavor
["vim_info"]:
1042 ns_flavor
["vim_info"][target_vim
] = {}
1045 # in case alternative images are provided we must check if they should be applied
1046 # for the vim_type, modify the vim_type taking into account
1047 ns_image_id
= int(vdur
["ns-image-id"])
1048 if vdur
.get("alt-image-ids"):
1049 db_vim
= get_vim_account(vnfr
["vim-account-id"])
1050 vim_type
= db_vim
["vim_type"]
1051 for alt_image_id
in vdur
.get("alt-image-ids"):
1052 ns_alt_image
= target
["image"][int(alt_image_id
)]
1053 if vim_type
== ns_alt_image
.get("vim-type"):
1054 # must use alternative image
1056 "use alternative image id: {}".format(alt_image_id
)
1058 ns_image_id
= alt_image_id
1059 vdur
["ns-image-id"] = ns_image_id
1061 ns_image
= target
["image"][int(ns_image_id
)]
1062 if target_vim
not in ns_image
["vim_info"]:
1063 ns_image
["vim_info"][target_vim
] = {}
1066 if vdur
.get("affinity-or-anti-affinity-group-id"):
1067 for ags_id
in vdur
["affinity-or-anti-affinity-group-id"]:
1068 ns_ags
= target
["affinity-or-anti-affinity-group"][int(ags_id
)]
1069 if target_vim
not in ns_ags
["vim_info"]:
1070 ns_ags
["vim_info"][target_vim
] = {}
1073 if vdur
.get("shared-volumes-id"):
1074 for sv_id
in vdur
["shared-volumes-id"]:
1075 ns_sv
= find_in_list(
1076 target
["shared-volumes"], lambda sv
: sv_id
in sv
["id"]
1079 ns_sv
["vim_info"][target_vim
] = {}
1081 vdur
["vim_info"] = {target_vim
: {}}
1082 # instantiation parameters
1084 vdu_instantiation_params
= find_in_list(
1085 get_iterable(vnf_params
, "vdu"),
1086 lambda i_vdu
: i_vdu
["id"] == vdud
["id"],
1088 if vdu_instantiation_params
:
1089 # Parse the vdu_volumes from the instantiation params
1090 vdu_volumes
= get_volumes_from_instantiation_params(
1091 vdu_instantiation_params
, vdud
1093 vdur
["additionalParams"]["OSM"]["vdu_volumes"] = vdu_volumes
1094 vdur
["additionalParams"]["OSM"][
1096 ] = vdu_instantiation_params
.get("vim-flavor-id")
1097 vdur_list
.append(vdur
)
1098 target_vnf
["vdur"] = vdur_list
1099 target
["vnf"].append(target_vnf
)
1101 self
.logger
.debug("Send to RO > nsr_id={} target={}".format(nsr_id
, target
))
1102 desc
= await self
.RO
.deploy(nsr_id
, target
)
1103 self
.logger
.debug("RO return > {}".format(desc
))
1104 action_id
= desc
["action_id"]
1105 await self
._wait
_ng
_ro
(
1112 operation
="instantiation",
1117 "_admin.deployed.RO.operational-status": "running",
1118 "detailed-status": " ".join(stage
),
1120 # db_nsr["_admin.deployed.RO.detailed-status"] = "Deployed at VIM"
1121 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
1122 self
._write
_op
_status
(nslcmop_id
, stage
)
1124 logging_text
+ "ns deployed at RO. RO_id={}".format(action_id
)
1128 async def _wait_ng_ro(
1138 detailed_status_old
= None
1140 start_time
= start_time
or time()
1141 while time() <= start_time
+ timeout
:
1142 desc_status
= await self
.op_status_map
[operation
](nsr_id
, action_id
)
1143 self
.logger
.debug("Wait NG RO > {}".format(desc_status
))
1144 if desc_status
["status"] == "FAILED":
1145 raise NgRoException(desc_status
["details"])
1146 elif desc_status
["status"] == "BUILD":
1148 stage
[2] = "VIM: ({})".format(desc_status
["details"])
1149 elif desc_status
["status"] == "DONE":
1151 stage
[2] = "Deployed at VIM"
1154 assert False, "ROclient.check_ns_status returns unknown {}".format(
1155 desc_status
["status"]
1157 if stage
and nslcmop_id
and stage
[2] != detailed_status_old
:
1158 detailed_status_old
= stage
[2]
1159 db_nsr_update
["detailed-status"] = " ".join(stage
)
1160 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
1161 self
._write
_op
_status
(nslcmop_id
, stage
)
1162 await asyncio
.sleep(15)
1163 else: # timeout_ns_deploy
1164 raise NgRoException("Timeout waiting ns to deploy")
1166 async def _terminate_ng_ro(
1167 self
, logging_text
, nsr_deployed
, nsr_id
, nslcmop_id
, stage
1172 start_deploy
= time()
1179 "action_id": nslcmop_id
,
1181 desc
= await self
.RO
.deploy(nsr_id
, target
)
1182 action_id
= desc
["action_id"]
1183 db_nsr_update
["_admin.deployed.RO.nsr_status"] = "DELETING"
1186 + "ns terminate action at RO. action_id={}".format(action_id
)
1190 delete_timeout
= 20 * 60 # 20 minutes
1191 await self
._wait
_ng
_ro
(
1198 operation
="termination",
1200 db_nsr_update
["_admin.deployed.RO.nsr_status"] = "DELETED"
1202 await self
.RO
.delete(nsr_id
)
1203 except NgRoException
as e
:
1204 if e
.http_code
== 404: # not found
1205 db_nsr_update
["_admin.deployed.RO.nsr_id"] = None
1206 db_nsr_update
["_admin.deployed.RO.nsr_status"] = "DELETED"
1208 logging_text
+ "RO_action_id={} already deleted".format(action_id
)
1210 elif e
.http_code
== 409: # conflict
1211 failed_detail
.append("delete conflict: {}".format(e
))
1214 + "RO_action_id={} delete conflict: {}".format(action_id
, e
)
1217 failed_detail
.append("delete error: {}".format(e
))
1220 + "RO_action_id={} delete error: {}".format(action_id
, e
)
1222 except Exception as e
:
1223 failed_detail
.append("delete error: {}".format(e
))
1225 logging_text
+ "RO_action_id={} delete error: {}".format(action_id
, e
)
1229 stage
[2] = "Error deleting from VIM"
1231 stage
[2] = "Deleted from VIM"
1232 db_nsr_update
["detailed-status"] = " ".join(stage
)
1233 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
1234 self
._write
_op
_status
(nslcmop_id
, stage
)
1237 raise LcmException("; ".join(failed_detail
))
1240 async def instantiate_RO(
1254 :param logging_text: preffix text to use at logging
1255 :param nsr_id: nsr identity
1256 :param nsd: database content of ns descriptor
1257 :param db_nsr: database content of ns record
1258 :param db_nslcmop: database content of ns operation, in this case, 'instantiate'
1260 :param db_vnfds: database content of vnfds, indexed by id (not _id). {id: {vnfd_object}, ...}
1261 :param n2vc_key_list: ssh-public-key list to be inserted to management vdus via cloud-init
1262 :param stage: list with 3 items: [general stage, tasks, vim_specific]. This task will write over vim_specific
1263 :return: None or exception
1266 start_deploy
= time()
1267 ns_params
= db_nslcmop
.get("operationParams")
1268 if ns_params
and ns_params
.get("timeout_ns_deploy"):
1269 timeout_ns_deploy
= ns_params
["timeout_ns_deploy"]
1271 timeout_ns_deploy
= self
.timeout
.ns_deploy
1273 # Check for and optionally request placement optimization. Database will be updated if placement activated
1274 stage
[2] = "Waiting for Placement."
1275 if await self
._do
_placement
(logging_text
, db_nslcmop
, db_vnfrs
):
1276 # in case of placement change ns_params[vimAcountId) if not present at any vnfrs
1277 for vnfr
in db_vnfrs
.values():
1278 if ns_params
["vimAccountId"] == vnfr
["vim-account-id"]:
1281 ns_params
["vimAccountId"] == vnfr
["vim-account-id"]
1283 return await self
._instantiate
_ng
_ro
(
1296 except Exception as e
:
1297 stage
[2] = "ERROR deploying at VIM"
1298 self
.set_vnfr_at_error(db_vnfrs
, str(e
))
1300 "Error deploying at VIM {}".format(e
),
1301 exc_info
=not isinstance(
1304 ROclient
.ROClientException
,
1313 async def wait_kdu_up(self
, logging_text
, nsr_id
, vnfr_id
, kdu_name
):
1315 Wait for kdu to be up, get ip address
1316 :param logging_text: prefix use for logging
1320 :return: IP address, K8s services
1323 # self.logger.debug(logging_text + "Starting wait_kdu_up")
1326 while nb_tries
< 360:
1327 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnfr_id
})
1331 for x
in get_iterable(db_vnfr
, "kdur")
1332 if x
.get("kdu-name") == kdu_name
1338 "Not found vnfr_id={}, kdu_name={}".format(vnfr_id
, kdu_name
)
1340 if kdur
.get("status"):
1341 if kdur
["status"] in ("READY", "ENABLED"):
1342 return kdur
.get("ip-address"), kdur
.get("services")
1345 "target KDU={} is in error state".format(kdu_name
)
1348 await asyncio
.sleep(10)
1350 raise LcmException("Timeout waiting KDU={} instantiated".format(kdu_name
))
1352 async def wait_vm_up_insert_key_ro(
1353 self
, logging_text
, nsr_id
, vnfr_id
, vdu_id
, vdu_index
, pub_key
=None, user
=None
1356 Wait for ip addres at RO, and optionally, insert public key in virtual machine
1357 :param logging_text: prefix use for logging
1362 :param pub_key: public ssh key to inject, None to skip
1363 :param user: user to apply the public ssh key
1367 self
.logger
.debug(logging_text
+ "Starting wait_vm_up_insert_key_ro")
1369 target_vdu_id
= None
1374 if ro_retries
>= 360: # 1 hour
1376 "Not found _admin.deployed.RO.nsr_id for nsr_id: {}".format(nsr_id
)
1379 await asyncio
.sleep(10)
1382 if not target_vdu_id
:
1383 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnfr_id
})
1385 if not vdu_id
: # for the VNF case
1386 if db_vnfr
.get("status") == "ERROR":
1388 "Cannot inject ssh-key because target VNF is in error state"
1390 ip_address
= db_vnfr
.get("ip-address")
1396 for x
in get_iterable(db_vnfr
, "vdur")
1397 if x
.get("ip-address") == ip_address
1405 for x
in get_iterable(db_vnfr
, "vdur")
1406 if x
.get("vdu-id-ref") == vdu_id
1407 and x
.get("count-index") == vdu_index
1413 not vdur
and len(db_vnfr
.get("vdur", ())) == 1
1414 ): # If only one, this should be the target vdu
1415 vdur
= db_vnfr
["vdur"][0]
1418 "Not found vnfr_id={}, vdu_id={}, vdu_index={}".format(
1419 vnfr_id
, vdu_id
, vdu_index
1422 # New generation RO stores information at "vim_info"
1425 if vdur
.get("vim_info"):
1427 t
for t
in vdur
["vim_info"]
1428 ) # there should be only one key
1429 ng_ro_status
= vdur
["vim_info"][target_vim
].get("vim_status")
1431 vdur
.get("pdu-type")
1432 or vdur
.get("status") == "ACTIVE"
1433 or ng_ro_status
== "ACTIVE"
1435 ip_address
= vdur
.get("ip-address")
1438 target_vdu_id
= vdur
["vdu-id-ref"]
1439 elif vdur
.get("status") == "ERROR" or ng_ro_status
== "ERROR":
1441 "Cannot inject ssh-key because target VM is in error state"
1444 if not target_vdu_id
:
1447 # inject public key into machine
1448 if pub_key
and user
:
1449 self
.logger
.debug(logging_text
+ "Inserting RO key")
1450 self
.logger
.debug("SSH > PubKey > {}".format(pub_key
))
1451 if vdur
.get("pdu-type"):
1452 self
.logger
.error(logging_text
+ "Cannot inject ssh-ky to a PDU")
1457 "action": "inject_ssh_key",
1461 "vnf": [{"_id": vnfr_id
, "vdur": [{"id": vdur
["id"]}]}],
1463 desc
= await self
.RO
.deploy(nsr_id
, target
)
1464 action_id
= desc
["action_id"]
1465 await self
._wait
_ng
_ro
(
1466 nsr_id
, action_id
, timeout
=600, operation
="instantiation"
1469 except NgRoException
as e
:
1471 "Reaching max tries injecting key. Error: {}".format(e
)
1478 async def _wait_dependent_n2vc(self
, nsr_id
, vca_deployed_list
, vca_index
):
1480 Wait until dependent VCA deployments have been finished. NS wait for VNFs and VDUs. VNFs for VDUs
1482 my_vca
= vca_deployed_list
[vca_index
]
1483 if my_vca
.get("vdu_id") or my_vca
.get("kdu_name"):
1484 # vdu or kdu: no dependencies
1488 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
1489 vca_deployed_list
= db_nsr
["_admin"]["deployed"]["VCA"]
1490 configuration_status_list
= db_nsr
["configurationStatus"]
1491 for index
, vca_deployed
in enumerate(configuration_status_list
):
1492 if index
== vca_index
:
1495 if not my_vca
.get("member-vnf-index") or (
1496 vca_deployed
.get("member-vnf-index")
1497 == my_vca
.get("member-vnf-index")
1499 internal_status
= configuration_status_list
[index
].get("status")
1500 if internal_status
== "READY":
1502 elif internal_status
== "BROKEN":
1504 "Configuration aborted because dependent charm/s has failed"
1509 # no dependencies, return
1511 await asyncio
.sleep(10)
1514 raise LcmException("Configuration aborted because dependent charm/s timeout")
1516 def get_vca_id(self
, db_vnfr
: dict, db_nsr
: dict):
1519 vca_id
= deep_get(db_vnfr
, ("vca-id",))
1521 vim_account_id
= deep_get(db_nsr
, ("instantiate_params", "vimAccountId"))
1522 vca_id
= VimAccountDB
.get_vim_account_with_id(vim_account_id
).get("vca")
1525 async def instantiate_N2VC(
1543 ee_config_descriptor
,
1545 nsr_id
= db_nsr
["_id"]
1546 db_update_entry
= "_admin.deployed.VCA.{}.".format(vca_index
)
1547 vca_deployed_list
= db_nsr
["_admin"]["deployed"]["VCA"]
1548 vca_deployed
= db_nsr
["_admin"]["deployed"]["VCA"][vca_index
]
1549 osm_config
= {"osm": {"ns_id": db_nsr
["_id"]}}
1551 "collection": "nsrs",
1552 "filter": {"_id": nsr_id
},
1553 "path": db_update_entry
,
1558 element_under_configuration
= nsr_id
1562 vnfr_id
= db_vnfr
["_id"]
1563 osm_config
["osm"]["vnf_id"] = vnfr_id
1565 namespace
= "{nsi}.{ns}".format(nsi
=nsi_id
if nsi_id
else "", ns
=nsr_id
)
1567 if vca_type
== "native_charm":
1570 index_number
= vdu_index
or 0
1573 element_type
= "VNF"
1574 element_under_configuration
= vnfr_id
1575 namespace
+= ".{}-{}".format(vnfr_id
, index_number
)
1577 namespace
+= ".{}-{}".format(vdu_id
, index_number
)
1578 element_type
= "VDU"
1579 element_under_configuration
= "{}-{}".format(vdu_id
, index_number
)
1580 osm_config
["osm"]["vdu_id"] = vdu_id
1582 namespace
+= ".{}".format(kdu_name
)
1583 element_type
= "KDU"
1584 element_under_configuration
= kdu_name
1585 osm_config
["osm"]["kdu_name"] = kdu_name
1588 if base_folder
["pkg-dir"]:
1589 artifact_path
= "{}/{}/{}/{}".format(
1590 base_folder
["folder"],
1591 base_folder
["pkg-dir"],
1594 in ("native_charm", "lxc_proxy_charm", "k8s_proxy_charm")
1599 artifact_path
= "{}/Scripts/{}/{}/".format(
1600 base_folder
["folder"],
1603 in ("native_charm", "lxc_proxy_charm", "k8s_proxy_charm")
1608 self
.logger
.debug("Artifact path > {}".format(artifact_path
))
1610 # get initial_config_primitive_list that applies to this element
1611 initial_config_primitive_list
= config_descriptor
.get(
1612 "initial-config-primitive"
1616 "Initial config primitive list > {}".format(
1617 initial_config_primitive_list
1621 # add config if not present for NS charm
1622 ee_descriptor_id
= ee_config_descriptor
.get("id")
1623 self
.logger
.debug("EE Descriptor > {}".format(ee_descriptor_id
))
1624 initial_config_primitive_list
= get_ee_sorted_initial_config_primitive_list(
1625 initial_config_primitive_list
, vca_deployed
, ee_descriptor_id
1629 "Initial config primitive list #2 > {}".format(
1630 initial_config_primitive_list
1633 # n2vc_redesign STEP 3.1
1634 # find old ee_id if exists
1635 ee_id
= vca_deployed
.get("ee_id")
1637 vca_id
= self
.get_vca_id(db_vnfr
, db_nsr
)
1638 # create or register execution environment in VCA
1639 if vca_type
in ("lxc_proxy_charm", "k8s_proxy_charm", "helm-v3"):
1640 self
._write
_configuration
_status
(
1642 vca_index
=vca_index
,
1644 element_under_configuration
=element_under_configuration
,
1645 element_type
=element_type
,
1648 step
= "create execution environment"
1649 self
.logger
.debug(logging_text
+ step
)
1653 if vca_type
== "k8s_proxy_charm":
1654 ee_id
= await self
.vca_map
[vca_type
].install_k8s_proxy_charm(
1655 charm_name
=artifact_path
[artifact_path
.rfind("/") + 1 :],
1656 namespace
=namespace
,
1657 artifact_path
=artifact_path
,
1661 elif vca_type
== "helm-v3":
1662 ee_id
, credentials
= await self
.vca_map
[
1664 ].create_execution_environment(
1669 artifact_path
=artifact_path
,
1670 chart_model
=vca_name
,
1674 ee_id
, credentials
= await self
.vca_map
[
1676 ].create_execution_environment(
1677 namespace
=namespace
,
1683 elif vca_type
== "native_charm":
1684 step
= "Waiting to VM being up and getting IP address"
1685 self
.logger
.debug(logging_text
+ step
)
1686 rw_mgmt_ip
= await self
.wait_vm_up_insert_key_ro(
1695 credentials
= {"hostname": rw_mgmt_ip
}
1697 username
= deep_get(
1698 config_descriptor
, ("config-access", "ssh-access", "default-user")
1700 # TODO remove this when changes on IM regarding config-access:ssh-access:default-user were
1701 # merged. Meanwhile let's get username from initial-config-primitive
1702 if not username
and initial_config_primitive_list
:
1703 for config_primitive
in initial_config_primitive_list
:
1704 for param
in config_primitive
.get("parameter", ()):
1705 if param
["name"] == "ssh-username":
1706 username
= param
["value"]
1710 "Cannot determine the username neither with 'initial-config-primitive' nor with "
1711 "'config-access.ssh-access.default-user'"
1713 credentials
["username"] = username
1714 # n2vc_redesign STEP 3.2
1716 self
._write
_configuration
_status
(
1718 vca_index
=vca_index
,
1719 status
="REGISTERING",
1720 element_under_configuration
=element_under_configuration
,
1721 element_type
=element_type
,
1724 step
= "register execution environment {}".format(credentials
)
1725 self
.logger
.debug(logging_text
+ step
)
1726 ee_id
= await self
.vca_map
[vca_type
].register_execution_environment(
1727 credentials
=credentials
,
1728 namespace
=namespace
,
1733 # for compatibility with MON/POL modules, the need model and application name at database
1734 # TODO ask MON/POL if needed to not assuming anymore the format "model_name.application_name"
1735 ee_id_parts
= ee_id
.split(".")
1736 db_nsr_update
= {db_update_entry
+ "ee_id": ee_id
}
1737 if len(ee_id_parts
) >= 2:
1738 model_name
= ee_id_parts
[0]
1739 application_name
= ee_id_parts
[1]
1740 db_nsr_update
[db_update_entry
+ "model"] = model_name
1741 db_nsr_update
[db_update_entry
+ "application"] = application_name
1743 # n2vc_redesign STEP 3.3
1744 step
= "Install configuration Software"
1746 self
._write
_configuration
_status
(
1748 vca_index
=vca_index
,
1749 status
="INSTALLING SW",
1750 element_under_configuration
=element_under_configuration
,
1751 element_type
=element_type
,
1752 other_update
=db_nsr_update
,
1755 # TODO check if already done
1756 self
.logger
.debug(logging_text
+ step
)
1758 if vca_type
== "native_charm":
1759 config_primitive
= next(
1760 (p
for p
in initial_config_primitive_list
if p
["name"] == "config"),
1763 if config_primitive
:
1764 config
= self
._map
_primitive
_params
(
1765 config_primitive
, {}, deploy_params
1768 if vca_type
== "lxc_proxy_charm":
1769 if element_type
== "NS":
1770 num_units
= db_nsr
.get("config-units") or 1
1771 elif element_type
== "VNF":
1772 num_units
= db_vnfr
.get("config-units") or 1
1773 elif element_type
== "VDU":
1774 for v
in db_vnfr
["vdur"]:
1775 if vdu_id
== v
["vdu-id-ref"]:
1776 num_units
= v
.get("config-units") or 1
1778 if vca_type
!= "k8s_proxy_charm":
1779 await self
.vca_map
[vca_type
].install_configuration_sw(
1781 artifact_path
=artifact_path
,
1784 num_units
=num_units
,
1789 # write in db flag of configuration_sw already installed
1791 "nsrs", nsr_id
, {db_update_entry
+ "config_sw_installed": True}
1794 # add relations for this VCA (wait for other peers related with this VCA)
1795 is_relation_added
= await self
._add
_vca
_relations
(
1796 logging_text
=logging_text
,
1799 vca_index
=vca_index
,
1802 if not is_relation_added
:
1803 raise LcmException("Relations could not be added to VCA.")
1805 # if SSH access is required, then get execution environment SSH public
1806 # if native charm we have waited already to VM be UP
1807 if vca_type
in ("k8s_proxy_charm", "lxc_proxy_charm", "helm-v3"):
1810 # self.logger.debug("get ssh key block")
1812 config_descriptor
, ("config-access", "ssh-access", "required")
1814 # self.logger.debug("ssh key needed")
1815 # Needed to inject a ssh key
1818 ("config-access", "ssh-access", "default-user"),
1820 step
= "Install configuration Software, getting public ssh key"
1821 pub_key
= await self
.vca_map
[vca_type
].get_ee_ssh_public__key(
1822 ee_id
=ee_id
, db_dict
=db_dict
, vca_id
=vca_id
1825 step
= "Insert public key into VM user={} ssh_key={}".format(
1829 # self.logger.debug("no need to get ssh key")
1830 step
= "Waiting to VM being up and getting IP address"
1831 self
.logger
.debug(logging_text
+ step
)
1833 # default rw_mgmt_ip to None, avoiding the non definition of the variable
1836 # n2vc_redesign STEP 5.1
1837 # wait for RO (ip-address) Insert pub_key into VM
1840 rw_mgmt_ip
, services
= await self
.wait_kdu_up(
1841 logging_text
, nsr_id
, vnfr_id
, kdu_name
1843 vnfd
= self
.db
.get_one(
1845 {"_id": f
'{db_vnfr["vnfd-id"]}:{db_vnfr["revision"]}'},
1847 kdu
= get_kdu(vnfd
, kdu_name
)
1849 service
["name"] for service
in get_kdu_services(kdu
)
1851 exposed_services
= []
1852 for service
in services
:
1853 if any(s
in service
["name"] for s
in kdu_services
):
1854 exposed_services
.append(service
)
1855 await self
.vca_map
[vca_type
].exec_primitive(
1857 primitive_name
="config",
1859 "osm-config": json
.dumps(
1861 k8s
={"services": exposed_services
}
1868 # This verification is needed in order to avoid trying to add a public key
1869 # to a VM, when the VNF is a KNF (in the edge case where the user creates a VCA
1870 # for a KNF and not for its KDUs, the previous verification gives False, and the code
1871 # jumps to this block, meaning that there is the need to verify if the VNF is actually a VNF
1873 elif db_vnfr
.get("vdur"):
1874 rw_mgmt_ip
= await self
.wait_vm_up_insert_key_ro(
1884 self
.logger
.debug(logging_text
+ " VM_ip_address={}".format(rw_mgmt_ip
))
1886 # store rw_mgmt_ip in deploy params for later replacement
1887 deploy_params
["rw_mgmt_ip"] = rw_mgmt_ip
1889 # n2vc_redesign STEP 6 Execute initial config primitive
1890 step
= "execute initial config primitive"
1892 # wait for dependent primitives execution (NS -> VNF -> VDU)
1893 if initial_config_primitive_list
:
1894 await self
._wait
_dependent
_n
2vc
(nsr_id
, vca_deployed_list
, vca_index
)
1896 # stage, in function of element type: vdu, kdu, vnf or ns
1897 my_vca
= vca_deployed_list
[vca_index
]
1898 if my_vca
.get("vdu_id") or my_vca
.get("kdu_name"):
1900 stage
[0] = "Stage 3/5: running Day-1 primitives for VDU."
1901 elif my_vca
.get("member-vnf-index"):
1903 stage
[0] = "Stage 4/5: running Day-1 primitives for VNF."
1906 stage
[0] = "Stage 5/5: running Day-1 primitives for NS."
1908 self
._write
_configuration
_status
(
1909 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="EXECUTING PRIMITIVE"
1912 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
)
1914 check_if_terminated_needed
= True
1915 for initial_config_primitive
in initial_config_primitive_list
:
1916 # adding information on the vca_deployed if it is a NS execution environment
1917 if not vca_deployed
["member-vnf-index"]:
1918 deploy_params
["ns_config_info"] = json
.dumps(
1919 self
._get
_ns
_config
_info
(nsr_id
)
1921 # TODO check if already done
1922 primitive_params_
= self
._map
_primitive
_params
(
1923 initial_config_primitive
, {}, deploy_params
1926 step
= "execute primitive '{}' params '{}'".format(
1927 initial_config_primitive
["name"], primitive_params_
1929 self
.logger
.debug(logging_text
+ step
)
1930 await self
.vca_map
[vca_type
].exec_primitive(
1932 primitive_name
=initial_config_primitive
["name"],
1933 params_dict
=primitive_params_
,
1938 # Once some primitive has been exec, check and write at db if it needs to exec terminated primitives
1939 if check_if_terminated_needed
:
1940 if config_descriptor
.get("terminate-config-primitive"):
1942 "nsrs", nsr_id
, {db_update_entry
+ "needed_terminate": True}
1944 check_if_terminated_needed
= False
1946 # TODO register in database that primitive is done
1948 # STEP 7 Configure metrics
1949 if vca_type
== "helm-v3":
1950 # TODO: review for those cases where the helm chart is a reference and
1951 # is not part of the NF package
1952 prometheus_jobs
= await self
.extract_prometheus_scrape_jobs(
1954 artifact_path
=artifact_path
,
1955 ee_config_descriptor
=ee_config_descriptor
,
1958 target_ip
=rw_mgmt_ip
,
1959 element_type
=element_type
,
1960 vnf_member_index
=db_vnfr
.get("member-vnf-index-ref", ""),
1962 vdu_index
=vdu_index
,
1964 kdu_index
=kdu_index
,
1970 {db_update_entry
+ "prometheus_jobs": prometheus_jobs
},
1973 for job
in prometheus_jobs
:
1976 {"job_name": job
["job_name"]},
1979 fail_on_empty
=False,
1982 step
= "instantiated at VCA"
1983 self
.logger
.debug(logging_text
+ step
)
1985 self
._write
_configuration
_status
(
1986 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="READY"
1989 except Exception as e
: # TODO not use Exception but N2VC exception
1990 # self.update_db_2("nsrs", nsr_id, {db_update_entry + "instantiation": "FAILED"})
1992 e
, (DbException
, N2VCException
, LcmException
, asyncio
.CancelledError
)
1995 "Exception while {} : {}".format(step
, e
), exc_info
=True
1997 self
._write
_configuration
_status
(
1998 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="BROKEN"
2000 raise LcmException("{}. {}".format(step
, e
)) from e
2002 def _write_ns_status(
2006 current_operation
: str,
2007 current_operation_id
: str,
2008 error_description
: str = None,
2009 error_detail
: str = None,
2010 other_update
: dict = None,
2013 Update db_nsr fields.
2016 :param current_operation:
2017 :param current_operation_id:
2018 :param error_description:
2019 :param error_detail:
2020 :param other_update: Other required changes at database if provided, will be cleared
2024 db_dict
= other_update
or {}
2027 ] = current_operation_id
# for backward compatibility
2028 db_dict
["_admin.current-operation"] = current_operation_id
2029 db_dict
["_admin.operation-type"] = (
2030 current_operation
if current_operation
!= "IDLE" else None
2032 db_dict
["currentOperation"] = current_operation
2033 db_dict
["currentOperationID"] = current_operation_id
2034 db_dict
["errorDescription"] = error_description
2035 db_dict
["errorDetail"] = error_detail
2038 db_dict
["nsState"] = ns_state
2039 self
.update_db_2("nsrs", nsr_id
, db_dict
)
2040 except DbException
as e
:
2041 self
.logger
.warn("Error writing NS status, ns={}: {}".format(nsr_id
, e
))
2043 def _write_op_status(
2047 error_message
: str = None,
2048 queuePosition
: int = 0,
2049 operation_state
: str = None,
2050 other_update
: dict = None,
2053 db_dict
= other_update
or {}
2054 db_dict
["queuePosition"] = queuePosition
2055 if isinstance(stage
, list):
2056 db_dict
["stage"] = stage
[0]
2057 db_dict
["detailed-status"] = " ".join(stage
)
2058 elif stage
is not None:
2059 db_dict
["stage"] = str(stage
)
2061 if error_message
is not None:
2062 db_dict
["errorMessage"] = error_message
2063 if operation_state
is not None:
2064 db_dict
["operationState"] = operation_state
2065 db_dict
["statusEnteredTime"] = time()
2066 self
.update_db_2("nslcmops", op_id
, db_dict
)
2067 except DbException
as e
:
2069 "Error writing OPERATION status for op_id: {} -> {}".format(op_id
, e
)
2072 def _write_all_config_status(self
, db_nsr
: dict, status
: str):
2074 nsr_id
= db_nsr
["_id"]
2075 # configurationStatus
2076 config_status
= db_nsr
.get("configurationStatus")
2079 "configurationStatus.{}.status".format(index
): status
2080 for index
, v
in enumerate(config_status
)
2084 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
2086 except DbException
as e
:
2088 "Error writing all configuration status, ns={}: {}".format(nsr_id
, e
)
2091 def _write_configuration_status(
2096 element_under_configuration
: str = None,
2097 element_type
: str = None,
2098 other_update
: dict = None,
2100 # self.logger.debug('_write_configuration_status(): vca_index={}, status={}'
2101 # .format(vca_index, status))
2104 db_path
= "configurationStatus.{}.".format(vca_index
)
2105 db_dict
= other_update
or {}
2107 db_dict
[db_path
+ "status"] = status
2108 if element_under_configuration
:
2110 db_path
+ "elementUnderConfiguration"
2111 ] = element_under_configuration
2113 db_dict
[db_path
+ "elementType"] = element_type
2114 self
.update_db_2("nsrs", nsr_id
, db_dict
)
2115 except DbException
as e
:
2117 "Error writing configuration status={}, ns={}, vca_index={}: {}".format(
2118 status
, nsr_id
, vca_index
, e
2122 async def _do_placement(self
, logging_text
, db_nslcmop
, db_vnfrs
):
2124 Check and computes the placement, (vim account where to deploy). If it is decided by an external tool, it
2125 sends the request via kafka and wait until the result is wrote at database (nslcmops _admin.plca).
2126 Database is used because the result can be obtained from a different LCM worker in case of HA.
2127 :param logging_text: contains the prefix for logging, with the ns and nslcmop identifiers
2128 :param db_nslcmop: database content of nslcmop
2129 :param db_vnfrs: database content of vnfrs, indexed by member-vnf-index.
2130 :return: True if some modification is done. Modifies database vnfrs and parameter db_vnfr with the
2131 computed 'vim-account-id'
2134 nslcmop_id
= db_nslcmop
["_id"]
2135 placement_engine
= deep_get(db_nslcmop
, ("operationParams", "placement-engine"))
2136 if placement_engine
== "PLA":
2138 logging_text
+ "Invoke and wait for placement optimization"
2140 await self
.msg
.aiowrite("pla", "get_placement", {"nslcmopId": nslcmop_id
})
2141 db_poll_interval
= 5
2142 wait
= db_poll_interval
* 10
2144 while not pla_result
and wait
>= 0:
2145 await asyncio
.sleep(db_poll_interval
)
2146 wait
-= db_poll_interval
2147 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
2148 pla_result
= deep_get(db_nslcmop
, ("_admin", "pla"))
2152 "Placement timeout for nslcmopId={}".format(nslcmop_id
)
2155 for pla_vnf
in pla_result
["vnf"]:
2156 vnfr
= db_vnfrs
.get(pla_vnf
["member-vnf-index"])
2157 if not pla_vnf
.get("vimAccountId") or not vnfr
:
2162 {"_id": vnfr
["_id"]},
2163 {"vim-account-id": pla_vnf
["vimAccountId"]},
2166 vnfr
["vim-account-id"] = pla_vnf
["vimAccountId"]
2169 def _gather_vnfr_healing_alerts(self
, vnfr
, vnfd
):
2171 nsr_id
= vnfr
["nsr-id-ref"]
2172 df
= vnfd
.get("df", [{}])[0]
2173 # Checking for auto-healing configuration
2174 if "healing-aspect" in df
:
2175 healing_aspects
= df
["healing-aspect"]
2176 for healing
in healing_aspects
:
2177 for healing_policy
in healing
.get("healing-policy", ()):
2178 vdu_id
= healing_policy
["vdu-id"]
2180 (vdur
for vdur
in vnfr
["vdur"] if vdu_id
== vdur
["vdu-id-ref"]),
2185 metric_name
= "vm_status"
2186 vdu_name
= vdur
.get("name")
2187 vnf_member_index
= vnfr
["member-vnf-index-ref"]
2189 name
= f
"healing_{uuid}"
2190 action
= healing_policy
2191 # action_on_recovery = healing.get("action-on-recovery")
2192 # cooldown_time = healing.get("cooldown-time")
2193 # day1 = healing.get("day1")
2197 "metric": metric_name
,
2200 "vnf_member_index": vnf_member_index
,
2201 "vdu_name": vdu_name
,
2203 "alarm_status": "ok",
2204 "action_type": "healing",
2207 alerts
.append(alert
)
2210 def _gather_vnfr_scaling_alerts(self
, vnfr
, vnfd
):
2212 nsr_id
= vnfr
["nsr-id-ref"]
2213 df
= vnfd
.get("df", [{}])[0]
2214 # Checking for auto-scaling configuration
2215 if "scaling-aspect" in df
:
2216 scaling_aspects
= df
["scaling-aspect"]
2217 all_vnfd_monitoring_params
= {}
2218 for ivld
in vnfd
.get("int-virtual-link-desc", ()):
2219 for mp
in ivld
.get("monitoring-parameters", ()):
2220 all_vnfd_monitoring_params
[mp
.get("id")] = mp
2221 for vdu
in vnfd
.get("vdu", ()):
2222 for mp
in vdu
.get("monitoring-parameter", ()):
2223 all_vnfd_monitoring_params
[mp
.get("id")] = mp
2224 for df
in vnfd
.get("df", ()):
2225 for mp
in df
.get("monitoring-parameter", ()):
2226 all_vnfd_monitoring_params
[mp
.get("id")] = mp
2227 for scaling_aspect
in scaling_aspects
:
2228 scaling_group_name
= scaling_aspect
.get("name", "")
2229 # Get monitored VDUs
2230 all_monitored_vdus
= set()
2231 for delta
in scaling_aspect
.get("aspect-delta-details", {}).get(
2234 for vdu_delta
in delta
.get("vdu-delta", ()):
2235 all_monitored_vdus
.add(vdu_delta
.get("id"))
2236 monitored_vdurs
= list(
2238 lambda vdur
: vdur
["vdu-id-ref"] in all_monitored_vdus
,
2242 if not monitored_vdurs
:
2244 "Scaling criteria is referring to a vnf-monitoring-param that does not contain a reference to a vdu or vnf metric"
2247 for scaling_policy
in scaling_aspect
.get("scaling-policy", ()):
2248 if scaling_policy
["scaling-type"] != "automatic":
2250 threshold_time
= scaling_policy
.get("threshold-time", "1")
2251 cooldown_time
= scaling_policy
.get("cooldown-time", "0")
2252 for scaling_criteria
in scaling_policy
["scaling-criteria"]:
2253 monitoring_param_ref
= scaling_criteria
.get(
2254 "vnf-monitoring-param-ref"
2256 vnf_monitoring_param
= all_vnfd_monitoring_params
[
2257 monitoring_param_ref
2259 for vdur
in monitored_vdurs
:
2260 vdu_id
= vdur
["vdu-id-ref"]
2261 metric_name
= vnf_monitoring_param
.get("performance-metric")
2262 metric_name
= f
"osm_{metric_name}"
2263 vnf_member_index
= vnfr
["member-vnf-index-ref"]
2264 scalein_threshold
= scaling_criteria
.get(
2265 "scale-in-threshold"
2267 scaleout_threshold
= scaling_criteria
.get(
2268 "scale-out-threshold"
2270 # Looking for min/max-number-of-instances
2271 instances_min_number
= 1
2272 instances_max_number
= 1
2273 vdu_profile
= df
["vdu-profile"]
2276 item
for item
in vdu_profile
if item
["id"] == vdu_id
2278 instances_min_number
= profile
.get(
2279 "min-number-of-instances", 1
2281 instances_max_number
= profile
.get(
2282 "max-number-of-instances", 1
2285 if scalein_threshold
:
2287 name
= f
"scalein_{uuid}"
2288 operation
= scaling_criteria
[
2289 "scale-in-relational-operation"
2291 rel_operator
= self
.rel_operation_types
.get(
2294 metric_selector
= f
'{metric_name}{{ns_id="{nsr_id}", vnf_member_index="{vnf_member_index}", vdu_id="{vdu_id}"}}'
2295 expression
= f
"(count ({metric_selector}) > {instances_min_number}) and (avg({metric_selector}) {rel_operator} {scalein_threshold})"
2298 "vnf_member_index": vnf_member_index
,
2304 "for": str(threshold_time
) + "m",
2307 action
= scaling_policy
2309 "scaling-group": scaling_group_name
,
2310 "cooldown-time": cooldown_time
,
2315 "metric": metric_name
,
2318 "vnf_member_index": vnf_member_index
,
2321 "alarm_status": "ok",
2322 "action_type": "scale_in",
2324 "prometheus_config": prom_cfg
,
2326 alerts
.append(alert
)
2328 if scaleout_threshold
:
2330 name
= f
"scaleout_{uuid}"
2331 operation
= scaling_criteria
[
2332 "scale-out-relational-operation"
2334 rel_operator
= self
.rel_operation_types
.get(
2337 metric_selector
= f
'{metric_name}{{ns_id="{nsr_id}", vnf_member_index="{vnf_member_index}", vdu_id="{vdu_id}"}}'
2338 expression
= f
"(count ({metric_selector}) < {instances_max_number}) and (avg({metric_selector}) {rel_operator} {scaleout_threshold})"
2341 "vnf_member_index": vnf_member_index
,
2347 "for": str(threshold_time
) + "m",
2350 action
= scaling_policy
2352 "scaling-group": scaling_group_name
,
2353 "cooldown-time": cooldown_time
,
2358 "metric": metric_name
,
2361 "vnf_member_index": vnf_member_index
,
2364 "alarm_status": "ok",
2365 "action_type": "scale_out",
2367 "prometheus_config": prom_cfg
,
2369 alerts
.append(alert
)
2372 def _gather_vnfr_alarm_alerts(self
, vnfr
, vnfd
):
2374 nsr_id
= vnfr
["nsr-id-ref"]
2375 vnf_member_index
= vnfr
["member-vnf-index-ref"]
2377 # Checking for VNF alarm configuration
2378 for vdur
in vnfr
["vdur"]:
2379 vdu_id
= vdur
["vdu-id-ref"]
2380 vdu
= next(filter(lambda vdu
: vdu
["id"] == vdu_id
, vnfd
["vdu"]))
2382 # Get VDU monitoring params, since alerts are based on them
2383 vdu_monitoring_params
= {}
2384 for mp
in vdu
.get("monitoring-parameter", []):
2385 vdu_monitoring_params
[mp
.get("id")] = mp
2386 if not vdu_monitoring_params
:
2388 "VDU alarm refers to a VDU monitoring param, but there are no VDU monitoring params in the VDU"
2391 # Get alarms in the VDU
2392 alarm_descriptors
= vdu
["alarm"]
2393 # Create VDU alarms for each alarm in the VDU
2394 for alarm_descriptor
in alarm_descriptors
:
2395 # Check that the VDU alarm refers to a proper monitoring param
2396 alarm_monitoring_param
= alarm_descriptor
.get(
2397 "vnf-monitoring-param-ref", ""
2399 vdu_specific_monitoring_param
= vdu_monitoring_params
.get(
2400 alarm_monitoring_param
, {}
2402 if not vdu_specific_monitoring_param
:
2404 "VDU alarm refers to a VDU monitoring param not present in the VDU"
2407 metric_name
= vdu_specific_monitoring_param
.get(
2408 "performance-metric"
2412 "VDU alarm refers to a VDU monitoring param that has no associated performance-metric"
2415 # Set params of the alarm to be created in Prometheus
2416 metric_name
= f
"osm_{metric_name}"
2417 metric_threshold
= alarm_descriptor
.get("value")
2419 alert_name
= f
"vdu_alarm_{uuid}"
2420 operation
= alarm_descriptor
["operation"]
2421 rel_operator
= self
.rel_operation_types
.get(operation
, "<=")
2422 metric_selector
= f
'{metric_name}{{ns_id="{nsr_id}", vnf_member_index="{vnf_member_index}", vdu_id="{vdu_id}"}}'
2423 expression
= f
"{metric_selector} {rel_operator} {metric_threshold}"
2426 "vnf_member_index": vnf_member_index
,
2428 "vdu_name": "{{ $labels.vdu_name }}",
2431 "alert": alert_name
,
2433 "for": "1m", # default value. Ideally, this should be related to an IM param, but there is not such param
2436 alarm_action
= dict()
2437 for action_type
in ["ok", "insufficient-data", "alarm"]:
2439 "actions" in alarm_descriptor
2440 and action_type
in alarm_descriptor
["actions"]
2442 alarm_action
[action_type
] = alarm_descriptor
["actions"][
2448 "metric": metric_name
,
2451 "vnf_member_index": vnf_member_index
,
2454 "alarm_status": "ok",
2455 "action_type": "vdu_alarm",
2456 "action": alarm_action
,
2457 "prometheus_config": prom_cfg
,
2459 alerts
.append(alert
)
2462 def update_nsrs_with_pla_result(self
, params
):
2464 nslcmop_id
= deep_get(params
, ("placement", "nslcmopId"))
2466 "nslcmops", nslcmop_id
, {"_admin.pla": params
.get("placement")}
2468 except Exception as e
:
2469 self
.logger
.warn("Update failed for nslcmop_id={}:{}".format(nslcmop_id
, e
))
2471 async def instantiate(self
, nsr_id
, nslcmop_id
):
2474 :param nsr_id: ns instance to deploy
2475 :param nslcmop_id: operation to run
2479 # Try to lock HA task here
2480 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
2481 if not task_is_locked_by_me
:
2483 "instantiate() task is not locked by me, ns={}".format(nsr_id
)
2487 logging_text
= "Task ns={} instantiate={} ".format(nsr_id
, nslcmop_id
)
2488 self
.logger
.debug(logging_text
+ "Enter")
2490 # get all needed from database
2492 # database nsrs record
2495 # database nslcmops record
2498 # update operation on nsrs
2500 # update operation on nslcmops
2501 db_nslcmop_update
= {}
2503 timeout_ns_deploy
= self
.timeout
.ns_deploy
2505 nslcmop_operation_state
= None
2506 db_vnfrs
= {} # vnf's info indexed by member-index
2508 tasks_dict_info
= {} # from task to info text
2512 "Stage 1/5: preparation of the environment.",
2513 "Waiting for previous operations to terminate.",
2516 # ^ stage, step, VIM progress
2518 # wait for any previous tasks in process
2519 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
2521 # STEP 0: Reading database (nslcmops, nsrs, nsds, vnfrs, vnfds)
2522 stage
[1] = "Reading from database."
2523 # nsState="BUILDING", currentOperation="INSTANTIATING", currentOperationID=nslcmop_id
2524 db_nsr_update
["detailed-status"] = "creating"
2525 db_nsr_update
["operational-status"] = "init"
2526 self
._write
_ns
_status
(
2528 ns_state
="BUILDING",
2529 current_operation
="INSTANTIATING",
2530 current_operation_id
=nslcmop_id
,
2531 other_update
=db_nsr_update
,
2533 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
, queuePosition
=0)
2535 # read from db: operation
2536 stage
[1] = "Getting nslcmop={} from db.".format(nslcmop_id
)
2537 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
2538 if db_nslcmop
["operationParams"].get("additionalParamsForVnf"):
2539 db_nslcmop
["operationParams"]["additionalParamsForVnf"] = json
.loads(
2540 db_nslcmop
["operationParams"]["additionalParamsForVnf"]
2542 ns_params
= db_nslcmop
.get("operationParams")
2543 if ns_params
and ns_params
.get("timeout_ns_deploy"):
2544 timeout_ns_deploy
= ns_params
["timeout_ns_deploy"]
2547 stage
[1] = "Getting nsr={} from db.".format(nsr_id
)
2548 self
.logger
.debug(logging_text
+ stage
[1])
2549 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
2550 stage
[1] = "Getting nsd={} from db.".format(db_nsr
["nsd-id"])
2551 self
.logger
.debug(logging_text
+ stage
[1])
2552 nsd
= self
.db
.get_one("nsds", {"_id": db_nsr
["nsd-id"]})
2553 self
.fs
.sync(db_nsr
["nsd-id"])
2555 # nsr_name = db_nsr["name"] # TODO short-name??
2557 # read from db: vnf's of this ns
2558 stage
[1] = "Getting vnfrs from db."
2559 self
.logger
.debug(logging_text
+ stage
[1])
2560 db_vnfrs_list
= self
.db
.get_list("vnfrs", {"nsr-id-ref": nsr_id
})
2562 # read from db: vnfd's for every vnf
2563 db_vnfds
= [] # every vnfd data
2565 # for each vnf in ns, read vnfd
2566 for vnfr
in db_vnfrs_list
:
2567 if vnfr
.get("kdur"):
2569 for kdur
in vnfr
["kdur"]:
2570 if kdur
.get("additionalParams"):
2571 kdur
["additionalParams"] = json
.loads(
2572 kdur
["additionalParams"]
2574 kdur_list
.append(kdur
)
2575 vnfr
["kdur"] = kdur_list
2577 db_vnfrs
[vnfr
["member-vnf-index-ref"]] = vnfr
2578 vnfd_id
= vnfr
["vnfd-id"]
2579 vnfd_ref
= vnfr
["vnfd-ref"]
2580 self
.fs
.sync(vnfd_id
)
2582 # if we haven't this vnfd, read it from db
2583 if vnfd_id
not in db_vnfds
:
2585 stage
[1] = "Getting vnfd={} id='{}' from db.".format(
2588 self
.logger
.debug(logging_text
+ stage
[1])
2589 vnfd
= self
.db
.get_one("vnfds", {"_id": vnfd_id
})
2592 db_vnfds
.append(vnfd
)
2594 # Get or generates the _admin.deployed.VCA list
2595 vca_deployed_list
= None
2596 if db_nsr
["_admin"].get("deployed"):
2597 vca_deployed_list
= db_nsr
["_admin"]["deployed"].get("VCA")
2598 if vca_deployed_list
is None:
2599 vca_deployed_list
= []
2600 configuration_status_list
= []
2601 db_nsr_update
["_admin.deployed.VCA"] = vca_deployed_list
2602 db_nsr_update
["configurationStatus"] = configuration_status_list
2603 # add _admin.deployed.VCA to db_nsr dictionary, value=vca_deployed_list
2604 populate_dict(db_nsr
, ("_admin", "deployed", "VCA"), vca_deployed_list
)
2605 elif isinstance(vca_deployed_list
, dict):
2606 # maintain backward compatibility. Change a dict to list at database
2607 vca_deployed_list
= list(vca_deployed_list
.values())
2608 db_nsr_update
["_admin.deployed.VCA"] = vca_deployed_list
2609 populate_dict(db_nsr
, ("_admin", "deployed", "VCA"), vca_deployed_list
)
2612 deep_get(db_nsr
, ("_admin", "deployed", "RO", "vnfd")), list
2614 populate_dict(db_nsr
, ("_admin", "deployed", "RO", "vnfd"), [])
2615 db_nsr_update
["_admin.deployed.RO.vnfd"] = []
2617 # set state to INSTANTIATED. When instantiated NBI will not delete directly
2618 db_nsr_update
["_admin.nsState"] = "INSTANTIATED"
2619 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
2621 "vnfrs", {"nsr-id-ref": nsr_id
}, {"_admin.nsState": "INSTANTIATED"}
2624 # n2vc_redesign STEP 2 Deploy Network Scenario
2625 stage
[0] = "Stage 2/5: deployment of KDUs, VMs and execution environments."
2626 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
)
2628 stage
[1] = "Deploying KDUs."
2629 # self.logger.debug(logging_text + "Before deploy_kdus")
2630 # Call to deploy_kdus in case exists the "vdu:kdu" param
2631 await self
.deploy_kdus(
2632 logging_text
=logging_text
,
2634 nslcmop_id
=nslcmop_id
,
2637 task_instantiation_info
=tasks_dict_info
,
2640 stage
[1] = "Getting VCA public key."
2641 # n2vc_redesign STEP 1 Get VCA public ssh-key
2642 # feature 1429. Add n2vc public key to needed VMs
2643 n2vc_key
= self
.n2vc
.get_public_key()
2644 n2vc_key_list
= [n2vc_key
]
2645 if self
.vca_config
.public_key
:
2646 n2vc_key_list
.append(self
.vca_config
.public_key
)
2648 stage
[1] = "Deploying NS at VIM."
2649 task_ro
= asyncio
.ensure_future(
2650 self
.instantiate_RO(
2651 logging_text
=logging_text
,
2655 db_nslcmop
=db_nslcmop
,
2658 n2vc_key_list
=n2vc_key_list
,
2662 self
.lcm_tasks
.register("ns", nsr_id
, nslcmop_id
, "instantiate_RO", task_ro
)
2663 tasks_dict_info
[task_ro
] = "Deploying at VIM"
2665 # n2vc_redesign STEP 3 to 6 Deploy N2VC
2666 stage
[1] = "Deploying Execution Environments."
2667 self
.logger
.debug(logging_text
+ stage
[1])
2669 # create namespace and certificate if any helm based EE is present in the NS
2670 if check_helm_ee_in_ns(db_vnfds
):
2671 await self
.vca_map
["helm-v3"].setup_ns_namespace(
2674 # create TLS certificates
2675 await self
.vca_map
["helm-v3"].create_tls_certificate(
2676 secret_name
=self
.EE_TLS_NAME
,
2679 usage
="server auth",
2683 nsi_id
= None # TODO put nsi_id when this nsr belongs to a NSI
2684 for vnf_profile
in get_vnf_profiles(nsd
):
2685 vnfd_id
= vnf_profile
["vnfd-id"]
2686 vnfd
= find_in_list(db_vnfds
, lambda a_vnf
: a_vnf
["id"] == vnfd_id
)
2687 member_vnf_index
= str(vnf_profile
["id"])
2688 db_vnfr
= db_vnfrs
[member_vnf_index
]
2689 base_folder
= vnfd
["_admin"]["storage"]
2696 # Get additional parameters
2697 deploy_params
= {"OSM": get_osm_params(db_vnfr
)}
2698 if db_vnfr
.get("additionalParamsForVnf"):
2699 deploy_params
.update(
2700 parse_yaml_strings(db_vnfr
["additionalParamsForVnf"].copy())
2703 descriptor_config
= get_configuration(vnfd
, vnfd
["id"])
2704 if descriptor_config
:
2706 logging_text
=logging_text
2707 + "member_vnf_index={} ".format(member_vnf_index
),
2710 nslcmop_id
=nslcmop_id
,
2716 member_vnf_index
=member_vnf_index
,
2717 vdu_index
=vdu_index
,
2718 kdu_index
=kdu_index
,
2720 deploy_params
=deploy_params
,
2721 descriptor_config
=descriptor_config
,
2722 base_folder
=base_folder
,
2723 task_instantiation_info
=tasks_dict_info
,
2727 # Deploy charms for each VDU that supports one.
2728 for vdud
in get_vdu_list(vnfd
):
2730 descriptor_config
= get_configuration(vnfd
, vdu_id
)
2731 vdur
= find_in_list(
2732 db_vnfr
["vdur"], lambda vdu
: vdu
["vdu-id-ref"] == vdu_id
2735 if vdur
.get("additionalParams"):
2736 deploy_params_vdu
= parse_yaml_strings(vdur
["additionalParams"])
2738 deploy_params_vdu
= deploy_params
2739 deploy_params_vdu
["OSM"] = get_osm_params(
2740 db_vnfr
, vdu_id
, vdu_count_index
=0
2742 vdud_count
= get_number_of_instances(vnfd
, vdu_id
)
2744 self
.logger
.debug("VDUD > {}".format(vdud
))
2746 "Descriptor config > {}".format(descriptor_config
)
2748 if descriptor_config
:
2752 for vdu_index
in range(vdud_count
):
2753 # TODO vnfr_params["rw_mgmt_ip"] = vdur["ip-address"]
2755 logging_text
=logging_text
2756 + "member_vnf_index={}, vdu_id={}, vdu_index={} ".format(
2757 member_vnf_index
, vdu_id
, vdu_index
2761 nslcmop_id
=nslcmop_id
,
2767 kdu_index
=kdu_index
,
2768 member_vnf_index
=member_vnf_index
,
2769 vdu_index
=vdu_index
,
2771 deploy_params
=deploy_params_vdu
,
2772 descriptor_config
=descriptor_config
,
2773 base_folder
=base_folder
,
2774 task_instantiation_info
=tasks_dict_info
,
2777 for kdud
in get_kdu_list(vnfd
):
2778 kdu_name
= kdud
["name"]
2779 descriptor_config
= get_configuration(vnfd
, kdu_name
)
2780 if descriptor_config
:
2784 kdu_index
, kdur
= next(
2786 for x
in enumerate(db_vnfr
["kdur"])
2787 if x
[1]["kdu-name"] == kdu_name
2789 deploy_params_kdu
= {"OSM": get_osm_params(db_vnfr
)}
2790 if kdur
.get("additionalParams"):
2791 deploy_params_kdu
.update(
2792 parse_yaml_strings(kdur
["additionalParams"].copy())
2796 logging_text
=logging_text
,
2799 nslcmop_id
=nslcmop_id
,
2805 member_vnf_index
=member_vnf_index
,
2806 vdu_index
=vdu_index
,
2807 kdu_index
=kdu_index
,
2809 deploy_params
=deploy_params_kdu
,
2810 descriptor_config
=descriptor_config
,
2811 base_folder
=base_folder
,
2812 task_instantiation_info
=tasks_dict_info
,
2816 # Check if each vnf has exporter for metric collection if so update prometheus job records
2817 if "exporters-endpoints" in vnfd
.get("df")[0]:
2818 exporter_config
= vnfd
.get("df")[0].get("exporters-endpoints")
2819 self
.logger
.debug("exporter config :{}".format(exporter_config
))
2820 artifact_path
= "{}/{}/{}".format(
2821 base_folder
["folder"],
2822 base_folder
["pkg-dir"],
2823 "exporter-endpoint",
2826 ee_config_descriptor
= exporter_config
2827 vnfr_id
= db_vnfr
["id"]
2828 rw_mgmt_ip
= await self
.wait_vm_up_insert_key_ro(
2837 self
.logger
.debug("rw_mgmt_ip:{}".format(rw_mgmt_ip
))
2838 self
.logger
.debug("Artifact_path:{}".format(artifact_path
))
2839 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnfr_id
})
2840 vdu_id_for_prom
= None
2841 vdu_index_for_prom
= None
2842 for x
in get_iterable(db_vnfr
, "vdur"):
2843 vdu_id_for_prom
= x
.get("vdu-id-ref")
2844 vdu_index_for_prom
= x
.get("count-index")
2845 prometheus_jobs
= await self
.extract_prometheus_scrape_jobs(
2847 artifact_path
=artifact_path
,
2848 ee_config_descriptor
=ee_config_descriptor
,
2851 target_ip
=rw_mgmt_ip
,
2853 vdu_id
=vdu_id_for_prom
,
2854 vdu_index
=vdu_index_for_prom
,
2857 self
.logger
.debug("Prometheus job:{}".format(prometheus_jobs
))
2859 db_nsr_update
["_admin.deployed.prometheus_jobs"] = prometheus_jobs
2866 for job
in prometheus_jobs
:
2869 {"job_name": job
["job_name"]},
2872 fail_on_empty
=False,
2875 # Check if this NS has a charm configuration
2876 descriptor_config
= nsd
.get("ns-configuration")
2877 if descriptor_config
and descriptor_config
.get("juju"):
2880 member_vnf_index
= None
2887 # Get additional parameters
2888 deploy_params
= {"OSM": {"vim_account_id": ns_params
["vimAccountId"]}}
2889 if db_nsr
.get("additionalParamsForNs"):
2890 deploy_params
.update(
2891 parse_yaml_strings(db_nsr
["additionalParamsForNs"].copy())
2893 base_folder
= nsd
["_admin"]["storage"]
2895 logging_text
=logging_text
,
2898 nslcmop_id
=nslcmop_id
,
2904 member_vnf_index
=member_vnf_index
,
2905 vdu_index
=vdu_index
,
2906 kdu_index
=kdu_index
,
2908 deploy_params
=deploy_params
,
2909 descriptor_config
=descriptor_config
,
2910 base_folder
=base_folder
,
2911 task_instantiation_info
=tasks_dict_info
,
2915 # rest of staff will be done at finally
2918 ROclient
.ROClientException
,
2924 logging_text
+ "Exit Exception while '{}': {}".format(stage
[1], e
)
2927 except asyncio
.CancelledError
:
2929 logging_text
+ "Cancelled Exception while '{}'".format(stage
[1])
2931 exc
= "Operation was cancelled"
2932 except Exception as e
:
2933 exc
= traceback
.format_exc()
2934 self
.logger
.critical(
2935 logging_text
+ "Exit Exception while '{}': {}".format(stage
[1], e
),
2940 error_list
.append(str(exc
))
2942 # wait for pending tasks
2944 stage
[1] = "Waiting for instantiate pending tasks."
2945 self
.logger
.debug(logging_text
+ stage
[1])
2946 error_list
+= await self
._wait
_for
_tasks
(
2954 stage
[1] = stage
[2] = ""
2955 except asyncio
.CancelledError
:
2956 error_list
.append("Cancelled")
2957 # TODO cancel all tasks
2958 except Exception as exc
:
2959 error_list
.append(str(exc
))
2961 # update operation-status
2962 db_nsr_update
["operational-status"] = "running"
2963 # let's begin with VCA 'configured' status (later we can change it)
2964 db_nsr_update
["config-status"] = "configured"
2965 for task
, task_name
in tasks_dict_info
.items():
2966 if not task
.done() or task
.cancelled() or task
.exception():
2967 if task_name
.startswith(self
.task_name_deploy_vca
):
2968 # A N2VC task is pending
2969 db_nsr_update
["config-status"] = "failed"
2971 # RO or KDU task is pending
2972 db_nsr_update
["operational-status"] = "failed"
2974 # update status at database
2976 error_detail
= ". ".join(error_list
)
2977 self
.logger
.error(logging_text
+ error_detail
)
2978 error_description_nslcmop
= "{} Detail: {}".format(
2979 stage
[0], error_detail
2981 error_description_nsr
= "Operation: INSTANTIATING.{}, {}".format(
2982 nslcmop_id
, stage
[0]
2985 db_nsr_update
["detailed-status"] = (
2986 error_description_nsr
+ " Detail: " + error_detail
2988 db_nslcmop_update
["detailed-status"] = error_detail
2989 nslcmop_operation_state
= "FAILED"
2993 error_description_nsr
= error_description_nslcmop
= None
2995 db_nsr_update
["detailed-status"] = "Done"
2996 db_nslcmop_update
["detailed-status"] = "Done"
2997 nslcmop_operation_state
= "COMPLETED"
2998 # Gather auto-healing and auto-scaling alerts for each vnfr
3001 for vnfr
in self
.db
.get_list("vnfrs", {"nsr-id-ref": nsr_id
}):
3003 (sub
for sub
in db_vnfds
if sub
["_id"] == vnfr
["vnfd-id"]), None
3005 healing_alerts
= self
._gather
_vnfr
_healing
_alerts
(vnfr
, vnfd
)
3006 for alert
in healing_alerts
:
3007 self
.logger
.info(f
"Storing healing alert in MongoDB: {alert}")
3008 self
.db
.create("alerts", alert
)
3010 scaling_alerts
= self
._gather
_vnfr
_scaling
_alerts
(vnfr
, vnfd
)
3011 for alert
in scaling_alerts
:
3012 self
.logger
.info(f
"Storing scaling alert in MongoDB: {alert}")
3013 self
.db
.create("alerts", alert
)
3015 alarm_alerts
= self
._gather
_vnfr
_alarm
_alerts
(vnfr
, vnfd
)
3016 for alert
in alarm_alerts
:
3017 self
.logger
.info(f
"Storing VNF alarm alert in MongoDB: {alert}")
3018 self
.db
.create("alerts", alert
)
3020 self
._write
_ns
_status
(
3023 current_operation
="IDLE",
3024 current_operation_id
=None,
3025 error_description
=error_description_nsr
,
3026 error_detail
=error_detail
,
3027 other_update
=db_nsr_update
,
3029 self
._write
_op
_status
(
3032 error_message
=error_description_nslcmop
,
3033 operation_state
=nslcmop_operation_state
,
3034 other_update
=db_nslcmop_update
,
3037 if nslcmop_operation_state
:
3039 await self
.msg
.aiowrite(
3044 "nslcmop_id": nslcmop_id
,
3045 "operationState": nslcmop_operation_state
,
3046 "startTime": db_nslcmop
["startTime"],
3047 "links": db_nslcmop
["links"],
3048 "operationParams": {
3049 "nsInstanceId": nsr_id
,
3050 "nsdId": db_nsr
["nsd-id"],
3054 except Exception as e
:
3056 logging_text
+ "kafka_write notification Exception {}".format(e
)
3059 self
.logger
.debug(logging_text
+ "Exit")
3060 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_instantiate")
3062 def _get_vnfd(self
, vnfd_id
: str, projects_read
: str, cached_vnfds
: Dict
[str, Any
]):
3063 if vnfd_id
not in cached_vnfds
:
3064 cached_vnfds
[vnfd_id
] = self
.db
.get_one(
3065 "vnfds", {"id": vnfd_id
, "_admin.projects_read": projects_read
}
3067 return cached_vnfds
[vnfd_id
]
3069 def _get_vnfr(self
, nsr_id
: str, vnf_profile_id
: str, cached_vnfrs
: Dict
[str, Any
]):
3070 if vnf_profile_id
not in cached_vnfrs
:
3071 cached_vnfrs
[vnf_profile_id
] = self
.db
.get_one(
3074 "member-vnf-index-ref": vnf_profile_id
,
3075 "nsr-id-ref": nsr_id
,
3078 return cached_vnfrs
[vnf_profile_id
]
3080 def _is_deployed_vca_in_relation(
3081 self
, vca
: DeployedVCA
, relation
: Relation
3084 for endpoint
in (relation
.provider
, relation
.requirer
):
3085 if endpoint
["kdu-resource-profile-id"]:
3088 vca
.vnf_profile_id
== endpoint
.vnf_profile_id
3089 and vca
.vdu_profile_id
== endpoint
.vdu_profile_id
3090 and vca
.execution_environment_ref
== endpoint
.execution_environment_ref
3096 def _update_ee_relation_data_with_implicit_data(
3097 self
, nsr_id
, nsd
, ee_relation_data
, cached_vnfds
, vnf_profile_id
: str = None
3099 ee_relation_data
= safe_get_ee_relation(
3100 nsr_id
, ee_relation_data
, vnf_profile_id
=vnf_profile_id
3102 ee_relation_level
= EELevel
.get_level(ee_relation_data
)
3103 if (ee_relation_level
in (EELevel
.VNF
, EELevel
.VDU
)) and not ee_relation_data
[
3104 "execution-environment-ref"
3106 vnf_profile
= get_vnf_profile(nsd
, ee_relation_data
["vnf-profile-id"])
3107 vnfd_id
= vnf_profile
["vnfd-id"]
3108 project
= nsd
["_admin"]["projects_read"][0]
3109 db_vnfd
= self
._get
_vnfd
(vnfd_id
, project
, cached_vnfds
)
3112 if ee_relation_level
== EELevel
.VNF
3113 else ee_relation_data
["vdu-profile-id"]
3115 ee
= get_juju_ee_ref(db_vnfd
, entity_id
)
3118 f
"not execution environments found for ee_relation {ee_relation_data}"
3120 ee_relation_data
["execution-environment-ref"] = ee
["id"]
3121 return ee_relation_data
3123 def _get_ns_relations(
3126 nsd
: Dict
[str, Any
],
3128 cached_vnfds
: Dict
[str, Any
],
3129 ) -> List
[Relation
]:
3131 db_ns_relations
= get_ns_configuration_relation_list(nsd
)
3132 for r
in db_ns_relations
:
3133 provider_dict
= None
3134 requirer_dict
= None
3135 if all(key
in r
for key
in ("provider", "requirer")):
3136 provider_dict
= r
["provider"]
3137 requirer_dict
= r
["requirer"]
3138 elif "entities" in r
:
3139 provider_id
= r
["entities"][0]["id"]
3142 "endpoint": r
["entities"][0]["endpoint"],
3144 if provider_id
!= nsd
["id"]:
3145 provider_dict
["vnf-profile-id"] = provider_id
3146 requirer_id
= r
["entities"][1]["id"]
3149 "endpoint": r
["entities"][1]["endpoint"],
3151 if requirer_id
!= nsd
["id"]:
3152 requirer_dict
["vnf-profile-id"] = requirer_id
3155 "provider/requirer or entities must be included in the relation."
3157 relation_provider
= self
._update
_ee
_relation
_data
_with
_implicit
_data
(
3158 nsr_id
, nsd
, provider_dict
, cached_vnfds
3160 relation_requirer
= self
._update
_ee
_relation
_data
_with
_implicit
_data
(
3161 nsr_id
, nsd
, requirer_dict
, cached_vnfds
3163 provider
= EERelation(relation_provider
)
3164 requirer
= EERelation(relation_requirer
)
3165 relation
= Relation(r
["name"], provider
, requirer
)
3166 vca_in_relation
= self
._is
_deployed
_vca
_in
_relation
(vca
, relation
)
3168 relations
.append(relation
)
3171 def _get_vnf_relations(
3174 nsd
: Dict
[str, Any
],
3176 cached_vnfds
: Dict
[str, Any
],
3177 ) -> List
[Relation
]:
3179 if vca
.target_element
== "ns":
3180 self
.logger
.debug("VCA is a NS charm, not a VNF.")
3182 vnf_profile
= get_vnf_profile(nsd
, vca
.vnf_profile_id
)
3183 vnf_profile_id
= vnf_profile
["id"]
3184 vnfd_id
= vnf_profile
["vnfd-id"]
3185 project
= nsd
["_admin"]["projects_read"][0]
3186 db_vnfd
= self
._get
_vnfd
(vnfd_id
, project
, cached_vnfds
)
3187 db_vnf_relations
= get_relation_list(db_vnfd
, vnfd_id
)
3188 for r
in db_vnf_relations
:
3189 provider_dict
= None
3190 requirer_dict
= None
3191 if all(key
in r
for key
in ("provider", "requirer")):
3192 provider_dict
= r
["provider"]
3193 requirer_dict
= r
["requirer"]
3194 elif "entities" in r
:
3195 provider_id
= r
["entities"][0]["id"]
3198 "vnf-profile-id": vnf_profile_id
,
3199 "endpoint": r
["entities"][0]["endpoint"],
3201 if provider_id
!= vnfd_id
:
3202 provider_dict
["vdu-profile-id"] = provider_id
3203 requirer_id
= r
["entities"][1]["id"]
3206 "vnf-profile-id": vnf_profile_id
,
3207 "endpoint": r
["entities"][1]["endpoint"],
3209 if requirer_id
!= vnfd_id
:
3210 requirer_dict
["vdu-profile-id"] = requirer_id
3213 "provider/requirer or entities must be included in the relation."
3215 relation_provider
= self
._update
_ee
_relation
_data
_with
_implicit
_data
(
3216 nsr_id
, nsd
, provider_dict
, cached_vnfds
, vnf_profile_id
=vnf_profile_id
3218 relation_requirer
= self
._update
_ee
_relation
_data
_with
_implicit
_data
(
3219 nsr_id
, nsd
, requirer_dict
, cached_vnfds
, vnf_profile_id
=vnf_profile_id
3221 provider
= EERelation(relation_provider
)
3222 requirer
= EERelation(relation_requirer
)
3223 relation
= Relation(r
["name"], provider
, requirer
)
3224 vca_in_relation
= self
._is
_deployed
_vca
_in
_relation
(vca
, relation
)
3226 relations
.append(relation
)
3229 def _get_kdu_resource_data(
3231 ee_relation
: EERelation
,
3232 db_nsr
: Dict
[str, Any
],
3233 cached_vnfds
: Dict
[str, Any
],
3234 ) -> DeployedK8sResource
:
3235 nsd
= get_nsd(db_nsr
)
3236 vnf_profiles
= get_vnf_profiles(nsd
)
3237 vnfd_id
= find_in_list(
3239 lambda vnf_profile
: vnf_profile
["id"] == ee_relation
.vnf_profile_id
,
3241 project
= nsd
["_admin"]["projects_read"][0]
3242 db_vnfd
= self
._get
_vnfd
(vnfd_id
, project
, cached_vnfds
)
3243 kdu_resource_profile
= get_kdu_resource_profile(
3244 db_vnfd
, ee_relation
.kdu_resource_profile_id
3246 kdu_name
= kdu_resource_profile
["kdu-name"]
3247 deployed_kdu
, _
= get_deployed_kdu(
3248 db_nsr
.get("_admin", ()).get("deployed", ()),
3250 ee_relation
.vnf_profile_id
,
3252 deployed_kdu
.update({"resource-name": kdu_resource_profile
["resource-name"]})
3255 def _get_deployed_component(
3257 ee_relation
: EERelation
,
3258 db_nsr
: Dict
[str, Any
],
3259 cached_vnfds
: Dict
[str, Any
],
3260 ) -> DeployedComponent
:
3261 nsr_id
= db_nsr
["_id"]
3262 deployed_component
= None
3263 ee_level
= EELevel
.get_level(ee_relation
)
3264 if ee_level
== EELevel
.NS
:
3265 vca
= get_deployed_vca(db_nsr
, {"vdu_id": None, "member-vnf-index": None})
3267 deployed_component
= DeployedVCA(nsr_id
, vca
)
3268 elif ee_level
== EELevel
.VNF
:
3269 vca
= get_deployed_vca(
3273 "member-vnf-index": ee_relation
.vnf_profile_id
,
3274 "ee_descriptor_id": ee_relation
.execution_environment_ref
,
3278 deployed_component
= DeployedVCA(nsr_id
, vca
)
3279 elif ee_level
== EELevel
.VDU
:
3280 vca
= get_deployed_vca(
3283 "vdu_id": ee_relation
.vdu_profile_id
,
3284 "member-vnf-index": ee_relation
.vnf_profile_id
,
3285 "ee_descriptor_id": ee_relation
.execution_environment_ref
,
3289 deployed_component
= DeployedVCA(nsr_id
, vca
)
3290 elif ee_level
== EELevel
.KDU
:
3291 kdu_resource_data
= self
._get
_kdu
_resource
_data
(
3292 ee_relation
, db_nsr
, cached_vnfds
3294 if kdu_resource_data
:
3295 deployed_component
= DeployedK8sResource(kdu_resource_data
)
3296 return deployed_component
3298 async def _add_relation(
3302 db_nsr
: Dict
[str, Any
],
3303 cached_vnfds
: Dict
[str, Any
],
3304 cached_vnfrs
: Dict
[str, Any
],
3306 deployed_provider
= self
._get
_deployed
_component
(
3307 relation
.provider
, db_nsr
, cached_vnfds
3309 deployed_requirer
= self
._get
_deployed
_component
(
3310 relation
.requirer
, db_nsr
, cached_vnfds
3314 and deployed_requirer
3315 and deployed_provider
.config_sw_installed
3316 and deployed_requirer
.config_sw_installed
3318 provider_db_vnfr
= (
3320 relation
.provider
.nsr_id
,
3321 relation
.provider
.vnf_profile_id
,
3324 if relation
.provider
.vnf_profile_id
3327 requirer_db_vnfr
= (
3329 relation
.requirer
.nsr_id
,
3330 relation
.requirer
.vnf_profile_id
,
3333 if relation
.requirer
.vnf_profile_id
3336 provider_vca_id
= self
.get_vca_id(provider_db_vnfr
, db_nsr
)
3337 requirer_vca_id
= self
.get_vca_id(requirer_db_vnfr
, db_nsr
)
3338 provider_relation_endpoint
= RelationEndpoint(
3339 deployed_provider
.ee_id
,
3341 relation
.provider
.endpoint
,
3343 requirer_relation_endpoint
= RelationEndpoint(
3344 deployed_requirer
.ee_id
,
3346 relation
.requirer
.endpoint
,
3349 await self
.vca_map
[vca_type
].add_relation(
3350 provider
=provider_relation_endpoint
,
3351 requirer
=requirer_relation_endpoint
,
3353 except N2VCException
as exception
:
3354 self
.logger
.error(exception
)
3355 raise LcmException(exception
)
3359 async def _add_vca_relations(
3365 timeout
: int = 3600,
3368 # 1. find all relations for this VCA
3369 # 2. wait for other peers related
3373 # STEP 1: find all relations for this VCA
3376 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
3377 nsd
= get_nsd(db_nsr
)
3380 deployed_vca_dict
= get_deployed_vca_list(db_nsr
)[vca_index
]
3381 my_vca
= DeployedVCA(nsr_id
, deployed_vca_dict
)
3386 relations
.extend(self
._get
_ns
_relations
(nsr_id
, nsd
, my_vca
, cached_vnfds
))
3387 relations
.extend(self
._get
_vnf
_relations
(nsr_id
, nsd
, my_vca
, cached_vnfds
))
3389 # if no relations, terminate
3391 self
.logger
.debug(logging_text
+ " No relations")
3394 self
.logger
.debug(logging_text
+ " adding relations {}".format(relations
))
3401 if now
- start
>= timeout
:
3402 self
.logger
.error(logging_text
+ " : timeout adding relations")
3405 # reload nsr from database (we need to update record: _admin.deployed.VCA)
3406 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
3408 # for each relation, find the VCA's related
3409 for relation
in relations
.copy():
3410 added
= await self
._add
_relation
(
3418 relations
.remove(relation
)
3421 self
.logger
.debug("Relations added")
3423 await asyncio
.sleep(5.0)
3427 except Exception as e
:
3428 self
.logger
.warn(logging_text
+ " ERROR adding relations: {}".format(e
))
3431 async def _install_kdu(
3439 k8s_instance_info
: dict,
3440 k8params
: dict = None,
3445 k8sclustertype
= k8s_instance_info
["k8scluster-type"]
3448 "collection": "nsrs",
3449 "filter": {"_id": nsr_id
},
3450 "path": nsr_db_path
,
3453 if k8s_instance_info
.get("kdu-deployment-name"):
3454 kdu_instance
= k8s_instance_info
.get("kdu-deployment-name")
3456 kdu_instance
= self
.k8scluster_map
[
3458 ].generate_kdu_instance_name(
3459 db_dict
=db_dict_install
,
3460 kdu_model
=k8s_instance_info
["kdu-model"],
3461 kdu_name
=k8s_instance_info
["kdu-name"],
3464 # Update the nsrs table with the kdu-instance value
3468 _desc
={nsr_db_path
+ ".kdu-instance": kdu_instance
},
3471 # Update the nsrs table with the actual namespace being used, if the k8scluster-type is `juju` or
3472 # `juju-bundle`. This verification is needed because there is not a standard/homogeneous namespace
3473 # between the Helm Charts and Juju Bundles-based KNFs. If we found a way of having an homogeneous
3474 # namespace, this first verification could be removed, and the next step would be done for any kind
3476 # TODO -> find a way to have an homogeneous namespace between the Helm Charts and Juju Bundles-based
3477 # KNFs (Bug 2027: https://osm.etsi.org/bugzilla/show_bug.cgi?id=2027)
3478 if k8sclustertype
in ("juju", "juju-bundle"):
3479 # First, verify if the current namespace is present in the `_admin.projects_read` (if not, it means
3480 # that the user passed a namespace which he wants its KDU to be deployed in)
3486 "_admin.projects_write": k8s_instance_info
["namespace"],
3487 "_admin.projects_read": k8s_instance_info
["namespace"],
3493 f
"Updating namespace/model for Juju Bundle from {k8s_instance_info['namespace']} to {kdu_instance}"
3498 _desc
={f
"{nsr_db_path}.namespace": kdu_instance
},
3500 k8s_instance_info
["namespace"] = kdu_instance
3502 await self
.k8scluster_map
[k8sclustertype
].install(
3503 cluster_uuid
=k8s_instance_info
["k8scluster-uuid"],
3504 kdu_model
=k8s_instance_info
["kdu-model"],
3507 db_dict
=db_dict_install
,
3509 kdu_name
=k8s_instance_info
["kdu-name"],
3510 namespace
=k8s_instance_info
["namespace"],
3511 kdu_instance
=kdu_instance
,
3515 # Obtain services to obtain management service ip
3516 services
= await self
.k8scluster_map
[k8sclustertype
].get_services(
3517 cluster_uuid
=k8s_instance_info
["k8scluster-uuid"],
3518 kdu_instance
=kdu_instance
,
3519 namespace
=k8s_instance_info
["namespace"],
3522 # Obtain management service info (if exists)
3523 vnfr_update_dict
= {}
3524 kdu_config
= get_configuration(vnfd
, kdud
["name"])
3526 target_ee_list
= kdu_config
.get("execution-environment-list", [])
3531 vnfr_update_dict
["kdur.{}.services".format(kdu_index
)] = services
3534 for service
in kdud
.get("service", [])
3535 if service
.get("mgmt-service")
3537 for mgmt_service
in mgmt_services
:
3538 for service
in services
:
3539 if service
["name"].startswith(mgmt_service
["name"]):
3540 # Mgmt service found, Obtain service ip
3541 ip
= service
.get("external_ip", service
.get("cluster_ip"))
3542 if isinstance(ip
, list) and len(ip
) == 1:
3546 "kdur.{}.ip-address".format(kdu_index
)
3549 # Check if must update also mgmt ip at the vnf
3550 service_external_cp
= mgmt_service
.get(
3551 "external-connection-point-ref"
3553 if service_external_cp
:
3555 deep_get(vnfd
, ("mgmt-interface", "cp"))
3556 == service_external_cp
3558 vnfr_update_dict
["ip-address"] = ip
3563 "external-connection-point-ref", ""
3565 == service_external_cp
,
3568 "kdur.{}.ip-address".format(kdu_index
)
3573 "Mgmt service name: {} not found".format(
3574 mgmt_service
["name"]
3578 vnfr_update_dict
["kdur.{}.status".format(kdu_index
)] = "READY"
3579 self
.update_db_2("vnfrs", vnfr_data
.get("_id"), vnfr_update_dict
)
3581 kdu_config
= get_configuration(vnfd
, k8s_instance_info
["kdu-name"])
3584 and kdu_config
.get("initial-config-primitive")
3585 and get_juju_ee_ref(vnfd
, k8s_instance_info
["kdu-name"]) is None
3587 initial_config_primitive_list
= kdu_config
.get(
3588 "initial-config-primitive"
3590 initial_config_primitive_list
.sort(key
=lambda val
: int(val
["seq"]))
3592 for initial_config_primitive
in initial_config_primitive_list
:
3593 primitive_params_
= self
._map
_primitive
_params
(
3594 initial_config_primitive
, {}, {}
3597 await asyncio
.wait_for(
3598 self
.k8scluster_map
[k8sclustertype
].exec_primitive(
3599 cluster_uuid
=k8s_instance_info
["k8scluster-uuid"],
3600 kdu_instance
=kdu_instance
,
3601 primitive_name
=initial_config_primitive
["name"],
3602 params
=primitive_params_
,
3603 db_dict
=db_dict_install
,
3609 except Exception as e
:
3610 # Prepare update db with error and raise exception
3613 "nsrs", nsr_id
, {nsr_db_path
+ ".detailed-status": str(e
)}
3617 vnfr_data
.get("_id"),
3618 {"kdur.{}.status".format(kdu_index
): "ERROR"},
3620 except Exception as error
:
3621 # ignore to keep original exception
3622 self
.logger
.warning(
3623 f
"An exception occurred while updating DB: {str(error)}"
3625 # reraise original error
3630 async def deploy_kdus(
3637 task_instantiation_info
,
3639 # Launch kdus if present in the descriptor
3641 k8scluster_id_2_uuic
= {
3642 "helm-chart-v3": {},
3646 async def _get_cluster_id(cluster_id
, cluster_type
):
3647 nonlocal k8scluster_id_2_uuic
3648 if cluster_id
in k8scluster_id_2_uuic
[cluster_type
]:
3649 return k8scluster_id_2_uuic
[cluster_type
][cluster_id
]
3651 # check if K8scluster is creating and wait look if previous tasks in process
3652 task_name
, task_dependency
= self
.lcm_tasks
.lookfor_related(
3653 "k8scluster", cluster_id
3656 text
= "Waiting for related tasks '{}' on k8scluster {} to be completed".format(
3657 task_name
, cluster_id
3659 self
.logger
.debug(logging_text
+ text
)
3660 await asyncio
.wait(task_dependency
, timeout
=3600)
3662 db_k8scluster
= self
.db
.get_one(
3663 "k8sclusters", {"_id": cluster_id
}, fail_on_empty
=False
3665 if not db_k8scluster
:
3666 raise LcmException("K8s cluster {} cannot be found".format(cluster_id
))
3668 k8s_id
= deep_get(db_k8scluster
, ("_admin", cluster_type
, "id"))
3670 if cluster_type
== "helm-chart-v3":
3672 # backward compatibility for existing clusters that have not been initialized for helm v3
3673 k8s_credentials
= yaml
.safe_dump(
3674 db_k8scluster
.get("credentials")
3676 k8s_id
, uninstall_sw
= await self
.k8sclusterhelm3
.init_env(
3677 k8s_credentials
, reuse_cluster_uuid
=cluster_id
3679 db_k8scluster_update
= {}
3680 db_k8scluster_update
["_admin.helm-chart-v3.error_msg"] = None
3681 db_k8scluster_update
["_admin.helm-chart-v3.id"] = k8s_id
3682 db_k8scluster_update
[
3683 "_admin.helm-chart-v3.created"
3685 db_k8scluster_update
[
3686 "_admin.helm-chart-v3.operationalState"
3689 "k8sclusters", cluster_id
, db_k8scluster_update
3691 except Exception as e
:
3694 + "error initializing helm-v3 cluster: {}".format(str(e
))
3697 "K8s cluster '{}' has not been initialized for '{}'".format(
3698 cluster_id
, cluster_type
3703 "K8s cluster '{}' has not been initialized for '{}'".format(
3704 cluster_id
, cluster_type
3707 k8scluster_id_2_uuic
[cluster_type
][cluster_id
] = k8s_id
3710 logging_text
+= "Deploy kdus: "
3713 db_nsr_update
= {"_admin.deployed.K8s": []}
3714 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
3717 updated_cluster_list
= []
3718 updated_v3_cluster_list
= []
3720 for vnfr_data
in db_vnfrs
.values():
3721 vca_id
= self
.get_vca_id(vnfr_data
, {})
3722 for kdu_index
, kdur
in enumerate(get_iterable(vnfr_data
, "kdur")):
3723 # Step 0: Prepare and set parameters
3724 desc_params
= parse_yaml_strings(kdur
.get("additionalParams"))
3725 vnfd_id
= vnfr_data
.get("vnfd-id")
3726 vnfd_with_id
= find_in_list(
3727 db_vnfds
, lambda vnfd
: vnfd
["_id"] == vnfd_id
3731 for kdud
in vnfd_with_id
["kdu"]
3732 if kdud
["name"] == kdur
["kdu-name"]
3734 namespace
= kdur
.get("k8s-namespace")
3735 kdu_deployment_name
= kdur
.get("kdu-deployment-name")
3736 if kdur
.get("helm-chart"):
3737 kdumodel
= kdur
["helm-chart"]
3738 # Default version: helm3, if helm-version is v2 assign v2
3739 k8sclustertype
= "helm-chart-v3"
3740 self
.logger
.debug("kdur: {}".format(kdur
))
3741 elif kdur
.get("juju-bundle"):
3742 kdumodel
= kdur
["juju-bundle"]
3743 k8sclustertype
= "juju-bundle"
3746 "kdu type for kdu='{}.{}' is neither helm-chart nor "
3747 "juju-bundle. Maybe an old NBI version is running".format(
3748 vnfr_data
["member-vnf-index-ref"], kdur
["kdu-name"]
3751 # check if kdumodel is a file and exists
3753 vnfd_with_id
= find_in_list(
3754 db_vnfds
, lambda vnfd
: vnfd
["_id"] == vnfd_id
3756 storage
= deep_get(vnfd_with_id
, ("_admin", "storage"))
3757 if storage
: # may be not present if vnfd has not artifacts
3758 # path format: /vnfdid/pkkdir/helm-charts|juju-bundles/kdumodel
3759 if storage
["pkg-dir"]:
3760 filename
= "{}/{}/{}s/{}".format(
3767 filename
= "{}/Scripts/{}s/{}".format(
3772 if self
.fs
.file_exists(
3773 filename
, mode
="file"
3774 ) or self
.fs
.file_exists(filename
, mode
="dir"):
3775 kdumodel
= self
.fs
.path
+ filename
3776 except (asyncio
.TimeoutError
, asyncio
.CancelledError
):
3778 except Exception as e
: # it is not a file
3779 self
.logger
.warning(f
"An exception occurred: {str(e)}")
3781 k8s_cluster_id
= kdur
["k8s-cluster"]["id"]
3782 step
= "Synchronize repos for k8s cluster '{}'".format(
3785 cluster_uuid
= await _get_cluster_id(k8s_cluster_id
, k8sclustertype
)
3789 k8sclustertype
== "helm-chart"
3790 and cluster_uuid
not in updated_cluster_list
3792 k8sclustertype
== "helm-chart-v3"
3793 and cluster_uuid
not in updated_v3_cluster_list
3795 del_repo_list
, added_repo_dict
= await asyncio
.ensure_future(
3796 self
.k8scluster_map
[k8sclustertype
].synchronize_repos(
3797 cluster_uuid
=cluster_uuid
3800 if del_repo_list
or added_repo_dict
:
3801 if k8sclustertype
== "helm-chart":
3803 "_admin.helm_charts_added." + item
: None
3804 for item
in del_repo_list
3807 "_admin.helm_charts_added." + item
: name
3808 for item
, name
in added_repo_dict
.items()
3810 updated_cluster_list
.append(cluster_uuid
)
3811 elif k8sclustertype
== "helm-chart-v3":
3813 "_admin.helm_charts_v3_added." + item
: None
3814 for item
in del_repo_list
3817 "_admin.helm_charts_v3_added." + item
: name
3818 for item
, name
in added_repo_dict
.items()
3820 updated_v3_cluster_list
.append(cluster_uuid
)
3822 logging_text
+ "repos synchronized on k8s cluster "
3823 "'{}' to_delete: {}, to_add: {}".format(
3824 k8s_cluster_id
, del_repo_list
, added_repo_dict
3829 {"_id": k8s_cluster_id
},
3835 step
= "Instantiating KDU {}.{} in k8s cluster {}".format(
3836 vnfr_data
["member-vnf-index-ref"],
3840 k8s_instance_info
= {
3841 "kdu-instance": None,
3842 "k8scluster-uuid": cluster_uuid
,
3843 "k8scluster-type": k8sclustertype
,
3844 "member-vnf-index": vnfr_data
["member-vnf-index-ref"],
3845 "kdu-name": kdur
["kdu-name"],
3846 "kdu-model": kdumodel
,
3847 "namespace": namespace
,
3848 "kdu-deployment-name": kdu_deployment_name
,
3850 db_path
= "_admin.deployed.K8s.{}".format(index
)
3851 db_nsr_update
[db_path
] = k8s_instance_info
3852 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
3853 vnfd_with_id
= find_in_list(
3854 db_vnfds
, lambda vnf
: vnf
["_id"] == vnfd_id
3856 task
= asyncio
.ensure_future(
3865 k8params
=desc_params
,
3870 self
.lcm_tasks
.register(
3874 "instantiate_KDU-{}".format(index
),
3877 task_instantiation_info
[task
] = "Deploying KDU {}".format(
3883 except (LcmException
, asyncio
.CancelledError
):
3885 except Exception as e
:
3886 msg
= "Exception {} while {}: {}".format(type(e
).__name
__, step
, e
)
3887 if isinstance(e
, (N2VCException
, DbException
)):
3888 self
.logger
.error(logging_text
+ msg
)
3890 self
.logger
.critical(logging_text
+ msg
, exc_info
=True)
3891 raise LcmException(msg
)
3894 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
3914 task_instantiation_info
,
3917 # launch instantiate_N2VC in a asyncio task and register task object
3918 # Look where information of this charm is at database <nsrs>._admin.deployed.VCA
3919 # if not found, create one entry and update database
3920 # fill db_nsr._admin.deployed.VCA.<index>
3923 logging_text
+ "_deploy_n2vc vnfd_id={}, vdu_id={}".format(vnfd_id
, vdu_id
)
3927 get_charm_name
= False
3928 if "execution-environment-list" in descriptor_config
:
3929 ee_list
= descriptor_config
.get("execution-environment-list", [])
3930 elif "juju" in descriptor_config
:
3931 ee_list
= [descriptor_config
] # ns charms
3932 if "execution-environment-list" not in descriptor_config
:
3933 # charm name is only required for ns charms
3934 get_charm_name
= True
3935 else: # other types as script are not supported
3938 for ee_item
in ee_list
:
3941 + "_deploy_n2vc ee_item juju={}, helm={}".format(
3942 ee_item
.get("juju"), ee_item
.get("helm-chart")
3945 ee_descriptor_id
= ee_item
.get("id")
3946 if ee_item
.get("juju"):
3947 vca_name
= ee_item
["juju"].get("charm")
3949 charm_name
= self
.find_charm_name(db_nsr
, str(vca_name
))
3952 if ee_item
["juju"].get("charm") is not None
3955 if ee_item
["juju"].get("cloud") == "k8s":
3956 vca_type
= "k8s_proxy_charm"
3957 elif ee_item
["juju"].get("proxy") is False:
3958 vca_type
= "native_charm"
3959 elif ee_item
.get("helm-chart"):
3960 vca_name
= ee_item
["helm-chart"]
3961 vca_type
= "helm-v3"
3964 logging_text
+ "skipping non juju neither charm configuration"
3969 for vca_index
, vca_deployed
in enumerate(
3970 db_nsr
["_admin"]["deployed"]["VCA"]
3972 if not vca_deployed
:
3975 vca_deployed
.get("member-vnf-index") == member_vnf_index
3976 and vca_deployed
.get("vdu_id") == vdu_id
3977 and vca_deployed
.get("kdu_name") == kdu_name
3978 and vca_deployed
.get("vdu_count_index", 0) == vdu_index
3979 and vca_deployed
.get("ee_descriptor_id") == ee_descriptor_id
3983 # not found, create one.
3985 "ns" if not member_vnf_index
else "vnf/{}".format(member_vnf_index
)
3988 target
+= "/vdu/{}/{}".format(vdu_id
, vdu_index
or 0)
3990 target
+= "/kdu/{}".format(kdu_name
)
3992 "target_element": target
,
3993 # ^ target_element will replace member-vnf-index, kdu_name, vdu_id ... in a single string
3994 "member-vnf-index": member_vnf_index
,
3996 "kdu_name": kdu_name
,
3997 "vdu_count_index": vdu_index
,
3998 "operational-status": "init", # TODO revise
3999 "detailed-status": "", # TODO revise
4000 "step": "initial-deploy", # TODO revise
4002 "vdu_name": vdu_name
,
4004 "ee_descriptor_id": ee_descriptor_id
,
4005 "charm_name": charm_name
,
4009 # create VCA and configurationStatus in db
4011 "_admin.deployed.VCA.{}".format(vca_index
): vca_deployed
,
4012 "configurationStatus.{}".format(vca_index
): dict(),
4014 self
.update_db_2("nsrs", nsr_id
, db_dict
)
4016 db_nsr
["_admin"]["deployed"]["VCA"].append(vca_deployed
)
4018 self
.logger
.debug("N2VC > NSR_ID > {}".format(nsr_id
))
4019 self
.logger
.debug("N2VC > DB_NSR > {}".format(db_nsr
))
4020 self
.logger
.debug("N2VC > VCA_DEPLOYED > {}".format(vca_deployed
))
4023 task_n2vc
= asyncio
.ensure_future(
4024 self
.instantiate_N2VC(
4025 logging_text
=logging_text
,
4026 vca_index
=vca_index
,
4032 vdu_index
=vdu_index
,
4033 kdu_index
=kdu_index
,
4034 deploy_params
=deploy_params
,
4035 config_descriptor
=descriptor_config
,
4036 base_folder
=base_folder
,
4037 nslcmop_id
=nslcmop_id
,
4041 ee_config_descriptor
=ee_item
,
4044 self
.lcm_tasks
.register(
4048 "instantiate_N2VC-{}".format(vca_index
),
4051 task_instantiation_info
[
4053 ] = self
.task_name_deploy_vca
+ " {}.{}".format(
4054 member_vnf_index
or "", vdu_id
or ""
4057 def _format_additional_params(self
, params
):
4058 params
= params
or {}
4059 for key
, value
in params
.items():
4060 if str(value
).startswith("!!yaml "):
4061 params
[key
] = yaml
.safe_load(value
[7:])
4064 def _get_terminate_primitive_params(self
, seq
, vnf_index
):
4065 primitive
= seq
.get("name")
4066 primitive_params
= {}
4068 "member_vnf_index": vnf_index
,
4069 "primitive": primitive
,
4070 "primitive_params": primitive_params
,
4073 return self
._map
_primitive
_params
(seq
, params
, desc_params
)
4077 def _retry_or_skip_suboperation(self
, db_nslcmop
, op_index
):
4078 op
= deep_get(db_nslcmop
, ("_admin", "operations"), [])[op_index
]
4079 if op
.get("operationState") == "COMPLETED":
4080 # b. Skip sub-operation
4081 # _ns_execute_primitive() or RO.create_action() will NOT be executed
4082 return self
.SUBOPERATION_STATUS_SKIP
4084 # c. retry executing sub-operation
4085 # The sub-operation exists, and operationState != 'COMPLETED'
4086 # Update operationState = 'PROCESSING' to indicate a retry.
4087 operationState
= "PROCESSING"
4088 detailed_status
= "In progress"
4089 self
._update
_suboperation
_status
(
4090 db_nslcmop
, op_index
, operationState
, detailed_status
4092 # Return the sub-operation index
4093 # _ns_execute_primitive() or RO.create_action() will be called from scale()
4094 # with arguments extracted from the sub-operation
4097 # Find a sub-operation where all keys in a matching dictionary must match
4098 # Returns the index of the matching sub-operation, or SUBOPERATION_STATUS_NOT_FOUND if no match
4099 def _find_suboperation(self
, db_nslcmop
, match
):
4100 if db_nslcmop
and match
:
4101 op_list
= db_nslcmop
.get("_admin", {}).get("operations", [])
4102 for i
, op
in enumerate(op_list
):
4103 if all(op
.get(k
) == match
[k
] for k
in match
):
4105 return self
.SUBOPERATION_STATUS_NOT_FOUND
4107 # Update status for a sub-operation given its index
4108 def _update_suboperation_status(
4109 self
, db_nslcmop
, op_index
, operationState
, detailed_status
4111 # Update DB for HA tasks
4112 q_filter
= {"_id": db_nslcmop
["_id"]}
4114 "_admin.operations.{}.operationState".format(op_index
): operationState
,
4115 "_admin.operations.{}.detailed-status".format(op_index
): detailed_status
,
4118 "nslcmops", q_filter
=q_filter
, update_dict
=update_dict
, fail_on_empty
=False
4121 # Add sub-operation, return the index of the added sub-operation
4122 # Optionally, set operationState, detailed-status, and operationType
4123 # Status and type are currently set for 'scale' sub-operations:
4124 # 'operationState' : 'PROCESSING' | 'COMPLETED' | 'FAILED'
4125 # 'detailed-status' : status message
4126 # 'operationType': may be any type, in the case of scaling: 'PRE-SCALE' | 'POST-SCALE'
4127 # Status and operation type are currently only used for 'scale', but NOT for 'terminate' sub-operations.
4128 def _add_suboperation(
4136 mapped_primitive_params
,
4137 operationState
=None,
4138 detailed_status
=None,
4141 RO_scaling_info
=None,
4144 return self
.SUBOPERATION_STATUS_NOT_FOUND
4145 # Get the "_admin.operations" list, if it exists
4146 db_nslcmop_admin
= db_nslcmop
.get("_admin", {})
4147 op_list
= db_nslcmop_admin
.get("operations")
4148 # Create or append to the "_admin.operations" list
4150 "member_vnf_index": vnf_index
,
4152 "vdu_count_index": vdu_count_index
,
4153 "primitive": primitive
,
4154 "primitive_params": mapped_primitive_params
,
4157 new_op
["operationState"] = operationState
4159 new_op
["detailed-status"] = detailed_status
4161 new_op
["lcmOperationType"] = operationType
4163 new_op
["RO_nsr_id"] = RO_nsr_id
4165 new_op
["RO_scaling_info"] = RO_scaling_info
4167 # No existing operations, create key 'operations' with current operation as first list element
4168 db_nslcmop_admin
.update({"operations": [new_op
]})
4169 op_list
= db_nslcmop_admin
.get("operations")
4171 # Existing operations, append operation to list
4172 op_list
.append(new_op
)
4174 db_nslcmop_update
= {"_admin.operations": op_list
}
4175 self
.update_db_2("nslcmops", db_nslcmop
["_id"], db_nslcmop_update
)
4176 op_index
= len(op_list
) - 1
4179 # Helper methods for scale() sub-operations
4181 # pre-scale/post-scale:
4182 # Check for 3 different cases:
4183 # a. New: First time execution, return SUBOPERATION_STATUS_NEW
4184 # b. Skip: Existing sub-operation exists, operationState == 'COMPLETED', return SUBOPERATION_STATUS_SKIP
4185 # c. retry: Existing sub-operation exists, operationState != 'COMPLETED', return op_index to re-execute
4186 def _check_or_add_scale_suboperation(
4190 vnf_config_primitive
,
4194 RO_scaling_info
=None,
4196 # Find this sub-operation
4197 if RO_nsr_id
and RO_scaling_info
:
4198 operationType
= "SCALE-RO"
4200 "member_vnf_index": vnf_index
,
4201 "RO_nsr_id": RO_nsr_id
,
4202 "RO_scaling_info": RO_scaling_info
,
4206 "member_vnf_index": vnf_index
,
4207 "primitive": vnf_config_primitive
,
4208 "primitive_params": primitive_params
,
4209 "lcmOperationType": operationType
,
4211 op_index
= self
._find
_suboperation
(db_nslcmop
, match
)
4212 if op_index
== self
.SUBOPERATION_STATUS_NOT_FOUND
:
4213 # a. New sub-operation
4214 # The sub-operation does not exist, add it.
4215 # _ns_execute_primitive() will be called from scale() as usual, with non-modified arguments
4216 # The following parameters are set to None for all kind of scaling:
4218 vdu_count_index
= None
4220 if RO_nsr_id
and RO_scaling_info
:
4221 vnf_config_primitive
= None
4222 primitive_params
= None
4225 RO_scaling_info
= None
4226 # Initial status for sub-operation
4227 operationState
= "PROCESSING"
4228 detailed_status
= "In progress"
4229 # Add sub-operation for pre/post-scaling (zero or more operations)
4230 self
._add
_suboperation
(
4236 vnf_config_primitive
,
4244 return self
.SUBOPERATION_STATUS_NEW
4246 # Return either SUBOPERATION_STATUS_SKIP (operationState == 'COMPLETED'),
4247 # or op_index (operationState != 'COMPLETED')
4248 return self
._retry
_or
_skip
_suboperation
(db_nslcmop
, op_index
)
4250 # Function to return execution_environment id
4252 async def destroy_N2VC(
4260 exec_primitives
=True,
4265 Execute the terminate primitives and destroy the execution environment (if destroy_ee=False
4266 :param logging_text:
4268 :param vca_deployed: Dictionary of deployment info at db_nsr._admin.depoloyed.VCA.<INDEX>
4269 :param config_descriptor: Configuration descriptor of the NSD, VNFD, VNFD.vdu or VNFD.kdu
4270 :param vca_index: index in the database _admin.deployed.VCA
4271 :param destroy_ee: False to do not destroy, because it will be destroyed all of then at once
4272 :param exec_primitives: False to do not execute terminate primitives, because the config is not completed or has
4273 not executed properly
4274 :param scaling_in: True destroys the application, False destroys the model
4275 :return: None or exception
4280 + " vca_index: {}, vca_deployed: {}, config_descriptor: {}, destroy_ee: {}".format(
4281 vca_index
, vca_deployed
, config_descriptor
, destroy_ee
4285 vca_type
= vca_deployed
.get("type", "lxc_proxy_charm")
4287 # execute terminate_primitives
4289 terminate_primitives
= get_ee_sorted_terminate_config_primitive_list(
4290 config_descriptor
.get("terminate-config-primitive"),
4291 vca_deployed
.get("ee_descriptor_id"),
4293 vdu_id
= vca_deployed
.get("vdu_id")
4294 vdu_count_index
= vca_deployed
.get("vdu_count_index")
4295 vdu_name
= vca_deployed
.get("vdu_name")
4296 vnf_index
= vca_deployed
.get("member-vnf-index")
4297 if terminate_primitives
and vca_deployed
.get("needed_terminate"):
4298 for seq
in terminate_primitives
:
4299 # For each sequence in list, get primitive and call _ns_execute_primitive()
4300 step
= "Calling terminate action for vnf_member_index={} primitive={}".format(
4301 vnf_index
, seq
.get("name")
4303 self
.logger
.debug(logging_text
+ step
)
4304 # Create the primitive for each sequence, i.e. "primitive": "touch"
4305 primitive
= seq
.get("name")
4306 mapped_primitive_params
= self
._get
_terminate
_primitive
_params
(
4311 self
._add
_suboperation
(
4318 mapped_primitive_params
,
4320 # Sub-operations: Call _ns_execute_primitive() instead of action()
4322 result
, result_detail
= await self
._ns
_execute
_primitive
(
4323 vca_deployed
["ee_id"],
4325 mapped_primitive_params
,
4329 except LcmException
:
4330 # this happens when VCA is not deployed. In this case it is not needed to terminate
4332 result_ok
= ["COMPLETED", "PARTIALLY_COMPLETED"]
4333 if result
not in result_ok
:
4335 "terminate_primitive {} for vnf_member_index={} fails with "
4336 "error {}".format(seq
.get("name"), vnf_index
, result_detail
)
4338 # set that this VCA do not need terminated
4339 db_update_entry
= "_admin.deployed.VCA.{}.needed_terminate".format(
4343 "nsrs", db_nslcmop
["nsInstanceId"], {db_update_entry
: False}
4346 # Delete Prometheus Jobs if any
4347 # This uses NSR_ID, so it will destroy any jobs under this index
4348 self
.db
.del_list("prometheus_jobs", {"nsr_id": db_nslcmop
["nsInstanceId"]})
4351 await self
.vca_map
[vca_type
].delete_execution_environment(
4352 vca_deployed
["ee_id"],
4353 scaling_in
=scaling_in
,
4358 async def _delete_all_N2VC(self
, db_nsr
: dict, vca_id
: str = None):
4359 self
._write
_all
_config
_status
(db_nsr
=db_nsr
, status
="TERMINATING")
4360 namespace
= "." + db_nsr
["_id"]
4362 await self
.n2vc
.delete_namespace(
4363 namespace
=namespace
,
4364 total_timeout
=self
.timeout
.charm_delete
,
4367 except N2VCNotFound
: # already deleted. Skip
4369 self
._write
_all
_config
_status
(db_nsr
=db_nsr
, status
="DELETED")
4371 async def terminate(self
, nsr_id
, nslcmop_id
):
4372 # Try to lock HA task here
4373 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
4374 if not task_is_locked_by_me
:
4377 logging_text
= "Task ns={} terminate={} ".format(nsr_id
, nslcmop_id
)
4378 self
.logger
.debug(logging_text
+ "Enter")
4379 timeout_ns_terminate
= self
.timeout
.ns_terminate
4382 operation_params
= None
4384 error_list
= [] # annotates all failed error messages
4385 db_nslcmop_update
= {}
4386 autoremove
= False # autoremove after terminated
4387 tasks_dict_info
= {}
4390 "Stage 1/3: Preparing task.",
4391 "Waiting for previous operations to terminate.",
4394 # ^ contains [stage, step, VIM-status]
4396 # wait for any previous tasks in process
4397 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
4399 stage
[1] = "Getting nslcmop={} from db.".format(nslcmop_id
)
4400 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
4401 operation_params
= db_nslcmop
.get("operationParams") or {}
4402 if operation_params
.get("timeout_ns_terminate"):
4403 timeout_ns_terminate
= operation_params
["timeout_ns_terminate"]
4404 stage
[1] = "Getting nsr={} from db.".format(nsr_id
)
4405 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
4407 db_nsr_update
["operational-status"] = "terminating"
4408 db_nsr_update
["config-status"] = "terminating"
4409 self
._write
_ns
_status
(
4411 ns_state
="TERMINATING",
4412 current_operation
="TERMINATING",
4413 current_operation_id
=nslcmop_id
,
4414 other_update
=db_nsr_update
,
4416 self
._write
_op
_status
(op_id
=nslcmop_id
, queuePosition
=0, stage
=stage
)
4417 nsr_deployed
= deepcopy(db_nsr
["_admin"].get("deployed")) or {}
4418 if db_nsr
["_admin"]["nsState"] == "NOT_INSTANTIATED":
4421 stage
[1] = "Getting vnf descriptors from db."
4422 db_vnfrs_list
= self
.db
.get_list("vnfrs", {"nsr-id-ref": nsr_id
})
4424 db_vnfr
["member-vnf-index-ref"]: db_vnfr
for db_vnfr
in db_vnfrs_list
4426 db_vnfds_from_id
= {}
4427 db_vnfds_from_member_index
= {}
4429 for vnfr
in db_vnfrs_list
:
4430 vnfd_id
= vnfr
["vnfd-id"]
4431 if vnfd_id
not in db_vnfds_from_id
:
4432 vnfd
= self
.db
.get_one("vnfds", {"_id": vnfd_id
})
4433 db_vnfds_from_id
[vnfd_id
] = vnfd
4434 db_vnfds_from_member_index
[
4435 vnfr
["member-vnf-index-ref"]
4436 ] = db_vnfds_from_id
[vnfd_id
]
4438 # Destroy individual execution environments when there are terminating primitives.
4439 # Rest of EE will be deleted at once
4440 # TODO - check before calling _destroy_N2VC
4441 # if not operation_params.get("skip_terminate_primitives"):#
4442 # or not vca.get("needed_terminate"):
4443 stage
[0] = "Stage 2/3 execute terminating primitives."
4444 self
.logger
.debug(logging_text
+ stage
[0])
4445 stage
[1] = "Looking execution environment that needs terminate."
4446 self
.logger
.debug(logging_text
+ stage
[1])
4448 for vca_index
, vca
in enumerate(get_iterable(nsr_deployed
, "VCA")):
4449 config_descriptor
= None
4450 vca_member_vnf_index
= vca
.get("member-vnf-index")
4451 vca_id
= self
.get_vca_id(
4452 db_vnfrs_dict
.get(vca_member_vnf_index
)
4453 if vca_member_vnf_index
4457 if not vca
or not vca
.get("ee_id"):
4459 if not vca
.get("member-vnf-index"):
4461 config_descriptor
= db_nsr
.get("ns-configuration")
4462 elif vca
.get("vdu_id"):
4463 db_vnfd
= db_vnfds_from_member_index
[vca
["member-vnf-index"]]
4464 config_descriptor
= get_configuration(db_vnfd
, vca
.get("vdu_id"))
4465 elif vca
.get("kdu_name"):
4466 db_vnfd
= db_vnfds_from_member_index
[vca
["member-vnf-index"]]
4467 config_descriptor
= get_configuration(db_vnfd
, vca
.get("kdu_name"))
4469 db_vnfd
= db_vnfds_from_member_index
[vca
["member-vnf-index"]]
4470 config_descriptor
= get_configuration(db_vnfd
, db_vnfd
["id"])
4471 vca_type
= vca
.get("type")
4472 exec_terminate_primitives
= not operation_params
.get(
4473 "skip_terminate_primitives"
4474 ) and vca
.get("needed_terminate")
4475 # For helm we must destroy_ee. Also for native_charm, as juju_model cannot be deleted if there are
4476 # pending native charms
4477 destroy_ee
= True if vca_type
in ("helm-v3", "native_charm") else False
4478 # self.logger.debug(logging_text + "vca_index: {}, ee_id: {}, vca_type: {} destroy_ee: {}".format(
4479 # vca_index, vca.get("ee_id"), vca_type, destroy_ee))
4480 task
= asyncio
.ensure_future(
4488 exec_terminate_primitives
,
4492 tasks_dict_info
[task
] = "Terminating VCA {}".format(vca
.get("ee_id"))
4494 # wait for pending tasks of terminate primitives
4498 + "Waiting for tasks {}".format(list(tasks_dict_info
.keys()))
4500 error_list
= await self
._wait
_for
_tasks
(
4503 min(self
.timeout
.charm_delete
, timeout_ns_terminate
),
4507 tasks_dict_info
.clear()
4509 return # raise LcmException("; ".join(error_list))
4511 # remove All execution environments at once
4512 stage
[0] = "Stage 3/3 delete all."
4514 if nsr_deployed
.get("VCA"):
4515 stage
[1] = "Deleting all execution environments."
4516 self
.logger
.debug(logging_text
+ stage
[1])
4517 vca_id
= self
.get_vca_id({}, db_nsr
)
4518 task_delete_ee
= asyncio
.ensure_future(
4520 self
._delete
_all
_N
2VC
(db_nsr
=db_nsr
, vca_id
=vca_id
),
4521 timeout
=self
.timeout
.charm_delete
,
4524 # task_delete_ee = asyncio.ensure_future(self.n2vc.delete_namespace(namespace="." + nsr_id))
4525 tasks_dict_info
[task_delete_ee
] = "Terminating all VCA"
4527 # Delete Namespace and Certificates if necessary
4528 if check_helm_ee_in_ns(list(db_vnfds_from_member_index
.values())):
4529 await self
.vca_map
["helm-v3"].delete_tls_certificate(
4530 namespace
=db_nslcmop
["nsInstanceId"],
4531 certificate_name
=self
.EE_TLS_NAME
,
4533 await self
.vca_map
["helm-v3"].delete_namespace(
4534 namespace
=db_nslcmop
["nsInstanceId"],
4537 # Delete from k8scluster
4538 stage
[1] = "Deleting KDUs."
4539 self
.logger
.debug(logging_text
+ stage
[1])
4540 # print(nsr_deployed)
4541 for kdu
in get_iterable(nsr_deployed
, "K8s"):
4542 if not kdu
or not kdu
.get("kdu-instance"):
4544 kdu_instance
= kdu
.get("kdu-instance")
4545 if kdu
.get("k8scluster-type") in self
.k8scluster_map
:
4546 # TODO: Uninstall kdu instances taking into account they could be deployed in different VIMs
4547 vca_id
= self
.get_vca_id({}, db_nsr
)
4548 task_delete_kdu_instance
= asyncio
.ensure_future(
4549 self
.k8scluster_map
[kdu
["k8scluster-type"]].uninstall(
4550 cluster_uuid
=kdu
.get("k8scluster-uuid"),
4551 kdu_instance
=kdu_instance
,
4553 namespace
=kdu
.get("namespace"),
4559 + "Unknown k8s deployment type {}".format(
4560 kdu
.get("k8scluster-type")
4565 task_delete_kdu_instance
4566 ] = "Terminating KDU '{}'".format(kdu
.get("kdu-name"))
4569 stage
[1] = "Deleting ns from VIM."
4570 if self
.ro_config
.ng
:
4571 task_delete_ro
= asyncio
.ensure_future(
4572 self
._terminate
_ng
_ro
(
4573 logging_text
, nsr_deployed
, nsr_id
, nslcmop_id
, stage
4576 tasks_dict_info
[task_delete_ro
] = "Removing deployment from VIM"
4578 # rest of staff will be done at finally
4581 ROclient
.ROClientException
,
4586 self
.logger
.error(logging_text
+ "Exit Exception {}".format(e
))
4588 except asyncio
.CancelledError
:
4590 logging_text
+ "Cancelled Exception while '{}'".format(stage
[1])
4592 exc
= "Operation was cancelled"
4593 except Exception as e
:
4594 exc
= traceback
.format_exc()
4595 self
.logger
.critical(
4596 logging_text
+ "Exit Exception while '{}': {}".format(stage
[1], e
),
4601 error_list
.append(str(exc
))
4603 # wait for pending tasks
4605 stage
[1] = "Waiting for terminate pending tasks."
4606 self
.logger
.debug(logging_text
+ stage
[1])
4607 error_list
+= await self
._wait
_for
_tasks
(
4610 timeout_ns_terminate
,
4614 stage
[1] = stage
[2] = ""
4615 except asyncio
.CancelledError
:
4616 error_list
.append("Cancelled")
4617 # TODO cancell all tasks
4618 except Exception as exc
:
4619 error_list
.append(str(exc
))
4620 # update status at database
4622 error_detail
= "; ".join(error_list
)
4623 # self.logger.error(logging_text + error_detail)
4624 error_description_nslcmop
= "{} Detail: {}".format(
4625 stage
[0], error_detail
4627 error_description_nsr
= "Operation: TERMINATING.{}, {}.".format(
4628 nslcmop_id
, stage
[0]
4631 db_nsr_update
["operational-status"] = "failed"
4632 db_nsr_update
["detailed-status"] = (
4633 error_description_nsr
+ " Detail: " + error_detail
4635 db_nslcmop_update
["detailed-status"] = error_detail
4636 nslcmop_operation_state
= "FAILED"
4640 error_description_nsr
= error_description_nslcmop
= None
4641 ns_state
= "NOT_INSTANTIATED"
4642 db_nsr_update
["operational-status"] = "terminated"
4643 db_nsr_update
["detailed-status"] = "Done"
4644 db_nsr_update
["_admin.nsState"] = "NOT_INSTANTIATED"
4645 db_nslcmop_update
["detailed-status"] = "Done"
4646 nslcmop_operation_state
= "COMPLETED"
4649 self
._write
_ns
_status
(
4652 current_operation
="IDLE",
4653 current_operation_id
=None,
4654 error_description
=error_description_nsr
,
4655 error_detail
=error_detail
,
4656 other_update
=db_nsr_update
,
4658 self
._write
_op
_status
(
4661 error_message
=error_description_nslcmop
,
4662 operation_state
=nslcmop_operation_state
,
4663 other_update
=db_nslcmop_update
,
4665 if ns_state
== "NOT_INSTANTIATED":
4669 {"nsr-id-ref": nsr_id
},
4670 {"_admin.nsState": "NOT_INSTANTIATED"},
4672 except DbException
as e
:
4675 + "Error writing VNFR status for nsr-id-ref: {} -> {}".format(
4679 if operation_params
:
4680 autoremove
= operation_params
.get("autoremove", False)
4681 if nslcmop_operation_state
:
4683 await self
.msg
.aiowrite(
4688 "nslcmop_id": nslcmop_id
,
4689 "operationState": nslcmop_operation_state
,
4690 "autoremove": autoremove
,
4693 except Exception as e
:
4695 logging_text
+ "kafka_write notification Exception {}".format(e
)
4697 self
.logger
.debug(f
"Deleting alerts: ns_id={nsr_id}")
4698 self
.db
.del_list("alerts", {"tags.ns_id": nsr_id
})
4700 self
.logger
.debug(logging_text
+ "Exit")
4701 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_terminate")
4703 async def _wait_for_tasks(
4704 self
, logging_text
, created_tasks_info
, timeout
, stage
, nslcmop_id
, nsr_id
=None
4707 error_detail_list
= []
4709 pending_tasks
= list(created_tasks_info
.keys())
4710 num_tasks
= len(pending_tasks
)
4712 stage
[1] = "{}/{}.".format(num_done
, num_tasks
)
4713 self
._write
_op
_status
(nslcmop_id
, stage
)
4714 while pending_tasks
:
4716 _timeout
= timeout
+ time_start
- time()
4717 done
, pending_tasks
= await asyncio
.wait(
4718 pending_tasks
, timeout
=_timeout
, return_when
=asyncio
.FIRST_COMPLETED
4720 num_done
+= len(done
)
4721 if not done
: # Timeout
4722 for task
in pending_tasks
:
4723 new_error
= created_tasks_info
[task
] + ": Timeout"
4724 error_detail_list
.append(new_error
)
4725 error_list
.append(new_error
)
4728 if task
.cancelled():
4731 exc
= task
.exception()
4733 if isinstance(exc
, asyncio
.TimeoutError
):
4735 new_error
= created_tasks_info
[task
] + ": {}".format(exc
)
4736 error_list
.append(created_tasks_info
[task
])
4737 error_detail_list
.append(new_error
)
4744 ROclient
.ROClientException
,
4750 self
.logger
.error(logging_text
+ new_error
)
4752 exc_traceback
= "".join(
4753 traceback
.format_exception(None, exc
, exc
.__traceback
__)
4757 + created_tasks_info
[task
]
4763 logging_text
+ created_tasks_info
[task
] + ": Done"
4765 stage
[1] = "{}/{}.".format(num_done
, num_tasks
)
4767 stage
[1] += " Errors: " + ". ".join(error_detail_list
) + "."
4768 if nsr_id
: # update also nsr
4773 "errorDescription": "Error at: " + ", ".join(error_list
),
4774 "errorDetail": ". ".join(error_detail_list
),
4777 self
._write
_op
_status
(nslcmop_id
, stage
)
4778 return error_detail_list
4781 def _map_primitive_params(primitive_desc
, params
, instantiation_params
):
4783 Generates the params to be provided to charm before executing primitive. If user does not provide a parameter,
4784 The default-value is used. If it is between < > it look for a value at instantiation_params
4785 :param primitive_desc: portion of VNFD/NSD that describes primitive
4786 :param params: Params provided by user
4787 :param instantiation_params: Instantiation params provided by user
4788 :return: a dictionary with the calculated params
4790 calculated_params
= {}
4791 for parameter
in primitive_desc
.get("parameter", ()):
4792 param_name
= parameter
["name"]
4793 if param_name
in params
:
4794 calculated_params
[param_name
] = params
[param_name
]
4795 elif "default-value" in parameter
or "value" in parameter
:
4796 if "value" in parameter
:
4797 calculated_params
[param_name
] = parameter
["value"]
4799 calculated_params
[param_name
] = parameter
["default-value"]
4801 isinstance(calculated_params
[param_name
], str)
4802 and calculated_params
[param_name
].startswith("<")
4803 and calculated_params
[param_name
].endswith(">")
4805 if calculated_params
[param_name
][1:-1] in instantiation_params
:
4806 calculated_params
[param_name
] = instantiation_params
[
4807 calculated_params
[param_name
][1:-1]
4811 "Parameter {} needed to execute primitive {} not provided".format(
4812 calculated_params
[param_name
], primitive_desc
["name"]
4817 "Parameter {} needed to execute primitive {} not provided".format(
4818 param_name
, primitive_desc
["name"]
4822 if isinstance(calculated_params
[param_name
], (dict, list, tuple)):
4823 calculated_params
[param_name
] = yaml
.safe_dump(
4824 calculated_params
[param_name
], default_flow_style
=True, width
=256
4826 elif isinstance(calculated_params
[param_name
], str) and calculated_params
[
4828 ].startswith("!!yaml "):
4829 calculated_params
[param_name
] = calculated_params
[param_name
][7:]
4830 if parameter
.get("data-type") == "INTEGER":
4832 calculated_params
[param_name
] = int(calculated_params
[param_name
])
4833 except ValueError: # error converting string to int
4835 "Parameter {} of primitive {} must be integer".format(
4836 param_name
, primitive_desc
["name"]
4839 elif parameter
.get("data-type") == "BOOLEAN":
4840 calculated_params
[param_name
] = not (
4841 (str(calculated_params
[param_name
])).lower() == "false"
4844 # add always ns_config_info if primitive name is config
4845 if primitive_desc
["name"] == "config":
4846 if "ns_config_info" in instantiation_params
:
4847 calculated_params
["ns_config_info"] = instantiation_params
[
4850 return calculated_params
4852 def _look_for_deployed_vca(
4859 ee_descriptor_id
=None,
4861 # find vca_deployed record for this action. Raise LcmException if not found or there is not any id.
4862 for vca
in deployed_vca
:
4865 if member_vnf_index
!= vca
["member-vnf-index"] or vdu_id
!= vca
["vdu_id"]:
4868 vdu_count_index
is not None
4869 and vdu_count_index
!= vca
["vdu_count_index"]
4872 if kdu_name
and kdu_name
!= vca
["kdu_name"]:
4874 if ee_descriptor_id
and ee_descriptor_id
!= vca
["ee_descriptor_id"]:
4878 # vca_deployed not found
4880 "charm for member_vnf_index={} vdu_id={}.{} kdu_name={} execution-environment-list.id={}"
4881 " is not deployed".format(
4890 ee_id
= vca
.get("ee_id")
4892 "type", "lxc_proxy_charm"
4893 ) # default value for backward compatibility - proxy charm
4896 "charm for member_vnf_index={} vdu_id={} kdu_name={} vdu_count_index={} has not "
4897 "execution environment".format(
4898 member_vnf_index
, vdu_id
, kdu_name
, vdu_count_index
4901 return ee_id
, vca_type
4903 async def _ns_execute_primitive(
4909 retries_interval
=30,
4916 if primitive
== "config":
4917 primitive_params
= {"params": primitive_params
}
4919 vca_type
= vca_type
or "lxc_proxy_charm"
4923 output
= await asyncio
.wait_for(
4924 self
.vca_map
[vca_type
].exec_primitive(
4926 primitive_name
=primitive
,
4927 params_dict
=primitive_params
,
4928 progress_timeout
=self
.timeout
.progress_primitive
,
4929 total_timeout
=self
.timeout
.primitive
,
4934 timeout
=timeout
or self
.timeout
.primitive
,
4938 except asyncio
.CancelledError
:
4940 except Exception as e
:
4944 "Error executing action {} on {} -> {}".format(
4949 await asyncio
.sleep(retries_interval
)
4951 if isinstance(e
, asyncio
.TimeoutError
):
4953 message
="Timed out waiting for action to complete"
4955 return "FAILED", getattr(e
, "message", repr(e
))
4957 return "COMPLETED", output
4959 except (LcmException
, asyncio
.CancelledError
):
4961 except Exception as e
:
4962 return "FAIL", "Error executing action {}: {}".format(primitive
, e
)
4964 async def vca_status_refresh(self
, nsr_id
, nslcmop_id
):
4966 Updating the vca_status with latest juju information in nsrs record
4967 :param: nsr_id: Id of the nsr
4968 :param: nslcmop_id: Id of the nslcmop
4972 self
.logger
.debug("Task ns={} action={} Enter".format(nsr_id
, nslcmop_id
))
4973 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
4974 vca_id
= self
.get_vca_id({}, db_nsr
)
4975 if db_nsr
["_admin"]["deployed"]["K8s"]:
4976 for _
, k8s
in enumerate(db_nsr
["_admin"]["deployed"]["K8s"]):
4977 cluster_uuid
, kdu_instance
, cluster_type
= (
4978 k8s
["k8scluster-uuid"],
4979 k8s
["kdu-instance"],
4980 k8s
["k8scluster-type"],
4982 await self
._on
_update
_k
8s
_db
(
4983 cluster_uuid
=cluster_uuid
,
4984 kdu_instance
=kdu_instance
,
4985 filter={"_id": nsr_id
},
4987 cluster_type
=cluster_type
,
4990 for vca_index
, _
in enumerate(db_nsr
["_admin"]["deployed"]["VCA"]):
4991 table
, filter = "nsrs", {"_id": nsr_id
}
4992 path
= "_admin.deployed.VCA.{}.".format(vca_index
)
4993 await self
._on
_update
_n
2vc
_db
(table
, filter, path
, {})
4995 self
.logger
.debug("Task ns={} action={} Exit".format(nsr_id
, nslcmop_id
))
4996 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_vca_status_refresh")
4998 async def action(self
, nsr_id
, nslcmop_id
):
4999 # Try to lock HA task here
5000 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
5001 if not task_is_locked_by_me
:
5004 logging_text
= "Task ns={} action={} ".format(nsr_id
, nslcmop_id
)
5005 self
.logger
.debug(logging_text
+ "Enter")
5006 # get all needed from database
5010 db_nslcmop_update
= {}
5011 nslcmop_operation_state
= None
5012 error_description_nslcmop
= None
5016 # wait for any previous tasks in process
5017 step
= "Waiting for previous operations to terminate"
5018 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
5020 self
._write
_ns
_status
(
5023 current_operation
="RUNNING ACTION",
5024 current_operation_id
=nslcmop_id
,
5027 step
= "Getting information from database"
5028 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
5029 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
5030 if db_nslcmop
["operationParams"].get("primitive_params"):
5031 db_nslcmop
["operationParams"]["primitive_params"] = json
.loads(
5032 db_nslcmop
["operationParams"]["primitive_params"]
5035 nsr_deployed
= db_nsr
["_admin"].get("deployed")
5036 vnf_index
= db_nslcmop
["operationParams"].get("member_vnf_index")
5037 vdu_id
= db_nslcmop
["operationParams"].get("vdu_id")
5038 kdu_name
= db_nslcmop
["operationParams"].get("kdu_name")
5039 vdu_count_index
= db_nslcmop
["operationParams"].get("vdu_count_index")
5040 primitive
= db_nslcmop
["operationParams"]["primitive"]
5041 primitive_params
= db_nslcmop
["operationParams"]["primitive_params"]
5042 timeout_ns_action
= db_nslcmop
["operationParams"].get(
5043 "timeout_ns_action", self
.timeout
.primitive
5047 step
= "Getting vnfr from database"
5048 db_vnfr
= self
.db
.get_one(
5049 "vnfrs", {"member-vnf-index-ref": vnf_index
, "nsr-id-ref": nsr_id
}
5051 if db_vnfr
.get("kdur"):
5053 for kdur
in db_vnfr
["kdur"]:
5054 if kdur
.get("additionalParams"):
5055 kdur
["additionalParams"] = json
.loads(
5056 kdur
["additionalParams"]
5058 kdur_list
.append(kdur
)
5059 db_vnfr
["kdur"] = kdur_list
5060 step
= "Getting vnfd from database"
5061 db_vnfd
= self
.db
.get_one("vnfds", {"_id": db_vnfr
["vnfd-id"]})
5063 # Sync filesystem before running a primitive
5064 self
.fs
.sync(db_vnfr
["vnfd-id"])
5066 step
= "Getting nsd from database"
5067 db_nsd
= self
.db
.get_one("nsds", {"_id": db_nsr
["nsd-id"]})
5069 vca_id
= self
.get_vca_id(db_vnfr
, db_nsr
)
5070 # for backward compatibility
5071 if nsr_deployed
and isinstance(nsr_deployed
.get("VCA"), dict):
5072 nsr_deployed
["VCA"] = list(nsr_deployed
["VCA"].values())
5073 db_nsr_update
["_admin.deployed.VCA"] = nsr_deployed
["VCA"]
5074 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
5076 # look for primitive
5077 config_primitive_desc
= descriptor_configuration
= None
5079 descriptor_configuration
= get_configuration(db_vnfd
, vdu_id
)
5081 descriptor_configuration
= get_configuration(db_vnfd
, kdu_name
)
5083 descriptor_configuration
= get_configuration(db_vnfd
, db_vnfd
["id"])
5085 descriptor_configuration
= db_nsd
.get("ns-configuration")
5087 if descriptor_configuration
and descriptor_configuration
.get(
5090 for config_primitive
in descriptor_configuration
["config-primitive"]:
5091 if config_primitive
["name"] == primitive
:
5092 config_primitive_desc
= config_primitive
5095 if not config_primitive_desc
:
5096 if not (kdu_name
and primitive
in ("upgrade", "rollback", "status")):
5098 "Primitive {} not found at [ns|vnf|vdu]-configuration:config-primitive ".format(
5102 primitive_name
= primitive
5103 ee_descriptor_id
= None
5105 primitive_name
= config_primitive_desc
.get(
5106 "execution-environment-primitive", primitive
5108 ee_descriptor_id
= config_primitive_desc
.get(
5109 "execution-environment-ref"
5115 (x
for x
in db_vnfr
["vdur"] if x
["vdu-id-ref"] == vdu_id
), None
5117 desc_params
= parse_yaml_strings(vdur
.get("additionalParams"))
5120 (x
for x
in db_vnfr
["kdur"] if x
["kdu-name"] == kdu_name
), None
5122 desc_params
= parse_yaml_strings(kdur
.get("additionalParams"))
5124 desc_params
= parse_yaml_strings(
5125 db_vnfr
.get("additionalParamsForVnf")
5128 desc_params
= parse_yaml_strings(db_nsr
.get("additionalParamsForNs"))
5129 if kdu_name
and get_configuration(db_vnfd
, kdu_name
):
5130 kdu_configuration
= get_configuration(db_vnfd
, kdu_name
)
5132 for primitive
in kdu_configuration
.get("initial-config-primitive", []):
5133 actions
.add(primitive
["name"])
5134 for primitive
in kdu_configuration
.get("config-primitive", []):
5135 actions
.add(primitive
["name"])
5137 nsr_deployed
["K8s"],
5138 lambda kdu
: kdu_name
== kdu
["kdu-name"]
5139 and kdu
["member-vnf-index"] == vnf_index
,
5143 if primitive_name
in actions
5144 and kdu
["k8scluster-type"] != "helm-chart-v3"
5148 # TODO check if ns is in a proper status
5150 primitive_name
in ("upgrade", "rollback", "status") or kdu_action
5152 # kdur and desc_params already set from before
5153 if primitive_params
:
5154 desc_params
.update(primitive_params
)
5155 # TODO Check if we will need something at vnf level
5156 for index
, kdu
in enumerate(get_iterable(nsr_deployed
, "K8s")):
5158 kdu_name
== kdu
["kdu-name"]
5159 and kdu
["member-vnf-index"] == vnf_index
5164 "KDU '{}' for vnf '{}' not deployed".format(kdu_name
, vnf_index
)
5167 if kdu
.get("k8scluster-type") not in self
.k8scluster_map
:
5168 msg
= "unknown k8scluster-type '{}'".format(
5169 kdu
.get("k8scluster-type")
5171 raise LcmException(msg
)
5174 "collection": "nsrs",
5175 "filter": {"_id": nsr_id
},
5176 "path": "_admin.deployed.K8s.{}".format(index
),
5180 + "Exec k8s {} on {}.{}".format(primitive_name
, vnf_index
, kdu_name
)
5182 step
= "Executing kdu {}".format(primitive_name
)
5183 if primitive_name
== "upgrade":
5184 if desc_params
.get("kdu_model"):
5185 kdu_model
= desc_params
.get("kdu_model")
5186 del desc_params
["kdu_model"]
5188 kdu_model
= kdu
.get("kdu-model")
5189 if kdu_model
.count("/") < 2: # helm chart is not embedded
5190 parts
= kdu_model
.split(sep
=":")
5192 kdu_model
= parts
[0]
5193 if desc_params
.get("kdu_atomic_upgrade"):
5194 atomic_upgrade
= desc_params
.get(
5195 "kdu_atomic_upgrade"
5196 ).lower() in ("yes", "true", "1")
5197 del desc_params
["kdu_atomic_upgrade"]
5199 atomic_upgrade
= True
5201 detailed_status
= await asyncio
.wait_for(
5202 self
.k8scluster_map
[kdu
["k8scluster-type"]].upgrade(
5203 cluster_uuid
=kdu
.get("k8scluster-uuid"),
5204 kdu_instance
=kdu
.get("kdu-instance"),
5205 atomic
=atomic_upgrade
,
5206 kdu_model
=kdu_model
,
5209 timeout
=timeout_ns_action
,
5211 timeout
=timeout_ns_action
+ 10,
5214 logging_text
+ " Upgrade of kdu {} done".format(detailed_status
)
5216 elif primitive_name
== "rollback":
5217 detailed_status
= await asyncio
.wait_for(
5218 self
.k8scluster_map
[kdu
["k8scluster-type"]].rollback(
5219 cluster_uuid
=kdu
.get("k8scluster-uuid"),
5220 kdu_instance
=kdu
.get("kdu-instance"),
5223 timeout
=timeout_ns_action
,
5225 elif primitive_name
== "status":
5226 detailed_status
= await asyncio
.wait_for(
5227 self
.k8scluster_map
[kdu
["k8scluster-type"]].status_kdu(
5228 cluster_uuid
=kdu
.get("k8scluster-uuid"),
5229 kdu_instance
=kdu
.get("kdu-instance"),
5232 timeout
=timeout_ns_action
,
5235 kdu_instance
= kdu
.get("kdu-instance") or "{}-{}".format(
5236 kdu
["kdu-name"], nsr_id
5238 params
= self
._map
_primitive
_params
(
5239 config_primitive_desc
, primitive_params
, desc_params
5242 detailed_status
= await asyncio
.wait_for(
5243 self
.k8scluster_map
[kdu
["k8scluster-type"]].exec_primitive(
5244 cluster_uuid
=kdu
.get("k8scluster-uuid"),
5245 kdu_instance
=kdu_instance
,
5246 primitive_name
=primitive_name
,
5249 timeout
=timeout_ns_action
,
5252 timeout
=timeout_ns_action
,
5256 nslcmop_operation_state
= "COMPLETED"
5258 detailed_status
= ""
5259 nslcmop_operation_state
= "FAILED"
5261 ee_id
, vca_type
= self
._look
_for
_deployed
_vca
(
5262 nsr_deployed
["VCA"],
5263 member_vnf_index
=vnf_index
,
5265 vdu_count_index
=vdu_count_index
,
5266 ee_descriptor_id
=ee_descriptor_id
,
5268 for vca_index
, vca_deployed
in enumerate(
5269 db_nsr
["_admin"]["deployed"]["VCA"]
5271 if vca_deployed
.get("member-vnf-index") == vnf_index
:
5273 "collection": "nsrs",
5274 "filter": {"_id": nsr_id
},
5275 "path": "_admin.deployed.VCA.{}.".format(vca_index
),
5279 nslcmop_operation_state
,
5281 ) = await self
._ns
_execute
_primitive
(
5283 primitive
=primitive_name
,
5284 primitive_params
=self
._map
_primitive
_params
(
5285 config_primitive_desc
, primitive_params
, desc_params
5287 timeout
=timeout_ns_action
,
5293 db_nslcmop_update
["detailed-status"] = detailed_status
5294 error_description_nslcmop
= (
5295 detailed_status
if nslcmop_operation_state
== "FAILED" else ""
5299 + "Done with result {} {}".format(
5300 nslcmop_operation_state
, detailed_status
5303 return # database update is called inside finally
5305 except (DbException
, LcmException
, N2VCException
, K8sException
) as e
:
5306 self
.logger
.error(logging_text
+ "Exit Exception {}".format(e
))
5308 except asyncio
.CancelledError
:
5310 logging_text
+ "Cancelled Exception while '{}'".format(step
)
5312 exc
= "Operation was cancelled"
5313 except asyncio
.TimeoutError
:
5314 self
.logger
.error(logging_text
+ "Timeout while '{}'".format(step
))
5316 except Exception as e
:
5317 exc
= traceback
.format_exc()
5318 self
.logger
.critical(
5319 logging_text
+ "Exit Exception {} {}".format(type(e
).__name
__, e
),
5328 ) = error_description_nslcmop
= "FAILED {}: {}".format(step
, exc
)
5329 nslcmop_operation_state
= "FAILED"
5331 self
._write
_ns
_status
(
5335 ], # TODO check if degraded. For the moment use previous status
5336 current_operation
="IDLE",
5337 current_operation_id
=None,
5338 # error_description=error_description_nsr,
5339 # error_detail=error_detail,
5340 other_update
=db_nsr_update
,
5343 self
._write
_op
_status
(
5346 error_message
=error_description_nslcmop
,
5347 operation_state
=nslcmop_operation_state
,
5348 other_update
=db_nslcmop_update
,
5351 if nslcmop_operation_state
:
5353 await self
.msg
.aiowrite(
5358 "nslcmop_id": nslcmop_id
,
5359 "operationState": nslcmop_operation_state
,
5362 except Exception as e
:
5364 logging_text
+ "kafka_write notification Exception {}".format(e
)
5366 self
.logger
.debug(logging_text
+ "Exit")
5367 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_action")
5368 return nslcmop_operation_state
, detailed_status
5370 async def terminate_vdus(
5371 self
, db_vnfr
, member_vnf_index
, db_nsr
, update_db_nslcmops
, stage
, logging_text
5373 """This method terminates VDUs
5376 db_vnfr: VNF instance record
5377 member_vnf_index: VNF index to identify the VDUs to be removed
5378 db_nsr: NS instance record
5379 update_db_nslcmops: Nslcmop update record
5381 vca_scaling_info
= []
5382 scaling_info
= {"scaling_group_name": "vdu_autoscale", "vdu": [], "kdu": []}
5383 scaling_info
["scaling_direction"] = "IN"
5384 scaling_info
["vdu-delete"] = {}
5385 scaling_info
["kdu-delete"] = {}
5386 db_vdur
= db_vnfr
.get("vdur")
5387 vdur_list
= copy(db_vdur
)
5389 for index
, vdu
in enumerate(vdur_list
):
5390 vca_scaling_info
.append(
5392 "osm_vdu_id": vdu
["vdu-id-ref"],
5393 "member-vnf-index": member_vnf_index
,
5395 "vdu_index": count_index
,
5398 scaling_info
["vdu-delete"][vdu
["vdu-id-ref"]] = count_index
5399 scaling_info
["vdu"].append(
5401 "name": vdu
.get("name") or vdu
.get("vdu-name"),
5402 "vdu_id": vdu
["vdu-id-ref"],
5406 for interface
in vdu
["interfaces"]:
5407 scaling_info
["vdu"][index
]["interface"].append(
5409 "name": interface
["name"],
5410 "ip_address": interface
["ip-address"],
5411 "mac_address": interface
.get("mac-address"),
5414 self
.logger
.info("NS update scaling info{}".format(scaling_info
))
5415 stage
[2] = "Terminating VDUs"
5416 if scaling_info
.get("vdu-delete"):
5417 # scale_process = "RO"
5418 if self
.ro_config
.ng
:
5419 await self
._scale
_ng
_ro
(
5428 async def remove_vnf(self
, nsr_id
, nslcmop_id
, vnf_instance_id
):
5429 """This method is to Remove VNF instances from NS.
5432 nsr_id: NS instance id
5433 nslcmop_id: nslcmop id of update
5434 vnf_instance_id: id of the VNF instance to be removed
5437 result: (str, str) COMPLETED/FAILED, details
5441 logging_text
= "Task ns={} update ".format(nsr_id
)
5442 check_vnfr_count
= len(self
.db
.get_list("vnfrs", {"nsr-id-ref": nsr_id
}))
5443 self
.logger
.info("check_vnfr_count {}".format(check_vnfr_count
))
5444 if check_vnfr_count
> 1:
5445 stage
= ["", "", ""]
5446 step
= "Getting nslcmop from database"
5448 step
+ " after having waited for previous tasks to be completed"
5450 # db_nslcmop = self.db.get_one("nslcmops", {"_id": nslcmop_id})
5451 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
5452 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnf_instance_id
})
5453 member_vnf_index
= db_vnfr
["member-vnf-index-ref"]
5454 """ db_vnfr = self.db.get_one(
5455 "vnfrs", {"member-vnf-index-ref": member_vnf_index, "nsr-id-ref": nsr_id}) """
5457 update_db_nslcmops
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
5458 await self
.terminate_vdus(
5467 constituent_vnfr
= db_nsr
.get("constituent-vnfr-ref")
5468 constituent_vnfr
.remove(db_vnfr
.get("_id"))
5469 db_nsr_update
["constituent-vnfr-ref"] = db_nsr
.get(
5470 "constituent-vnfr-ref"
5472 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
5473 self
.db
.del_one("vnfrs", {"_id": db_vnfr
.get("_id")})
5474 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
5475 return "COMPLETED", "Done"
5477 step
= "Terminate VNF Failed with"
5479 "{} Cannot terminate the last VNF in this NS.".format(
5483 except (LcmException
, asyncio
.CancelledError
):
5485 except Exception as e
:
5486 self
.logger
.debug("Error removing VNF {}".format(e
))
5487 return "FAILED", "Error removing VNF {}".format(e
)
5489 async def _ns_redeploy_vnf(
5497 """This method updates and redeploys VNF instances
5500 nsr_id: NS instance id
5501 nslcmop_id: nslcmop id
5502 db_vnfd: VNF descriptor
5503 db_vnfr: VNF instance record
5504 db_nsr: NS instance record
5507 result: (str, str) COMPLETED/FAILED, details
5511 stage
= ["", "", ""]
5512 logging_text
= "Task ns={} update ".format(nsr_id
)
5513 latest_vnfd_revision
= db_vnfd
["_admin"].get("revision")
5514 member_vnf_index
= db_vnfr
["member-vnf-index-ref"]
5516 # Terminate old VNF resources
5517 update_db_nslcmops
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
5518 await self
.terminate_vdus(
5527 # old_vnfd_id = db_vnfr["vnfd-id"]
5528 # new_db_vnfd = self.db.get_one("vnfds", {"_id": vnfd_id})
5529 new_db_vnfd
= db_vnfd
5530 # new_vnfd_ref = new_db_vnfd["id"]
5531 # new_vnfd_id = vnfd_id
5535 for cp
in new_db_vnfd
.get("ext-cpd", ()):
5537 "name": cp
.get("id"),
5538 "connection-point-id": cp
.get("int-cpd", {}).get("cpd"),
5539 "connection-point-vdu-id": cp
.get("int-cpd", {}).get("vdu-id"),
5542 new_vnfr_cp
.append(vnf_cp
)
5543 new_vdur
= update_db_nslcmops
["operationParams"]["newVdur"]
5544 # new_vdur = self._create_vdur_descriptor_from_vnfd(db_nsd, db_vnfd, old_db_vnfd, vnfd_id, db_nsr, member_vnf_index)
5545 # new_vnfr_update = {"vnfd-ref": new_vnfd_ref, "vnfd-id": new_vnfd_id, "connection-point": new_vnfr_cp, "vdur": new_vdur, "ip-address": ""}
5547 "revision": latest_vnfd_revision
,
5548 "connection-point": new_vnfr_cp
,
5552 self
.update_db_2("vnfrs", db_vnfr
["_id"], new_vnfr_update
)
5553 updated_db_vnfr
= self
.db
.get_one(
5555 {"member-vnf-index-ref": member_vnf_index
, "nsr-id-ref": nsr_id
},
5558 # Instantiate new VNF resources
5559 # update_db_nslcmops = self.db.get_one("nslcmops", {"_id": nslcmop_id})
5560 vca_scaling_info
= []
5561 scaling_info
= {"scaling_group_name": "vdu_autoscale", "vdu": [], "kdu": []}
5562 scaling_info
["scaling_direction"] = "OUT"
5563 scaling_info
["vdu-create"] = {}
5564 scaling_info
["kdu-create"] = {}
5565 vdud_instantiate_list
= db_vnfd
["vdu"]
5566 for index
, vdud
in enumerate(vdud_instantiate_list
):
5567 cloud_init_text
= self
._get
_vdu
_cloud
_init
_content
(vdud
, db_vnfd
)
5569 additional_params
= (
5570 self
._get
_vdu
_additional
_params
(updated_db_vnfr
, vdud
["id"])
5573 cloud_init_list
= []
5575 # TODO Information of its own ip is not available because db_vnfr is not updated.
5576 additional_params
["OSM"] = get_osm_params(
5577 updated_db_vnfr
, vdud
["id"], 1
5579 cloud_init_list
.append(
5580 self
._parse
_cloud
_init
(
5587 vca_scaling_info
.append(
5589 "osm_vdu_id": vdud
["id"],
5590 "member-vnf-index": member_vnf_index
,
5592 "vdu_index": count_index
,
5595 scaling_info
["vdu-create"][vdud
["id"]] = count_index
5596 if self
.ro_config
.ng
:
5598 "New Resources to be deployed: {}".format(scaling_info
)
5600 await self
._scale
_ng
_ro
(
5608 return "COMPLETED", "Done"
5609 except (LcmException
, asyncio
.CancelledError
):
5611 except Exception as e
:
5612 self
.logger
.debug("Error updating VNF {}".format(e
))
5613 return "FAILED", "Error updating VNF {}".format(e
)
5615 async def _ns_charm_upgrade(
5621 timeout
: float = None,
5623 """This method upgrade charms in VNF instances
5626 ee_id: Execution environment id
5627 path: Local path to the charm
5629 charm_type: Charm type can be lxc-proxy-charm, native-charm or k8s-proxy-charm
5630 timeout: (Float) Timeout for the ns update operation
5633 result: (str, str) COMPLETED/FAILED, details
5636 charm_type
= charm_type
or "lxc_proxy_charm"
5637 output
= await self
.vca_map
[charm_type
].upgrade_charm(
5641 charm_type
=charm_type
,
5642 timeout
=timeout
or self
.timeout
.ns_update
,
5646 return "COMPLETED", output
5648 except (LcmException
, asyncio
.CancelledError
):
5651 except Exception as e
:
5652 self
.logger
.debug("Error upgrading charm {}".format(path
))
5654 return "FAILED", "Error upgrading charm {}: {}".format(path
, e
)
5656 async def update(self
, nsr_id
, nslcmop_id
):
5657 """Update NS according to different update types
5659 This method performs upgrade of VNF instances then updates the revision
5660 number in VNF record
5663 nsr_id: Network service will be updated
5664 nslcmop_id: ns lcm operation id
5667 It may raise DbException, LcmException, N2VCException, K8sException
5670 # Try to lock HA task here
5671 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
5672 if not task_is_locked_by_me
:
5675 logging_text
= "Task ns={} update={} ".format(nsr_id
, nslcmop_id
)
5676 self
.logger
.debug(logging_text
+ "Enter")
5678 # Set the required variables to be filled up later
5680 db_nslcmop_update
= {}
5682 nslcmop_operation_state
= None
5684 error_description_nslcmop
= ""
5686 change_type
= "updated"
5687 detailed_status
= ""
5688 member_vnf_index
= None
5691 # wait for any previous tasks in process
5692 step
= "Waiting for previous operations to terminate"
5693 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
5694 self
._write
_ns
_status
(
5697 current_operation
="UPDATING",
5698 current_operation_id
=nslcmop_id
,
5701 step
= "Getting nslcmop from database"
5702 db_nslcmop
= self
.db
.get_one(
5703 "nslcmops", {"_id": nslcmop_id
}, fail_on_empty
=False
5705 update_type
= db_nslcmop
["operationParams"]["updateType"]
5707 step
= "Getting nsr from database"
5708 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
5709 old_operational_status
= db_nsr
["operational-status"]
5710 db_nsr_update
["operational-status"] = "updating"
5711 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
5712 nsr_deployed
= db_nsr
["_admin"].get("deployed")
5714 if update_type
== "CHANGE_VNFPKG":
5715 # Get the input parameters given through update request
5716 vnf_instance_id
= db_nslcmop
["operationParams"][
5717 "changeVnfPackageData"
5718 ].get("vnfInstanceId")
5720 vnfd_id
= db_nslcmop
["operationParams"]["changeVnfPackageData"].get(
5723 timeout_seconds
= db_nslcmop
["operationParams"].get("timeout_ns_update")
5725 step
= "Getting vnfr from database"
5726 db_vnfr
= self
.db
.get_one(
5727 "vnfrs", {"_id": vnf_instance_id
}, fail_on_empty
=False
5730 step
= "Getting vnfds from database"
5732 latest_vnfd
= self
.db
.get_one(
5733 "vnfds", {"_id": vnfd_id
}, fail_on_empty
=False
5735 latest_vnfd_revision
= latest_vnfd
["_admin"].get("revision")
5738 current_vnf_revision
= db_vnfr
.get("revision", 1)
5739 current_vnfd
= self
.db
.get_one(
5741 {"_id": vnfd_id
+ ":" + str(current_vnf_revision
)},
5742 fail_on_empty
=False,
5744 # Charm artifact paths will be filled up later
5746 current_charm_artifact_path
,
5747 target_charm_artifact_path
,
5748 charm_artifact_paths
,
5750 ) = ([], [], [], [])
5752 step
= "Checking if revision has changed in VNFD"
5753 if current_vnf_revision
!= latest_vnfd_revision
:
5754 change_type
= "policy_updated"
5756 # There is new revision of VNFD, update operation is required
5757 current_vnfd_path
= vnfd_id
+ ":" + str(current_vnf_revision
)
5758 latest_vnfd_path
= vnfd_id
+ ":" + str(latest_vnfd_revision
)
5760 step
= "Removing the VNFD packages if they exist in the local path"
5761 shutil
.rmtree(self
.fs
.path
+ current_vnfd_path
, ignore_errors
=True)
5762 shutil
.rmtree(self
.fs
.path
+ latest_vnfd_path
, ignore_errors
=True)
5764 step
= "Get the VNFD packages from FSMongo"
5765 self
.fs
.sync(from_path
=latest_vnfd_path
)
5766 self
.fs
.sync(from_path
=current_vnfd_path
)
5769 "Get the charm-type, charm-id, ee-id if there is deployed VCA"
5771 current_base_folder
= current_vnfd
["_admin"]["storage"]
5772 latest_base_folder
= latest_vnfd
["_admin"]["storage"]
5774 for vca_index
, vca_deployed
in enumerate(
5775 get_iterable(nsr_deployed
, "VCA")
5777 vnf_index
= db_vnfr
.get("member-vnf-index-ref")
5779 # Getting charm-id and charm-type
5780 if vca_deployed
.get("member-vnf-index") == vnf_index
:
5781 vca_id
= self
.get_vca_id(db_vnfr
, db_nsr
)
5782 vca_type
= vca_deployed
.get("type")
5783 vdu_count_index
= vca_deployed
.get("vdu_count_index")
5786 ee_id
= vca_deployed
.get("ee_id")
5788 step
= "Getting descriptor config"
5789 if current_vnfd
.get("kdu"):
5790 search_key
= "kdu_name"
5792 search_key
= "vnfd_id"
5794 entity_id
= vca_deployed
.get(search_key
)
5796 descriptor_config
= get_configuration(
5797 current_vnfd
, entity_id
5800 if "execution-environment-list" in descriptor_config
:
5801 ee_list
= descriptor_config
.get(
5802 "execution-environment-list", []
5807 # There could be several charm used in the same VNF
5808 for ee_item
in ee_list
:
5809 if ee_item
.get("juju"):
5810 step
= "Getting charm name"
5811 charm_name
= ee_item
["juju"].get("charm")
5813 step
= "Setting Charm artifact paths"
5814 current_charm_artifact_path
.append(
5815 get_charm_artifact_path(
5816 current_base_folder
,
5819 current_vnf_revision
,
5822 target_charm_artifact_path
.append(
5823 get_charm_artifact_path(
5827 latest_vnfd_revision
,
5830 elif ee_item
.get("helm-chart"):
5831 # add chart to list and all parameters
5832 step
= "Getting helm chart name"
5833 chart_name
= ee_item
.get("helm-chart")
5834 vca_type
= "helm-v3"
5835 step
= "Setting Helm chart artifact paths"
5837 helm_artifacts
.append(
5839 "current_artifact_path": get_charm_artifact_path(
5840 current_base_folder
,
5843 current_vnf_revision
,
5845 "target_artifact_path": get_charm_artifact_path(
5849 latest_vnfd_revision
,
5852 "vca_index": vca_index
,
5853 "vdu_index": vdu_count_index
,
5857 charm_artifact_paths
= zip(
5858 current_charm_artifact_path
, target_charm_artifact_path
5861 step
= "Checking if software version has changed in VNFD"
5862 if find_software_version(current_vnfd
) != find_software_version(
5865 step
= "Checking if existing VNF has charm"
5866 for current_charm_path
, target_charm_path
in list(
5867 charm_artifact_paths
5869 if current_charm_path
:
5871 "Software version change is not supported as VNF instance {} has charm.".format(
5876 # There is no change in the charm package, then redeploy the VNF
5877 # based on new descriptor
5878 step
= "Redeploying VNF"
5879 member_vnf_index
= db_vnfr
["member-vnf-index-ref"]
5880 (result
, detailed_status
) = await self
._ns
_redeploy
_vnf
(
5881 nsr_id
, nslcmop_id
, latest_vnfd
, db_vnfr
, db_nsr
5883 if result
== "FAILED":
5884 nslcmop_operation_state
= result
5885 error_description_nslcmop
= detailed_status
5886 db_nslcmop_update
["detailed-status"] = detailed_status
5889 + " step {} Done with result {} {}".format(
5890 step
, nslcmop_operation_state
, detailed_status
5895 step
= "Checking if any charm package has changed or not"
5896 for current_charm_path
, target_charm_path
in list(
5897 charm_artifact_paths
5901 and target_charm_path
5902 and self
.check_charm_hash_changed(
5903 current_charm_path
, target_charm_path
5906 step
= "Checking whether VNF uses juju bundle"
5907 if check_juju_bundle_existence(current_vnfd
):
5909 "Charm upgrade is not supported for the instance which"
5910 " uses juju-bundle: {}".format(
5911 check_juju_bundle_existence(current_vnfd
)
5915 step
= "Upgrading Charm"
5919 ) = await self
._ns
_charm
_upgrade
(
5922 charm_type
=vca_type
,
5923 path
=self
.fs
.path
+ target_charm_path
,
5924 timeout
=timeout_seconds
,
5927 if result
== "FAILED":
5928 nslcmop_operation_state
= result
5929 error_description_nslcmop
= detailed_status
5931 db_nslcmop_update
["detailed-status"] = detailed_status
5934 + " step {} Done with result {} {}".format(
5935 step
, nslcmop_operation_state
, detailed_status
5939 step
= "Updating policies"
5940 member_vnf_index
= db_vnfr
["member-vnf-index-ref"]
5941 result
= "COMPLETED"
5942 detailed_status
= "Done"
5943 db_nslcmop_update
["detailed-status"] = "Done"
5946 for item
in helm_artifacts
:
5948 item
["current_artifact_path"]
5949 and item
["target_artifact_path"]
5950 and self
.check_charm_hash_changed(
5951 item
["current_artifact_path"],
5952 item
["target_artifact_path"],
5956 db_update_entry
= "_admin.deployed.VCA.{}.".format(
5959 vnfr_id
= db_vnfr
["_id"]
5960 osm_config
= {"osm": {"ns_id": nsr_id
, "vnf_id": vnfr_id
}}
5962 "collection": "nsrs",
5963 "filter": {"_id": nsr_id
},
5964 "path": db_update_entry
,
5966 vca_type
, namespace
, helm_id
= get_ee_id_parts(item
["ee_id"])
5967 await self
.vca_map
[vca_type
].upgrade_execution_environment(
5968 namespace
=namespace
,
5972 artifact_path
=item
["target_artifact_path"],
5975 vnf_id
= db_vnfr
.get("vnfd-ref")
5976 config_descriptor
= get_configuration(latest_vnfd
, vnf_id
)
5977 self
.logger
.debug("get ssh key block")
5981 ("config-access", "ssh-access", "required"),
5983 # Needed to inject a ssh key
5986 ("config-access", "ssh-access", "default-user"),
5989 "Install configuration Software, getting public ssh key"
5991 pub_key
= await self
.vca_map
[
5993 ].get_ee_ssh_public__key(
5994 ee_id
=ee_id
, db_dict
=db_dict
, vca_id
=vca_id
5998 "Insert public key into VM user={} ssh_key={}".format(
6002 self
.logger
.debug(logging_text
+ step
)
6004 # wait for RO (ip-address) Insert pub_key into VM
6005 rw_mgmt_ip
= await self
.wait_vm_up_insert_key_ro(
6015 initial_config_primitive_list
= config_descriptor
.get(
6016 "initial-config-primitive"
6018 config_primitive
= next(
6021 for p
in initial_config_primitive_list
6022 if p
["name"] == "config"
6026 if not config_primitive
:
6029 deploy_params
= {"OSM": get_osm_params(db_vnfr
)}
6031 deploy_params
["rw_mgmt_ip"] = rw_mgmt_ip
6032 if db_vnfr
.get("additionalParamsForVnf"):
6033 deploy_params
.update(
6035 db_vnfr
["additionalParamsForVnf"].copy()
6038 primitive_params_
= self
._map
_primitive
_params
(
6039 config_primitive
, {}, deploy_params
6042 step
= "execute primitive '{}' params '{}'".format(
6043 config_primitive
["name"], primitive_params_
6045 self
.logger
.debug(logging_text
+ step
)
6046 await self
.vca_map
[vca_type
].exec_primitive(
6048 primitive_name
=config_primitive
["name"],
6049 params_dict
=primitive_params_
,
6055 step
= "Updating policies"
6056 member_vnf_index
= db_vnfr
["member-vnf-index-ref"]
6057 detailed_status
= "Done"
6058 db_nslcmop_update
["detailed-status"] = "Done"
6060 # If nslcmop_operation_state is None, so any operation is not failed.
6061 if not nslcmop_operation_state
:
6062 nslcmop_operation_state
= "COMPLETED"
6064 # If update CHANGE_VNFPKG nslcmop_operation is successful
6065 # vnf revision need to be updated
6066 vnfr_update
["revision"] = latest_vnfd_revision
6067 self
.update_db_2("vnfrs", db_vnfr
["_id"], vnfr_update
)
6071 + " task Done with result {} {}".format(
6072 nslcmop_operation_state
, detailed_status
6075 elif update_type
== "REMOVE_VNF":
6076 # This part is included in https://osm.etsi.org/gerrit/11876
6077 vnf_instance_id
= db_nslcmop
["operationParams"]["removeVnfInstanceId"]
6078 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnf_instance_id
})
6079 member_vnf_index
= db_vnfr
["member-vnf-index-ref"]
6080 step
= "Removing VNF"
6081 (result
, detailed_status
) = await self
.remove_vnf(
6082 nsr_id
, nslcmop_id
, vnf_instance_id
6084 if result
== "FAILED":
6085 nslcmop_operation_state
= result
6086 error_description_nslcmop
= detailed_status
6087 db_nslcmop_update
["detailed-status"] = detailed_status
6088 change_type
= "vnf_terminated"
6089 if not nslcmop_operation_state
:
6090 nslcmop_operation_state
= "COMPLETED"
6093 + " task Done with result {} {}".format(
6094 nslcmop_operation_state
, detailed_status
6098 elif update_type
== "OPERATE_VNF":
6099 vnf_id
= db_nslcmop
["operationParams"]["operateVnfData"][
6102 operation_type
= db_nslcmop
["operationParams"]["operateVnfData"][
6105 additional_param
= db_nslcmop
["operationParams"]["operateVnfData"][
6108 (result
, detailed_status
) = await self
.rebuild_start_stop(
6109 nsr_id
, nslcmop_id
, vnf_id
, additional_param
, operation_type
6111 if result
== "FAILED":
6112 nslcmop_operation_state
= result
6113 error_description_nslcmop
= detailed_status
6114 db_nslcmop_update
["detailed-status"] = detailed_status
6115 if not nslcmop_operation_state
:
6116 nslcmop_operation_state
= "COMPLETED"
6119 + " task Done with result {} {}".format(
6120 nslcmop_operation_state
, detailed_status
6124 # If nslcmop_operation_state is None, so any operation is not failed.
6125 # All operations are executed in overall.
6126 if not nslcmop_operation_state
:
6127 nslcmop_operation_state
= "COMPLETED"
6128 db_nsr_update
["operational-status"] = old_operational_status
6130 except (DbException
, LcmException
, N2VCException
, K8sException
) as e
:
6131 self
.logger
.error(logging_text
+ "Exit Exception {}".format(e
))
6133 except asyncio
.CancelledError
:
6135 logging_text
+ "Cancelled Exception while '{}'".format(step
)
6137 exc
= "Operation was cancelled"
6138 except asyncio
.TimeoutError
:
6139 self
.logger
.error(logging_text
+ "Timeout while '{}'".format(step
))
6141 except Exception as e
:
6142 exc
= traceback
.format_exc()
6143 self
.logger
.critical(
6144 logging_text
+ "Exit Exception {} {}".format(type(e
).__name
__, e
),
6153 ) = error_description_nslcmop
= "FAILED {}: {}".format(step
, exc
)
6154 nslcmop_operation_state
= "FAILED"
6155 db_nsr_update
["operational-status"] = old_operational_status
6157 self
._write
_ns
_status
(
6159 ns_state
=db_nsr
["nsState"],
6160 current_operation
="IDLE",
6161 current_operation_id
=None,
6162 other_update
=db_nsr_update
,
6165 self
._write
_op
_status
(
6168 error_message
=error_description_nslcmop
,
6169 operation_state
=nslcmop_operation_state
,
6170 other_update
=db_nslcmop_update
,
6173 if nslcmop_operation_state
:
6177 "nslcmop_id": nslcmop_id
,
6178 "operationState": nslcmop_operation_state
,
6181 change_type
in ("vnf_terminated", "policy_updated")
6182 and member_vnf_index
6184 msg
.update({"vnf_member_index": member_vnf_index
})
6185 await self
.msg
.aiowrite("ns", change_type
, msg
)
6186 except Exception as e
:
6188 logging_text
+ "kafka_write notification Exception {}".format(e
)
6190 self
.logger
.debug(logging_text
+ "Exit")
6191 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_update")
6192 return nslcmop_operation_state
, detailed_status
6194 async def scale(self
, nsr_id
, nslcmop_id
):
6195 # Try to lock HA task here
6196 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
6197 if not task_is_locked_by_me
:
6200 logging_text
= "Task ns={} scale={} ".format(nsr_id
, nslcmop_id
)
6201 stage
= ["", "", ""]
6202 tasks_dict_info
= {}
6203 # ^ stage, step, VIM progress
6204 self
.logger
.debug(logging_text
+ "Enter")
6205 # get all needed from database
6207 db_nslcmop_update
= {}
6210 # in case of error, indicates what part of scale was failed to put nsr at error status
6211 scale_process
= None
6212 old_operational_status
= ""
6213 old_config_status
= ""
6216 # wait for any previous tasks in process
6217 step
= "Waiting for previous operations to terminate"
6218 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
6219 self
._write
_ns
_status
(
6222 current_operation
="SCALING",
6223 current_operation_id
=nslcmop_id
,
6226 step
= "Getting nslcmop from database"
6228 step
+ " after having waited for previous tasks to be completed"
6230 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
6232 step
= "Getting nsr from database"
6233 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
6234 old_operational_status
= db_nsr
["operational-status"]
6235 old_config_status
= db_nsr
["config-status"]
6237 step
= "Parsing scaling parameters"
6238 db_nsr_update
["operational-status"] = "scaling"
6239 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
6240 nsr_deployed
= db_nsr
["_admin"].get("deployed")
6242 vnf_index
= db_nslcmop
["operationParams"]["scaleVnfData"][
6244 ]["member-vnf-index"]
6245 scaling_group
= db_nslcmop
["operationParams"]["scaleVnfData"][
6247 ]["scaling-group-descriptor"]
6248 scaling_type
= db_nslcmop
["operationParams"]["scaleVnfData"]["scaleVnfType"]
6249 # for backward compatibility
6250 if nsr_deployed
and isinstance(nsr_deployed
.get("VCA"), dict):
6251 nsr_deployed
["VCA"] = list(nsr_deployed
["VCA"].values())
6252 db_nsr_update
["_admin.deployed.VCA"] = nsr_deployed
["VCA"]
6253 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
6255 step
= "Getting vnfr from database"
6256 db_vnfr
= self
.db
.get_one(
6257 "vnfrs", {"member-vnf-index-ref": vnf_index
, "nsr-id-ref": nsr_id
}
6260 vca_id
= self
.get_vca_id(db_vnfr
, db_nsr
)
6262 step
= "Getting vnfd from database"
6263 db_vnfd
= self
.db
.get_one("vnfds", {"_id": db_vnfr
["vnfd-id"]})
6265 base_folder
= db_vnfd
["_admin"]["storage"]
6267 step
= "Getting scaling-group-descriptor"
6268 scaling_descriptor
= find_in_list(
6269 get_scaling_aspect(db_vnfd
),
6270 lambda scale_desc
: scale_desc
["name"] == scaling_group
,
6272 if not scaling_descriptor
:
6274 "input parameter 'scaleByStepData':'scaling-group-descriptor':'{}' is not present "
6275 "at vnfd:scaling-group-descriptor".format(scaling_group
)
6278 step
= "Sending scale order to VIM"
6279 # TODO check if ns is in a proper status
6281 if not db_nsr
["_admin"].get("scaling-group"):
6286 "_admin.scaling-group": [
6287 {"name": scaling_group
, "nb-scale-op": 0}
6291 admin_scale_index
= 0
6293 for admin_scale_index
, admin_scale_info
in enumerate(
6294 db_nsr
["_admin"]["scaling-group"]
6296 if admin_scale_info
["name"] == scaling_group
:
6297 nb_scale_op
= admin_scale_info
.get("nb-scale-op", 0)
6299 else: # not found, set index one plus last element and add new entry with the name
6300 admin_scale_index
+= 1
6302 "_admin.scaling-group.{}.name".format(admin_scale_index
)
6305 vca_scaling_info
= []
6306 scaling_info
= {"scaling_group_name": scaling_group
, "vdu": [], "kdu": []}
6307 if scaling_type
== "SCALE_OUT":
6308 if "aspect-delta-details" not in scaling_descriptor
:
6310 "Aspect delta details not fount in scaling descriptor {}".format(
6311 scaling_descriptor
["name"]
6314 # count if max-instance-count is reached
6315 deltas
= scaling_descriptor
.get("aspect-delta-details")["deltas"]
6317 scaling_info
["scaling_direction"] = "OUT"
6318 scaling_info
["vdu-create"] = {}
6319 scaling_info
["kdu-create"] = {}
6320 for delta
in deltas
:
6321 for vdu_delta
in delta
.get("vdu-delta", {}):
6322 vdud
= get_vdu(db_vnfd
, vdu_delta
["id"])
6323 # vdu_index also provides the number of instance of the targeted vdu
6324 vdu_count
= vdu_index
= get_vdur_index(db_vnfr
, vdu_delta
)
6325 cloud_init_text
= self
._get
_vdu
_cloud
_init
_content
(
6329 additional_params
= (
6330 self
._get
_vdu
_additional
_params
(db_vnfr
, vdud
["id"])
6333 cloud_init_list
= []
6335 vdu_profile
= get_vdu_profile(db_vnfd
, vdu_delta
["id"])
6336 max_instance_count
= 10
6337 if vdu_profile
and "max-number-of-instances" in vdu_profile
:
6338 max_instance_count
= vdu_profile
.get(
6339 "max-number-of-instances", 10
6342 default_instance_num
= get_number_of_instances(
6345 instances_number
= vdu_delta
.get("number-of-instances", 1)
6346 nb_scale_op
+= instances_number
6348 new_instance_count
= nb_scale_op
+ default_instance_num
6349 # Control if new count is over max and vdu count is less than max.
6350 # Then assign new instance count
6351 if new_instance_count
> max_instance_count
> vdu_count
:
6352 instances_number
= new_instance_count
- max_instance_count
6354 instances_number
= instances_number
6356 if new_instance_count
> max_instance_count
:
6358 "reached the limit of {} (max-instance-count) "
6359 "scaling-out operations for the "
6360 "scaling-group-descriptor '{}'".format(
6361 nb_scale_op
, scaling_group
6364 for x
in range(vdu_delta
.get("number-of-instances", 1)):
6366 # TODO Information of its own ip is not available because db_vnfr is not updated.
6367 additional_params
["OSM"] = get_osm_params(
6368 db_vnfr
, vdu_delta
["id"], vdu_index
+ x
6370 cloud_init_list
.append(
6371 self
._parse
_cloud
_init
(
6378 vca_scaling_info
.append(
6380 "osm_vdu_id": vdu_delta
["id"],
6381 "member-vnf-index": vnf_index
,
6383 "vdu_index": vdu_index
+ x
,
6386 scaling_info
["vdu-create"][vdu_delta
["id"]] = instances_number
6387 for kdu_delta
in delta
.get("kdu-resource-delta", {}):
6388 kdu_profile
= get_kdu_resource_profile(db_vnfd
, kdu_delta
["id"])
6389 kdu_name
= kdu_profile
["kdu-name"]
6390 resource_name
= kdu_profile
.get("resource-name", "")
6392 # Might have different kdus in the same delta
6393 # Should have list for each kdu
6394 if not scaling_info
["kdu-create"].get(kdu_name
, None):
6395 scaling_info
["kdu-create"][kdu_name
] = []
6397 kdur
= get_kdur(db_vnfr
, kdu_name
)
6398 if kdur
.get("helm-chart"):
6399 k8s_cluster_type
= "helm-chart-v3"
6400 self
.logger
.debug("kdur: {}".format(kdur
))
6401 elif kdur
.get("juju-bundle"):
6402 k8s_cluster_type
= "juju-bundle"
6405 "kdu type for kdu='{}.{}' is neither helm-chart nor "
6406 "juju-bundle. Maybe an old NBI version is running".format(
6407 db_vnfr
["member-vnf-index-ref"], kdu_name
6411 max_instance_count
= 10
6412 if kdu_profile
and "max-number-of-instances" in kdu_profile
:
6413 max_instance_count
= kdu_profile
.get(
6414 "max-number-of-instances", 10
6417 nb_scale_op
+= kdu_delta
.get("number-of-instances", 1)
6418 deployed_kdu
, _
= get_deployed_kdu(
6419 nsr_deployed
, kdu_name
, vnf_index
6421 if deployed_kdu
is None:
6423 "KDU '{}' for vnf '{}' not deployed".format(
6427 kdu_instance
= deployed_kdu
.get("kdu-instance")
6428 instance_num
= await self
.k8scluster_map
[
6434 cluster_uuid
=deployed_kdu
.get("k8scluster-uuid"),
6435 kdu_model
=deployed_kdu
.get("kdu-model"),
6437 kdu_replica_count
= instance_num
+ kdu_delta
.get(
6438 "number-of-instances", 1
6441 # Control if new count is over max and instance_num is less than max.
6442 # Then assign max instance number to kdu replica count
6443 if kdu_replica_count
> max_instance_count
> instance_num
:
6444 kdu_replica_count
= max_instance_count
6445 if kdu_replica_count
> max_instance_count
:
6447 "reached the limit of {} (max-instance-count) "
6448 "scaling-out operations for the "
6449 "scaling-group-descriptor '{}'".format(
6450 instance_num
, scaling_group
6454 for x
in range(kdu_delta
.get("number-of-instances", 1)):
6455 vca_scaling_info
.append(
6457 "osm_kdu_id": kdu_name
,
6458 "member-vnf-index": vnf_index
,
6460 "kdu_index": instance_num
+ x
- 1,
6463 scaling_info
["kdu-create"][kdu_name
].append(
6465 "member-vnf-index": vnf_index
,
6467 "k8s-cluster-type": k8s_cluster_type
,
6468 "resource-name": resource_name
,
6469 "scale": kdu_replica_count
,
6472 elif scaling_type
== "SCALE_IN":
6473 deltas
= scaling_descriptor
.get("aspect-delta-details")["deltas"]
6475 scaling_info
["scaling_direction"] = "IN"
6476 scaling_info
["vdu-delete"] = {}
6477 scaling_info
["kdu-delete"] = {}
6479 for delta
in deltas
:
6480 for vdu_delta
in delta
.get("vdu-delta", {}):
6481 vdu_count
= vdu_index
= get_vdur_index(db_vnfr
, vdu_delta
)
6482 min_instance_count
= 0
6483 vdu_profile
= get_vdu_profile(db_vnfd
, vdu_delta
["id"])
6484 if vdu_profile
and "min-number-of-instances" in vdu_profile
:
6485 min_instance_count
= vdu_profile
["min-number-of-instances"]
6487 default_instance_num
= get_number_of_instances(
6488 db_vnfd
, vdu_delta
["id"]
6490 instance_num
= vdu_delta
.get("number-of-instances", 1)
6491 nb_scale_op
-= instance_num
6493 new_instance_count
= nb_scale_op
+ default_instance_num
6495 if new_instance_count
< min_instance_count
< vdu_count
:
6496 instances_number
= min_instance_count
- new_instance_count
6498 instances_number
= instance_num
6500 if new_instance_count
< min_instance_count
:
6502 "reached the limit of {} (min-instance-count) scaling-in operations for the "
6503 "scaling-group-descriptor '{}'".format(
6504 nb_scale_op
, scaling_group
6507 for x
in range(vdu_delta
.get("number-of-instances", 1)):
6508 vca_scaling_info
.append(
6510 "osm_vdu_id": vdu_delta
["id"],
6511 "member-vnf-index": vnf_index
,
6513 "vdu_index": vdu_index
- 1 - x
,
6516 scaling_info
["vdu-delete"][vdu_delta
["id"]] = instances_number
6517 for kdu_delta
in delta
.get("kdu-resource-delta", {}):
6518 kdu_profile
= get_kdu_resource_profile(db_vnfd
, kdu_delta
["id"])
6519 kdu_name
= kdu_profile
["kdu-name"]
6520 resource_name
= kdu_profile
.get("resource-name", "")
6522 if not scaling_info
["kdu-delete"].get(kdu_name
, None):
6523 scaling_info
["kdu-delete"][kdu_name
] = []
6525 kdur
= get_kdur(db_vnfr
, kdu_name
)
6526 if kdur
.get("helm-chart"):
6527 k8s_cluster_type
= "helm-chart-v3"
6528 self
.logger
.debug("kdur: {}".format(kdur
))
6529 elif kdur
.get("juju-bundle"):
6530 k8s_cluster_type
= "juju-bundle"
6533 "kdu type for kdu='{}.{}' is neither helm-chart nor "
6534 "juju-bundle. Maybe an old NBI version is running".format(
6535 db_vnfr
["member-vnf-index-ref"], kdur
["kdu-name"]
6539 min_instance_count
= 0
6540 if kdu_profile
and "min-number-of-instances" in kdu_profile
:
6541 min_instance_count
= kdu_profile
["min-number-of-instances"]
6543 nb_scale_op
-= kdu_delta
.get("number-of-instances", 1)
6544 deployed_kdu
, _
= get_deployed_kdu(
6545 nsr_deployed
, kdu_name
, vnf_index
6547 if deployed_kdu
is None:
6549 "KDU '{}' for vnf '{}' not deployed".format(
6553 kdu_instance
= deployed_kdu
.get("kdu-instance")
6554 instance_num
= await self
.k8scluster_map
[
6560 cluster_uuid
=deployed_kdu
.get("k8scluster-uuid"),
6561 kdu_model
=deployed_kdu
.get("kdu-model"),
6563 kdu_replica_count
= instance_num
- kdu_delta
.get(
6564 "number-of-instances", 1
6567 if kdu_replica_count
< min_instance_count
< instance_num
:
6568 kdu_replica_count
= min_instance_count
6569 if kdu_replica_count
< min_instance_count
:
6571 "reached the limit of {} (min-instance-count) scaling-in operations for the "
6572 "scaling-group-descriptor '{}'".format(
6573 instance_num
, scaling_group
6577 for x
in range(kdu_delta
.get("number-of-instances", 1)):
6578 vca_scaling_info
.append(
6580 "osm_kdu_id": kdu_name
,
6581 "member-vnf-index": vnf_index
,
6583 "kdu_index": instance_num
- x
- 1,
6586 scaling_info
["kdu-delete"][kdu_name
].append(
6588 "member-vnf-index": vnf_index
,
6590 "k8s-cluster-type": k8s_cluster_type
,
6591 "resource-name": resource_name
,
6592 "scale": kdu_replica_count
,
6596 # update VDU_SCALING_INFO with the VDUs to delete ip_addresses
6597 vdu_delete
= copy(scaling_info
.get("vdu-delete"))
6598 if scaling_info
["scaling_direction"] == "IN":
6599 for vdur
in reversed(db_vnfr
["vdur"]):
6600 if vdu_delete
.get(vdur
["vdu-id-ref"]):
6601 vdu_delete
[vdur
["vdu-id-ref"]] -= 1
6602 scaling_info
["vdu"].append(
6604 "name": vdur
.get("name") or vdur
.get("vdu-name"),
6605 "vdu_id": vdur
["vdu-id-ref"],
6609 for interface
in vdur
["interfaces"]:
6610 scaling_info
["vdu"][-1]["interface"].append(
6612 "name": interface
["name"],
6613 "ip_address": interface
["ip-address"],
6614 "mac_address": interface
.get("mac-address"),
6617 # vdu_delete = vdu_scaling_info.pop("vdu-delete")
6620 step
= "Executing pre-scale vnf-config-primitive"
6621 if scaling_descriptor
.get("scaling-config-action"):
6622 for scaling_config_action
in scaling_descriptor
[
6623 "scaling-config-action"
6626 scaling_config_action
.get("trigger") == "pre-scale-in"
6627 and scaling_type
== "SCALE_IN"
6629 scaling_config_action
.get("trigger") == "pre-scale-out"
6630 and scaling_type
== "SCALE_OUT"
6632 vnf_config_primitive
= scaling_config_action
[
6633 "vnf-config-primitive-name-ref"
6635 step
= db_nslcmop_update
[
6637 ] = "executing pre-scale scaling-config-action '{}'".format(
6638 vnf_config_primitive
6641 # look for primitive
6642 for config_primitive
in (
6643 get_configuration(db_vnfd
, db_vnfd
["id"]) or {}
6644 ).get("config-primitive", ()):
6645 if config_primitive
["name"] == vnf_config_primitive
:
6649 "Invalid vnfd descriptor at scaling-group-descriptor[name='{}']:scaling-config-action"
6650 "[vnf-config-primitive-name-ref='{}'] does not match any vnf-configuration:config-"
6651 "primitive".format(scaling_group
, vnf_config_primitive
)
6654 vnfr_params
= {"VDU_SCALE_INFO": scaling_info
}
6655 if db_vnfr
.get("additionalParamsForVnf"):
6656 vnfr_params
.update(db_vnfr
["additionalParamsForVnf"])
6658 scale_process
= "VCA"
6659 db_nsr_update
["config-status"] = "configuring pre-scaling"
6660 primitive_params
= self
._map
_primitive
_params
(
6661 config_primitive
, {}, vnfr_params
6664 # Pre-scale retry check: Check if this sub-operation has been executed before
6665 op_index
= self
._check
_or
_add
_scale
_suboperation
(
6668 vnf_config_primitive
,
6672 if op_index
== self
.SUBOPERATION_STATUS_SKIP
:
6673 # Skip sub-operation
6674 result
= "COMPLETED"
6675 result_detail
= "Done"
6678 + "vnf_config_primitive={} Skipped sub-operation, result {} {}".format(
6679 vnf_config_primitive
, result
, result_detail
6683 if op_index
== self
.SUBOPERATION_STATUS_NEW
:
6684 # New sub-operation: Get index of this sub-operation
6686 len(db_nslcmop
.get("_admin", {}).get("operations"))
6691 + "vnf_config_primitive={} New sub-operation".format(
6692 vnf_config_primitive
6696 # retry: Get registered params for this existing sub-operation
6697 op
= db_nslcmop
.get("_admin", {}).get("operations", [])[
6700 vnf_index
= op
.get("member_vnf_index")
6701 vnf_config_primitive
= op
.get("primitive")
6702 primitive_params
= op
.get("primitive_params")
6705 + "vnf_config_primitive={} Sub-operation retry".format(
6706 vnf_config_primitive
6709 # Execute the primitive, either with new (first-time) or registered (reintent) args
6710 ee_descriptor_id
= config_primitive
.get(
6711 "execution-environment-ref"
6713 primitive_name
= config_primitive
.get(
6714 "execution-environment-primitive", vnf_config_primitive
6716 ee_id
, vca_type
= self
._look
_for
_deployed
_vca
(
6717 nsr_deployed
["VCA"],
6718 member_vnf_index
=vnf_index
,
6720 vdu_count_index
=None,
6721 ee_descriptor_id
=ee_descriptor_id
,
6723 result
, result_detail
= await self
._ns
_execute
_primitive
(
6732 + "vnf_config_primitive={} Done with result {} {}".format(
6733 vnf_config_primitive
, result
, result_detail
6736 # Update operationState = COMPLETED | FAILED
6737 self
._update
_suboperation
_status
(
6738 db_nslcmop
, op_index
, result
, result_detail
6741 if result
== "FAILED":
6742 raise LcmException(result_detail
)
6743 db_nsr_update
["config-status"] = old_config_status
6744 scale_process
= None
6748 "_admin.scaling-group.{}.nb-scale-op".format(admin_scale_index
)
6751 "_admin.scaling-group.{}.time".format(admin_scale_index
)
6754 # SCALE-IN VCA - BEGIN
6755 if vca_scaling_info
:
6756 step
= db_nslcmop_update
[
6758 ] = "Deleting the execution environments"
6759 scale_process
= "VCA"
6760 for vca_info
in vca_scaling_info
:
6761 if vca_info
["type"] == "delete" and not vca_info
.get("osm_kdu_id"):
6762 member_vnf_index
= str(vca_info
["member-vnf-index"])
6764 logging_text
+ "vdu info: {}".format(vca_info
)
6766 if vca_info
.get("osm_vdu_id"):
6767 vdu_id
= vca_info
["osm_vdu_id"]
6768 vdu_index
= int(vca_info
["vdu_index"])
6771 ] = "Scaling member_vnf_index={}, vdu_id={}, vdu_index={} ".format(
6772 member_vnf_index
, vdu_id
, vdu_index
6774 stage
[2] = step
= "Scaling in VCA"
6775 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
)
6776 vca_update
= db_nsr
["_admin"]["deployed"]["VCA"]
6777 config_update
= db_nsr
["configurationStatus"]
6778 for vca_index
, vca
in enumerate(vca_update
):
6780 (vca
or vca
.get("ee_id"))
6781 and vca
["member-vnf-index"] == member_vnf_index
6782 and vca
["vdu_count_index"] == vdu_index
6784 if vca
.get("vdu_id"):
6785 config_descriptor
= get_configuration(
6786 db_vnfd
, vca
.get("vdu_id")
6788 elif vca
.get("kdu_name"):
6789 config_descriptor
= get_configuration(
6790 db_vnfd
, vca
.get("kdu_name")
6793 config_descriptor
= get_configuration(
6794 db_vnfd
, db_vnfd
["id"]
6796 operation_params
= (
6797 db_nslcmop
.get("operationParams") or {}
6799 exec_terminate_primitives
= not operation_params
.get(
6800 "skip_terminate_primitives"
6801 ) and vca
.get("needed_terminate")
6802 task
= asyncio
.ensure_future(
6811 exec_primitives
=exec_terminate_primitives
,
6815 timeout
=self
.timeout
.charm_delete
,
6818 tasks_dict_info
[task
] = "Terminating VCA {}".format(
6821 del vca_update
[vca_index
]
6822 del config_update
[vca_index
]
6823 # wait for pending tasks of terminate primitives
6827 + "Waiting for tasks {}".format(
6828 list(tasks_dict_info
.keys())
6831 error_list
= await self
._wait
_for
_tasks
(
6835 self
.timeout
.charm_delete
, self
.timeout
.ns_terminate
6840 tasks_dict_info
.clear()
6842 raise LcmException("; ".join(error_list
))
6844 db_vca_and_config_update
= {
6845 "_admin.deployed.VCA": vca_update
,
6846 "configurationStatus": config_update
,
6849 "nsrs", db_nsr
["_id"], db_vca_and_config_update
6851 scale_process
= None
6852 # SCALE-IN VCA - END
6855 if scaling_info
.get("vdu-create") or scaling_info
.get("vdu-delete"):
6856 scale_process
= "RO"
6857 if self
.ro_config
.ng
:
6858 await self
._scale
_ng
_ro
(
6859 logging_text
, db_nsr
, db_nslcmop
, db_vnfr
, scaling_info
, stage
6861 scaling_info
.pop("vdu-create", None)
6862 scaling_info
.pop("vdu-delete", None)
6864 scale_process
= None
6868 if scaling_info
.get("kdu-create") or scaling_info
.get("kdu-delete"):
6869 scale_process
= "KDU"
6870 await self
._scale
_kdu
(
6871 logging_text
, nsr_id
, nsr_deployed
, db_vnfd
, vca_id
, scaling_info
6873 scaling_info
.pop("kdu-create", None)
6874 scaling_info
.pop("kdu-delete", None)
6876 scale_process
= None
6880 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
6882 # SCALE-UP VCA - BEGIN
6883 if vca_scaling_info
:
6884 step
= db_nslcmop_update
[
6886 ] = "Creating new execution environments"
6887 scale_process
= "VCA"
6888 for vca_info
in vca_scaling_info
:
6889 if vca_info
["type"] == "create" and not vca_info
.get("osm_kdu_id"):
6890 member_vnf_index
= str(vca_info
["member-vnf-index"])
6892 logging_text
+ "vdu info: {}".format(vca_info
)
6894 vnfd_id
= db_vnfr
["vnfd-ref"]
6895 if vca_info
.get("osm_vdu_id"):
6896 vdu_index
= int(vca_info
["vdu_index"])
6897 deploy_params
= {"OSM": get_osm_params(db_vnfr
)}
6898 if db_vnfr
.get("additionalParamsForVnf"):
6899 deploy_params
.update(
6901 db_vnfr
["additionalParamsForVnf"].copy()
6904 descriptor_config
= get_configuration(
6905 db_vnfd
, db_vnfd
["id"]
6907 if descriptor_config
:
6913 logging_text
=logging_text
6914 + "member_vnf_index={} ".format(member_vnf_index
),
6917 nslcmop_id
=nslcmop_id
,
6923 kdu_index
=kdu_index
,
6924 member_vnf_index
=member_vnf_index
,
6925 vdu_index
=vdu_index
,
6927 deploy_params
=deploy_params
,
6928 descriptor_config
=descriptor_config
,
6929 base_folder
=base_folder
,
6930 task_instantiation_info
=tasks_dict_info
,
6933 vdu_id
= vca_info
["osm_vdu_id"]
6934 vdur
= find_in_list(
6935 db_vnfr
["vdur"], lambda vdu
: vdu
["vdu-id-ref"] == vdu_id
6937 descriptor_config
= get_configuration(db_vnfd
, vdu_id
)
6938 if vdur
.get("additionalParams"):
6939 deploy_params_vdu
= parse_yaml_strings(
6940 vdur
["additionalParams"]
6943 deploy_params_vdu
= deploy_params
6944 deploy_params_vdu
["OSM"] = get_osm_params(
6945 db_vnfr
, vdu_id
, vdu_count_index
=vdu_index
6947 if descriptor_config
:
6953 ] = "Scaling member_vnf_index={}, vdu_id={}, vdu_index={} ".format(
6954 member_vnf_index
, vdu_id
, vdu_index
6956 stage
[2] = step
= "Scaling out VCA"
6957 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
)
6959 logging_text
=logging_text
6960 + "member_vnf_index={}, vdu_id={}, vdu_index={} ".format(
6961 member_vnf_index
, vdu_id
, vdu_index
6965 nslcmop_id
=nslcmop_id
,
6971 member_vnf_index
=member_vnf_index
,
6972 vdu_index
=vdu_index
,
6973 kdu_index
=kdu_index
,
6975 deploy_params
=deploy_params_vdu
,
6976 descriptor_config
=descriptor_config
,
6977 base_folder
=base_folder
,
6978 task_instantiation_info
=tasks_dict_info
,
6981 # SCALE-UP VCA - END
6982 scale_process
= None
6985 # execute primitive service POST-SCALING
6986 step
= "Executing post-scale vnf-config-primitive"
6987 if scaling_descriptor
.get("scaling-config-action"):
6988 for scaling_config_action
in scaling_descriptor
[
6989 "scaling-config-action"
6992 scaling_config_action
.get("trigger") == "post-scale-in"
6993 and scaling_type
== "SCALE_IN"
6995 scaling_config_action
.get("trigger") == "post-scale-out"
6996 and scaling_type
== "SCALE_OUT"
6998 vnf_config_primitive
= scaling_config_action
[
6999 "vnf-config-primitive-name-ref"
7001 step
= db_nslcmop_update
[
7003 ] = "executing post-scale scaling-config-action '{}'".format(
7004 vnf_config_primitive
7007 vnfr_params
= {"VDU_SCALE_INFO": scaling_info
}
7008 if db_vnfr
.get("additionalParamsForVnf"):
7009 vnfr_params
.update(db_vnfr
["additionalParamsForVnf"])
7011 # look for primitive
7012 for config_primitive
in (
7013 get_configuration(db_vnfd
, db_vnfd
["id"]) or {}
7014 ).get("config-primitive", ()):
7015 if config_primitive
["name"] == vnf_config_primitive
:
7019 "Invalid vnfd descriptor at scaling-group-descriptor[name='{}']:scaling-config-"
7020 "action[vnf-config-primitive-name-ref='{}'] does not match any vnf-configuration:"
7021 "config-primitive".format(
7022 scaling_group
, vnf_config_primitive
7025 scale_process
= "VCA"
7026 db_nsr_update
["config-status"] = "configuring post-scaling"
7027 primitive_params
= self
._map
_primitive
_params
(
7028 config_primitive
, {}, vnfr_params
7031 # Post-scale retry check: Check if this sub-operation has been executed before
7032 op_index
= self
._check
_or
_add
_scale
_suboperation
(
7035 vnf_config_primitive
,
7039 if op_index
== self
.SUBOPERATION_STATUS_SKIP
:
7040 # Skip sub-operation
7041 result
= "COMPLETED"
7042 result_detail
= "Done"
7045 + "vnf_config_primitive={} Skipped sub-operation, result {} {}".format(
7046 vnf_config_primitive
, result
, result_detail
7050 if op_index
== self
.SUBOPERATION_STATUS_NEW
:
7051 # New sub-operation: Get index of this sub-operation
7053 len(db_nslcmop
.get("_admin", {}).get("operations"))
7058 + "vnf_config_primitive={} New sub-operation".format(
7059 vnf_config_primitive
7063 # retry: Get registered params for this existing sub-operation
7064 op
= db_nslcmop
.get("_admin", {}).get("operations", [])[
7067 vnf_index
= op
.get("member_vnf_index")
7068 vnf_config_primitive
= op
.get("primitive")
7069 primitive_params
= op
.get("primitive_params")
7072 + "vnf_config_primitive={} Sub-operation retry".format(
7073 vnf_config_primitive
7076 # Execute the primitive, either with new (first-time) or registered (reintent) args
7077 ee_descriptor_id
= config_primitive
.get(
7078 "execution-environment-ref"
7080 primitive_name
= config_primitive
.get(
7081 "execution-environment-primitive", vnf_config_primitive
7083 ee_id
, vca_type
= self
._look
_for
_deployed
_vca
(
7084 nsr_deployed
["VCA"],
7085 member_vnf_index
=vnf_index
,
7087 vdu_count_index
=None,
7088 ee_descriptor_id
=ee_descriptor_id
,
7090 result
, result_detail
= await self
._ns
_execute
_primitive
(
7099 + "vnf_config_primitive={} Done with result {} {}".format(
7100 vnf_config_primitive
, result
, result_detail
7103 # Update operationState = COMPLETED | FAILED
7104 self
._update
_suboperation
_status
(
7105 db_nslcmop
, op_index
, result
, result_detail
7108 if result
== "FAILED":
7109 raise LcmException(result_detail
)
7110 db_nsr_update
["config-status"] = old_config_status
7111 scale_process
= None
7116 ] = "" # "scaled {} {}".format(scaling_group, scaling_type)
7117 db_nsr_update
["operational-status"] = (
7119 if old_operational_status
== "failed"
7120 else old_operational_status
7122 db_nsr_update
["config-status"] = old_config_status
7125 ROclient
.ROClientException
,
7130 self
.logger
.error(logging_text
+ "Exit Exception {}".format(e
))
7132 except asyncio
.CancelledError
:
7134 logging_text
+ "Cancelled Exception while '{}'".format(step
)
7136 exc
= "Operation was cancelled"
7137 except Exception as e
:
7138 exc
= traceback
.format_exc()
7139 self
.logger
.critical(
7140 logging_text
+ "Exit Exception {} {}".format(type(e
).__name
__, e
),
7144 self
._write
_ns
_status
(
7147 current_operation
="IDLE",
7148 current_operation_id
=None,
7151 stage
[1] = "Waiting for instantiate pending tasks."
7152 self
.logger
.debug(logging_text
+ stage
[1])
7153 exc
= await self
._wait
_for
_tasks
(
7156 self
.timeout
.ns_deploy
,
7164 ] = error_description_nslcmop
= "FAILED {}: {}".format(step
, exc
)
7165 nslcmop_operation_state
= "FAILED"
7167 db_nsr_update
["operational-status"] = old_operational_status
7168 db_nsr_update
["config-status"] = old_config_status
7169 db_nsr_update
["detailed-status"] = ""
7171 if "VCA" in scale_process
:
7172 db_nsr_update
["config-status"] = "failed"
7173 if "RO" in scale_process
:
7174 db_nsr_update
["operational-status"] = "failed"
7177 ] = "FAILED scaling nslcmop={} {}: {}".format(
7178 nslcmop_id
, step
, exc
7181 error_description_nslcmop
= None
7182 nslcmop_operation_state
= "COMPLETED"
7183 db_nslcmop_update
["detailed-status"] = "Done"
7185 self
._write
_op
_status
(
7188 error_message
=error_description_nslcmop
,
7189 operation_state
=nslcmop_operation_state
,
7190 other_update
=db_nslcmop_update
,
7193 self
._write
_ns
_status
(
7196 current_operation
="IDLE",
7197 current_operation_id
=None,
7198 other_update
=db_nsr_update
,
7201 if nslcmop_operation_state
:
7205 "nslcmop_id": nslcmop_id
,
7206 "operationState": nslcmop_operation_state
,
7208 await self
.msg
.aiowrite("ns", "scaled", msg
)
7209 except Exception as e
:
7211 logging_text
+ "kafka_write notification Exception {}".format(e
)
7213 self
.logger
.debug(logging_text
+ "Exit")
7214 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_scale")
7216 async def _scale_kdu(
7217 self
, logging_text
, nsr_id
, nsr_deployed
, db_vnfd
, vca_id
, scaling_info
7219 _scaling_info
= scaling_info
.get("kdu-create") or scaling_info
.get("kdu-delete")
7220 for kdu_name
in _scaling_info
:
7221 for kdu_scaling_info
in _scaling_info
[kdu_name
]:
7222 deployed_kdu
, index
= get_deployed_kdu(
7223 nsr_deployed
, kdu_name
, kdu_scaling_info
["member-vnf-index"]
7225 cluster_uuid
= deployed_kdu
["k8scluster-uuid"]
7226 kdu_instance
= deployed_kdu
["kdu-instance"]
7227 kdu_model
= deployed_kdu
.get("kdu-model")
7228 scale
= int(kdu_scaling_info
["scale"])
7229 k8s_cluster_type
= kdu_scaling_info
["k8s-cluster-type"]
7232 "collection": "nsrs",
7233 "filter": {"_id": nsr_id
},
7234 "path": "_admin.deployed.K8s.{}".format(index
),
7237 step
= "scaling application {}".format(
7238 kdu_scaling_info
["resource-name"]
7240 self
.logger
.debug(logging_text
+ step
)
7242 if kdu_scaling_info
["type"] == "delete":
7243 kdu_config
= get_configuration(db_vnfd
, kdu_name
)
7246 and kdu_config
.get("terminate-config-primitive")
7247 and get_juju_ee_ref(db_vnfd
, kdu_name
) is None
7249 terminate_config_primitive_list
= kdu_config
.get(
7250 "terminate-config-primitive"
7252 terminate_config_primitive_list
.sort(
7253 key
=lambda val
: int(val
["seq"])
7257 terminate_config_primitive
7258 ) in terminate_config_primitive_list
:
7259 primitive_params_
= self
._map
_primitive
_params
(
7260 terminate_config_primitive
, {}, {}
7262 step
= "execute terminate config primitive"
7263 self
.logger
.debug(logging_text
+ step
)
7264 await asyncio
.wait_for(
7265 self
.k8scluster_map
[k8s_cluster_type
].exec_primitive(
7266 cluster_uuid
=cluster_uuid
,
7267 kdu_instance
=kdu_instance
,
7268 primitive_name
=terminate_config_primitive
["name"],
7269 params
=primitive_params_
,
7271 total_timeout
=self
.timeout
.primitive
,
7274 timeout
=self
.timeout
.primitive
7275 * self
.timeout
.primitive_outer_factor
,
7278 await asyncio
.wait_for(
7279 self
.k8scluster_map
[k8s_cluster_type
].scale(
7280 kdu_instance
=kdu_instance
,
7282 resource_name
=kdu_scaling_info
["resource-name"],
7283 total_timeout
=self
.timeout
.scale_on_error
,
7285 cluster_uuid
=cluster_uuid
,
7286 kdu_model
=kdu_model
,
7290 timeout
=self
.timeout
.scale_on_error
7291 * self
.timeout
.scale_on_error_outer_factor
,
7294 if kdu_scaling_info
["type"] == "create":
7295 kdu_config
= get_configuration(db_vnfd
, kdu_name
)
7298 and kdu_config
.get("initial-config-primitive")
7299 and get_juju_ee_ref(db_vnfd
, kdu_name
) is None
7301 initial_config_primitive_list
= kdu_config
.get(
7302 "initial-config-primitive"
7304 initial_config_primitive_list
.sort(
7305 key
=lambda val
: int(val
["seq"])
7308 for initial_config_primitive
in initial_config_primitive_list
:
7309 primitive_params_
= self
._map
_primitive
_params
(
7310 initial_config_primitive
, {}, {}
7312 step
= "execute initial config primitive"
7313 self
.logger
.debug(logging_text
+ step
)
7314 await asyncio
.wait_for(
7315 self
.k8scluster_map
[k8s_cluster_type
].exec_primitive(
7316 cluster_uuid
=cluster_uuid
,
7317 kdu_instance
=kdu_instance
,
7318 primitive_name
=initial_config_primitive
["name"],
7319 params
=primitive_params_
,
7326 async def _scale_ng_ro(
7327 self
, logging_text
, db_nsr
, db_nslcmop
, db_vnfr
, vdu_scaling_info
, stage
7329 nsr_id
= db_nslcmop
["nsInstanceId"]
7330 db_nsd
= self
.db
.get_one("nsds", {"_id": db_nsr
["nsd-id"]})
7333 # read from db: vnfd's for every vnf
7336 # for each vnf in ns, read vnfd
7337 for vnfr
in self
.db
.get_list("vnfrs", {"nsr-id-ref": nsr_id
}):
7338 db_vnfrs
[vnfr
["member-vnf-index-ref"]] = vnfr
7339 vnfd_id
= vnfr
["vnfd-id"] # vnfd uuid for this vnf
7340 # if we haven't this vnfd, read it from db
7341 if not find_in_list(db_vnfds
, lambda a_vnfd
: a_vnfd
["id"] == vnfd_id
):
7343 vnfd
= self
.db
.get_one("vnfds", {"_id": vnfd_id
})
7344 db_vnfds
.append(vnfd
)
7345 n2vc_key
= self
.n2vc
.get_public_key()
7346 n2vc_key_list
= [n2vc_key
]
7349 vdu_scaling_info
.get("vdu-create"),
7350 vdu_scaling_info
.get("vdu-delete"),
7353 # db_vnfr has been updated, update db_vnfrs to use it
7354 db_vnfrs
[db_vnfr
["member-vnf-index-ref"]] = db_vnfr
7355 await self
._instantiate
_ng
_ro
(
7365 start_deploy
=time(),
7366 timeout_ns_deploy
=self
.timeout
.ns_deploy
,
7368 if vdu_scaling_info
.get("vdu-delete"):
7370 db_vnfr
, None, vdu_scaling_info
["vdu-delete"], mark_delete
=False
7373 async def extract_prometheus_scrape_jobs(
7377 ee_config_descriptor
: dict,
7382 vnf_member_index
: str = "",
7384 vdu_index
: int = None,
7386 kdu_index
: int = None,
7388 """Method to extract prometheus scrape jobs from EE's Prometheus template job file
7389 This method will wait until the corresponding VDU or KDU is fully instantiated
7392 ee_id (str): Execution Environment ID
7393 artifact_path (str): Path where the EE's content is (including the Prometheus template file)
7394 ee_config_descriptor (dict): Execution Environment's configuration descriptor
7395 vnfr_id (str): VNFR ID where this EE applies
7396 nsr_id (str): NSR ID where this EE applies
7397 target_ip (str): VDU/KDU instance IP address
7398 element_type (str): NS or VNF or VDU or KDU
7399 vnf_member_index (str, optional): VNF index where this EE applies. Defaults to "".
7400 vdu_id (str, optional): VDU ID where this EE applies. Defaults to "".
7401 vdu_index (int, optional): VDU index where this EE applies. Defaults to None.
7402 kdu_name (str, optional): KDU name where this EE applies. Defaults to "".
7403 kdu_index (int, optional): KDU index where this EE applies. Defaults to None.
7406 LcmException: When the VDU or KDU instance was not found in an hour
7409 _type_: Prometheus jobs
7411 # default the vdur and kdur names to an empty string, to avoid any later
7412 # problem with Prometheus when the element type is not VDU or KDU
7416 # look if exist a file called 'prometheus*.j2' and
7417 artifact_content
= self
.fs
.dir_ls(artifact_path
)
7421 for f
in artifact_content
7422 if f
.startswith("prometheus") and f
.endswith(".j2")
7428 self
.logger
.debug("Artifact path{}".format(artifact_path
))
7429 self
.logger
.debug("job file{}".format(job_file
))
7430 with self
.fs
.file_open((artifact_path
, job_file
), "r") as f
:
7433 # obtain the VDUR or KDUR, if the element type is VDU or KDU
7434 if element_type
in ("VDU", "KDU"):
7435 for _
in range(360):
7436 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnfr_id
})
7437 if vdu_id
and vdu_index
is not None:
7441 for x
in get_iterable(db_vnfr
, "vdur")
7443 x
.get("vdu-id-ref") == vdu_id
7444 and x
.get("count-index") == vdu_index
7449 if vdur
.get("name"):
7450 vdur_name
= vdur
.get("name")
7452 if kdu_name
and kdu_index
is not None:
7456 for x
in get_iterable(db_vnfr
, "kdur")
7458 x
.get("kdu-name") == kdu_name
7459 and x
.get("count-index") == kdu_index
7464 if kdur
.get("name"):
7465 kdur_name
= kdur
.get("name")
7468 await asyncio
.sleep(10)
7470 if vdu_id
and vdu_index
is not None:
7472 f
"Timeout waiting VDU with name={vdu_id} and index={vdu_index} to be intantiated"
7474 if kdu_name
and kdu_index
is not None:
7476 f
"Timeout waiting KDU with name={kdu_name} and index={kdu_index} to be intantiated"
7479 if ee_id
is not None:
7480 _
, namespace
, helm_id
= get_ee_id_parts(
7482 ) # get namespace and EE gRPC service name
7483 host_name
= f
'{helm_id}-{ee_config_descriptor["metric-service"]}.{namespace}.svc' # svc_name.namespace.svc
7485 vnfr_id
= vnfr_id
.replace("-", "")
7487 "JOB_NAME": vnfr_id
,
7488 "TARGET_IP": target_ip
,
7489 "EXPORTER_POD_IP": host_name
,
7490 "EXPORTER_POD_PORT": host_port
,
7492 "VNF_MEMBER_INDEX": vnf_member_index
,
7493 "VDUR_NAME": vdur_name
,
7494 "KDUR_NAME": kdur_name
,
7495 "ELEMENT_TYPE": element_type
,
7498 metric_path
= ee_config_descriptor
["metric-path"]
7499 target_port
= ee_config_descriptor
["metric-port"]
7500 vnfr_id
= vnfr_id
.replace("-", "")
7502 "JOB_NAME": vnfr_id
,
7503 "TARGET_IP": target_ip
,
7504 "TARGET_PORT": target_port
,
7505 "METRIC_PATH": metric_path
,
7508 job_list
= parse_job(job_data
, variables
)
7509 # ensure job_name is using the vnfr_id. Adding the metadata nsr_id
7510 for job
in job_list
:
7512 not isinstance(job
.get("job_name"), str)
7513 or vnfr_id
not in job
["job_name"]
7515 job
["job_name"] = vnfr_id
+ "_" + str(SystemRandom().randint(1, 10000))
7516 job
["nsr_id"] = nsr_id
7517 job
["vnfr_id"] = vnfr_id
7520 async def rebuild_start_stop(
7521 self
, nsr_id
, nslcmop_id
, vnf_id
, additional_param
, operation_type
7523 logging_text
= "Task ns={} {}={} ".format(nsr_id
, operation_type
, nslcmop_id
)
7524 self
.logger
.info(logging_text
+ "Enter")
7525 stage
= ["Preparing the environment", ""]
7526 # database nsrs record
7530 # in case of error, indicates what part of scale was failed to put nsr at error status
7531 start_deploy
= time()
7533 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnf_id
})
7534 vim_account_id
= db_vnfr
.get("vim-account-id")
7535 vim_info_key
= "vim:" + vim_account_id
7536 vdu_id
= additional_param
["vdu_id"]
7537 vdurs
= [item
for item
in db_vnfr
["vdur"] if item
["vdu-id-ref"] == vdu_id
]
7538 vdur
= find_in_list(
7539 vdurs
, lambda vdu
: vdu
["count-index"] == additional_param
["count-index"]
7542 vdu_vim_name
= vdur
["name"]
7543 vim_vm_id
= vdur
["vim_info"][vim_info_key
]["vim_id"]
7544 target_vim
, _
= next(k_v
for k_v
in vdur
["vim_info"].items())
7546 raise LcmException("Target vdu is not found")
7547 self
.logger
.info("vdu_vim_name >> {} ".format(vdu_vim_name
))
7548 # wait for any previous tasks in process
7549 stage
[1] = "Waiting for previous operations to terminate"
7550 self
.logger
.info(stage
[1])
7551 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
7553 stage
[1] = "Reading from database."
7554 self
.logger
.info(stage
[1])
7555 self
._write
_ns
_status
(
7558 current_operation
=operation_type
.upper(),
7559 current_operation_id
=nslcmop_id
,
7561 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
, queuePosition
=0)
7564 stage
[1] = "Getting nsr={} from db.".format(nsr_id
)
7565 db_nsr_update
["operational-status"] = operation_type
7566 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
7570 "vim_vm_id": vim_vm_id
,
7572 "vdu_index": additional_param
["count-index"],
7573 "vdu_id": vdur
["id"],
7574 "target_vim": target_vim
,
7575 "vim_account_id": vim_account_id
,
7578 stage
[1] = "Sending rebuild request to RO... {}".format(desc
)
7579 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
, queuePosition
=0)
7580 self
.logger
.info("ro nsr id: {}".format(nsr_id
))
7581 result_dict
= await self
.RO
.operate(nsr_id
, desc
, operation_type
)
7582 self
.logger
.info("response from RO: {}".format(result_dict
))
7583 action_id
= result_dict
["action_id"]
7584 await self
._wait
_ng
_ro
(
7589 self
.timeout
.operate
,
7591 "start_stop_rebuild",
7593 return "COMPLETED", "Done"
7594 except (ROclient
.ROClientException
, DbException
, LcmException
) as e
:
7595 self
.logger
.error("Exit Exception {}".format(e
))
7597 except asyncio
.CancelledError
:
7598 self
.logger
.error("Cancelled Exception while '{}'".format(stage
))
7599 exc
= "Operation was cancelled"
7600 except Exception as e
:
7601 exc
= traceback
.format_exc()
7602 self
.logger
.critical(
7603 "Exit Exception {} {}".format(type(e
).__name
__, e
), exc_info
=True
7605 return "FAILED", "Error in operate VNF {}".format(exc
)
7607 async def migrate(self
, nsr_id
, nslcmop_id
):
7609 Migrate VNFs and VDUs instances in a NS
7611 :param: nsr_id: NS Instance ID
7612 :param: nslcmop_id: nslcmop ID of migrate
7615 # Try to lock HA task here
7616 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
7617 if not task_is_locked_by_me
:
7619 logging_text
= "Task ns={} migrate ".format(nsr_id
)
7620 self
.logger
.debug(logging_text
+ "Enter")
7621 # get all needed from database
7623 db_nslcmop_update
= {}
7624 nslcmop_operation_state
= None
7628 # in case of error, indicates what part of scale was failed to put nsr at error status
7629 start_deploy
= time()
7632 # wait for any previous tasks in process
7633 step
= "Waiting for previous operations to terminate"
7634 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
7636 self
._write
_ns
_status
(
7639 current_operation
="MIGRATING",
7640 current_operation_id
=nslcmop_id
,
7642 step
= "Getting nslcmop from database"
7644 step
+ " after having waited for previous tasks to be completed"
7646 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
7647 migrate_params
= db_nslcmop
.get("operationParams")
7650 target
.update(migrate_params
)
7651 desc
= await self
.RO
.migrate(nsr_id
, target
)
7652 self
.logger
.debug("RO return > {}".format(desc
))
7653 action_id
= desc
["action_id"]
7654 await self
._wait
_ng
_ro
(
7659 self
.timeout
.migrate
,
7660 operation
="migrate",
7662 except (ROclient
.ROClientException
, DbException
, LcmException
) as e
:
7663 self
.logger
.error("Exit Exception {}".format(e
))
7665 except asyncio
.CancelledError
:
7666 self
.logger
.error("Cancelled Exception while '{}'".format(step
))
7667 exc
= "Operation was cancelled"
7668 except Exception as e
:
7669 exc
= traceback
.format_exc()
7670 self
.logger
.critical(
7671 "Exit Exception {} {}".format(type(e
).__name
__, e
), exc_info
=True
7674 self
._write
_ns
_status
(
7677 current_operation
="IDLE",
7678 current_operation_id
=None,
7681 db_nslcmop_update
["detailed-status"] = "FAILED {}: {}".format(step
, exc
)
7682 nslcmop_operation_state
= "FAILED"
7684 nslcmop_operation_state
= "COMPLETED"
7685 db_nslcmop_update
["detailed-status"] = "Done"
7686 db_nsr_update
["detailed-status"] = "Done"
7688 self
._write
_op
_status
(
7692 operation_state
=nslcmop_operation_state
,
7693 other_update
=db_nslcmop_update
,
7695 if nslcmop_operation_state
:
7699 "nslcmop_id": nslcmop_id
,
7700 "operationState": nslcmop_operation_state
,
7702 await self
.msg
.aiowrite("ns", "migrated", msg
)
7703 except Exception as e
:
7705 logging_text
+ "kafka_write notification Exception {}".format(e
)
7707 self
.logger
.debug(logging_text
+ "Exit")
7708 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_migrate")
7710 async def heal(self
, nsr_id
, nslcmop_id
):
7714 :param nsr_id: ns instance to heal
7715 :param nslcmop_id: operation to run
7719 # Try to lock HA task here
7720 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
7721 if not task_is_locked_by_me
:
7724 logging_text
= "Task ns={} heal={} ".format(nsr_id
, nslcmop_id
)
7725 stage
= ["", "", ""]
7726 tasks_dict_info
= {}
7727 # ^ stage, step, VIM progress
7728 self
.logger
.debug(logging_text
+ "Enter")
7729 # get all needed from database
7731 db_nslcmop_update
= {}
7733 db_vnfrs
= {} # vnf's info indexed by _id
7735 old_operational_status
= ""
7736 old_config_status
= ""
7739 # wait for any previous tasks in process
7740 step
= "Waiting for previous operations to terminate"
7741 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
7742 self
._write
_ns
_status
(
7745 current_operation
="HEALING",
7746 current_operation_id
=nslcmop_id
,
7749 step
= "Getting nslcmop from database"
7751 step
+ " after having waited for previous tasks to be completed"
7753 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
7755 step
= "Getting nsr from database"
7756 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
7757 old_operational_status
= db_nsr
["operational-status"]
7758 old_config_status
= db_nsr
["config-status"]
7761 "_admin.deployed.RO.operational-status": "healing",
7763 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
7765 step
= "Sending heal order to VIM"
7767 logging_text
=logging_text
,
7769 db_nslcmop
=db_nslcmop
,
7774 stage
[1] = "Getting nsd={} from db.".format(db_nsr
["nsd-id"])
7775 self
.logger
.debug(logging_text
+ stage
[1])
7776 nsd
= self
.db
.get_one("nsds", {"_id": db_nsr
["nsd-id"]})
7777 self
.fs
.sync(db_nsr
["nsd-id"])
7779 # read from db: vnfr's of this ns
7780 step
= "Getting vnfrs from db"
7781 db_vnfrs_list
= self
.db
.get_list("vnfrs", {"nsr-id-ref": nsr_id
})
7782 for vnfr
in db_vnfrs_list
:
7783 db_vnfrs
[vnfr
["_id"]] = vnfr
7784 self
.logger
.debug("ns.heal db_vnfrs={}".format(db_vnfrs
))
7786 # Check for each target VNF
7787 target_list
= db_nslcmop
.get("operationParams", {}).get("healVnfData", {})
7788 for target_vnf
in target_list
:
7789 # Find this VNF in the list from DB
7790 vnfr_id
= target_vnf
.get("vnfInstanceId", None)
7792 db_vnfr
= db_vnfrs
[vnfr_id
]
7793 vnfd_id
= db_vnfr
.get("vnfd-id")
7794 vnfd_ref
= db_vnfr
.get("vnfd-ref")
7795 vnfd
= self
.db
.get_one("vnfds", {"_id": vnfd_id
})
7796 base_folder
= vnfd
["_admin"]["storage"]
7801 nsi_id
= None # TODO put nsi_id when this nsr belongs to a NSI
7802 member_vnf_index
= db_vnfr
.get("member-vnf-index-ref")
7804 # Check each target VDU and deploy N2VC
7805 target_vdu_list
= target_vnf
.get("additionalParams", {}).get(
7808 if not target_vdu_list
:
7809 # Codigo nuevo para crear diccionario
7810 target_vdu_list
= []
7811 for existing_vdu
in db_vnfr
.get("vdur"):
7812 vdu_name
= existing_vdu
.get("vdu-name", None)
7813 vdu_index
= existing_vdu
.get("count-index", 0)
7814 vdu_run_day1
= target_vnf
.get("additionalParams", {}).get(
7817 vdu_to_be_healed
= {
7819 "count-index": vdu_index
,
7820 "run-day1": vdu_run_day1
,
7822 target_vdu_list
.append(vdu_to_be_healed
)
7823 for target_vdu
in target_vdu_list
:
7824 deploy_params_vdu
= target_vdu
7825 # Set run-day1 vnf level value if not vdu level value exists
7826 if not deploy_params_vdu
.get("run-day1") and target_vnf
.get(
7827 "additionalParams", {}
7829 deploy_params_vdu
["run-day1"] = target_vnf
[
7832 vdu_name
= target_vdu
.get("vdu-id", None)
7833 # TODO: Get vdu_id from vdud.
7835 # For multi instance VDU count-index is mandatory
7836 # For single session VDU count-indes is 0
7837 vdu_index
= target_vdu
.get("count-index", 0)
7839 # n2vc_redesign STEP 3 to 6 Deploy N2VC
7840 stage
[1] = "Deploying Execution Environments."
7841 self
.logger
.debug(logging_text
+ stage
[1])
7843 # VNF Level charm. Normal case when proxy charms.
7844 # If target instance is management machine continue with actions: recreate EE for native charms or reinject juju key for proxy charms.
7845 descriptor_config
= get_configuration(vnfd
, vnfd_ref
)
7846 if descriptor_config
:
7847 # Continue if healed machine is management machine
7848 vnf_ip_address
= db_vnfr
.get("ip-address")
7849 target_instance
= None
7850 for instance
in db_vnfr
.get("vdur", None):
7852 instance
["vdu-name"] == vdu_name
7853 and instance
["count-index"] == vdu_index
7855 target_instance
= instance
7857 if vnf_ip_address
== target_instance
.get("ip-address"):
7859 logging_text
=logging_text
7860 + "member_vnf_index={}, vdu_name={}, vdu_index={} ".format(
7861 member_vnf_index
, vdu_name
, vdu_index
7865 nslcmop_id
=nslcmop_id
,
7871 member_vnf_index
=member_vnf_index
,
7874 deploy_params
=deploy_params_vdu
,
7875 descriptor_config
=descriptor_config
,
7876 base_folder
=base_folder
,
7877 task_instantiation_info
=tasks_dict_info
,
7881 # VDU Level charm. Normal case with native charms.
7882 descriptor_config
= get_configuration(vnfd
, vdu_name
)
7883 if descriptor_config
:
7885 logging_text
=logging_text
7886 + "member_vnf_index={}, vdu_name={}, vdu_index={} ".format(
7887 member_vnf_index
, vdu_name
, vdu_index
7891 nslcmop_id
=nslcmop_id
,
7897 member_vnf_index
=member_vnf_index
,
7898 vdu_index
=vdu_index
,
7900 deploy_params
=deploy_params_vdu
,
7901 descriptor_config
=descriptor_config
,
7902 base_folder
=base_folder
,
7903 task_instantiation_info
=tasks_dict_info
,
7908 ROclient
.ROClientException
,
7913 self
.logger
.error(logging_text
+ "Exit Exception {}".format(e
))
7915 except asyncio
.CancelledError
:
7917 logging_text
+ "Cancelled Exception while '{}'".format(step
)
7919 exc
= "Operation was cancelled"
7920 except Exception as e
:
7921 exc
= traceback
.format_exc()
7922 self
.logger
.critical(
7923 logging_text
+ "Exit Exception {} {}".format(type(e
).__name
__, e
),
7928 stage
[1] = "Waiting for healing pending tasks."
7929 self
.logger
.debug(logging_text
+ stage
[1])
7930 exc
= await self
._wait
_for
_tasks
(
7933 self
.timeout
.ns_deploy
,
7941 ] = error_description_nslcmop
= "FAILED {}: {}".format(step
, exc
)
7942 nslcmop_operation_state
= "FAILED"
7944 db_nsr_update
["operational-status"] = old_operational_status
7945 db_nsr_update
["config-status"] = old_config_status
7948 ] = "FAILED healing nslcmop={} {}: {}".format(nslcmop_id
, step
, exc
)
7949 for task
, task_name
in tasks_dict_info
.items():
7950 if not task
.done() or task
.cancelled() or task
.exception():
7951 if task_name
.startswith(self
.task_name_deploy_vca
):
7952 # A N2VC task is pending
7953 db_nsr_update
["config-status"] = "failed"
7955 # RO task is pending
7956 db_nsr_update
["operational-status"] = "failed"
7958 error_description_nslcmop
= None
7959 nslcmop_operation_state
= "COMPLETED"
7960 db_nslcmop_update
["detailed-status"] = "Done"
7961 db_nsr_update
["detailed-status"] = "Done"
7962 db_nsr_update
["operational-status"] = "running"
7963 db_nsr_update
["config-status"] = "configured"
7965 self
._write
_op
_status
(
7968 error_message
=error_description_nslcmop
,
7969 operation_state
=nslcmop_operation_state
,
7970 other_update
=db_nslcmop_update
,
7973 self
._write
_ns
_status
(
7976 current_operation
="IDLE",
7977 current_operation_id
=None,
7978 other_update
=db_nsr_update
,
7981 if nslcmop_operation_state
:
7985 "nslcmop_id": nslcmop_id
,
7986 "operationState": nslcmop_operation_state
,
7988 await self
.msg
.aiowrite("ns", "healed", msg
)
7989 except Exception as e
:
7991 logging_text
+ "kafka_write notification Exception {}".format(e
)
7993 self
.logger
.debug(logging_text
+ "Exit")
7994 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_heal")
8005 :param logging_text: preffix text to use at logging
8006 :param nsr_id: nsr identity
8007 :param db_nslcmop: database content of ns operation, in this case, 'instantiate'
8008 :param stage: list with 3 items: [general stage, tasks, vim_specific]. This task will write over vim_specific
8009 :return: None or exception
8012 def get_vim_account(vim_account_id
):
8014 if vim_account_id
in db_vims
:
8015 return db_vims
[vim_account_id
]
8016 db_vim
= self
.db
.get_one("vim_accounts", {"_id": vim_account_id
})
8017 db_vims
[vim_account_id
] = db_vim
8022 ns_params
= db_nslcmop
.get("operationParams")
8023 if ns_params
and ns_params
.get("timeout_ns_heal"):
8024 timeout_ns_heal
= ns_params
["timeout_ns_heal"]
8026 timeout_ns_heal
= self
.timeout
.ns_heal
8030 nslcmop_id
= db_nslcmop
["_id"]
8032 "action_id": nslcmop_id
,
8034 self
.logger
.warning(
8035 "db_nslcmop={} and timeout_ns_heal={}".format(
8036 db_nslcmop
, timeout_ns_heal
8039 target
.update(db_nslcmop
.get("operationParams", {}))
8041 self
.logger
.debug("Send to RO > nsr_id={} target={}".format(nsr_id
, target
))
8042 desc
= await self
.RO
.recreate(nsr_id
, target
)
8043 self
.logger
.debug("RO return > {}".format(desc
))
8044 action_id
= desc
["action_id"]
8045 # waits for RO to complete because Reinjecting juju key at ro can find VM in state Deleted
8046 await self
._wait
_ng
_ro
(
8053 operation
="healing",
8058 "_admin.deployed.RO.operational-status": "running",
8059 "detailed-status": " ".join(stage
),
8061 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
8062 self
._write
_op
_status
(nslcmop_id
, stage
)
8064 logging_text
+ "ns healed at RO. RO_id={}".format(action_id
)
8067 except Exception as e
:
8068 stage
[2] = "ERROR healing at VIM"
8069 # self.set_vnfr_at_error(db_vnfrs, str(e))
8071 "Error healing at VIM {}".format(e
),
8072 exc_info
=not isinstance(
8075 ROclient
.ROClientException
,
8101 task_instantiation_info
,
8104 # launch instantiate_N2VC in a asyncio task and register task object
8105 # Look where information of this charm is at database <nsrs>._admin.deployed.VCA
8106 # if not found, create one entry and update database
8107 # fill db_nsr._admin.deployed.VCA.<index>
8110 logging_text
+ "_deploy_n2vc vnfd_id={}, vdu_id={}".format(vnfd_id
, vdu_id
)
8114 get_charm_name
= False
8115 if "execution-environment-list" in descriptor_config
:
8116 ee_list
= descriptor_config
.get("execution-environment-list", [])
8117 elif "juju" in descriptor_config
:
8118 ee_list
= [descriptor_config
] # ns charms
8119 if "execution-environment-list" not in descriptor_config
:
8120 # charm name is only required for ns charms
8121 get_charm_name
= True
8122 else: # other types as script are not supported
8125 for ee_item
in ee_list
:
8128 + "_deploy_n2vc ee_item juju={}, helm={}".format(
8129 ee_item
.get("juju"), ee_item
.get("helm-chart")
8132 ee_descriptor_id
= ee_item
.get("id")
8133 if ee_item
.get("juju"):
8134 vca_name
= ee_item
["juju"].get("charm")
8136 charm_name
= self
.find_charm_name(db_nsr
, str(vca_name
))
8139 if ee_item
["juju"].get("charm") is not None
8142 if ee_item
["juju"].get("cloud") == "k8s":
8143 vca_type
= "k8s_proxy_charm"
8144 elif ee_item
["juju"].get("proxy") is False:
8145 vca_type
= "native_charm"
8146 elif ee_item
.get("helm-chart"):
8147 vca_name
= ee_item
["helm-chart"]
8148 vca_type
= "helm-v3"
8151 logging_text
+ "skipping non juju neither charm configuration"
8156 for vca_index
, vca_deployed
in enumerate(
8157 db_nsr
["_admin"]["deployed"]["VCA"]
8159 if not vca_deployed
:
8162 vca_deployed
.get("member-vnf-index") == member_vnf_index
8163 and vca_deployed
.get("vdu_id") == vdu_id
8164 and vca_deployed
.get("kdu_name") == kdu_name
8165 and vca_deployed
.get("vdu_count_index", 0) == vdu_index
8166 and vca_deployed
.get("ee_descriptor_id") == ee_descriptor_id
8170 # not found, create one.
8172 "ns" if not member_vnf_index
else "vnf/{}".format(member_vnf_index
)
8175 target
+= "/vdu/{}/{}".format(vdu_id
, vdu_index
or 0)
8177 target
+= "/kdu/{}".format(kdu_name
)
8179 "target_element": target
,
8180 # ^ target_element will replace member-vnf-index, kdu_name, vdu_id ... in a single string
8181 "member-vnf-index": member_vnf_index
,
8183 "kdu_name": kdu_name
,
8184 "vdu_count_index": vdu_index
,
8185 "operational-status": "init", # TODO revise
8186 "detailed-status": "", # TODO revise
8187 "step": "initial-deploy", # TODO revise
8189 "vdu_name": vdu_name
,
8191 "ee_descriptor_id": ee_descriptor_id
,
8192 "charm_name": charm_name
,
8196 # create VCA and configurationStatus in db
8198 "_admin.deployed.VCA.{}".format(vca_index
): vca_deployed
,
8199 "configurationStatus.{}".format(vca_index
): dict(),
8201 self
.update_db_2("nsrs", nsr_id
, db_dict
)
8203 db_nsr
["_admin"]["deployed"]["VCA"].append(vca_deployed
)
8205 self
.logger
.debug("N2VC > NSR_ID > {}".format(nsr_id
))
8206 self
.logger
.debug("N2VC > DB_NSR > {}".format(db_nsr
))
8207 self
.logger
.debug("N2VC > VCA_DEPLOYED > {}".format(vca_deployed
))
8210 task_n2vc
= asyncio
.ensure_future(
8212 logging_text
=logging_text
,
8213 vca_index
=vca_index
,
8219 vdu_index
=vdu_index
,
8220 deploy_params
=deploy_params
,
8221 config_descriptor
=descriptor_config
,
8222 base_folder
=base_folder
,
8223 nslcmop_id
=nslcmop_id
,
8227 ee_config_descriptor
=ee_item
,
8230 self
.lcm_tasks
.register(
8234 "instantiate_N2VC-{}".format(vca_index
),
8237 task_instantiation_info
[
8239 ] = self
.task_name_deploy_vca
+ " {}.{}".format(
8240 member_vnf_index
or "", vdu_id
or ""
8243 async def heal_N2VC(
8260 ee_config_descriptor
,
8262 nsr_id
= db_nsr
["_id"]
8263 db_update_entry
= "_admin.deployed.VCA.{}.".format(vca_index
)
8264 vca_deployed_list
= db_nsr
["_admin"]["deployed"]["VCA"]
8265 vca_deployed
= db_nsr
["_admin"]["deployed"]["VCA"][vca_index
]
8266 osm_config
= {"osm": {"ns_id": db_nsr
["_id"]}}
8268 "collection": "nsrs",
8269 "filter": {"_id": nsr_id
},
8270 "path": db_update_entry
,
8275 element_under_configuration
= nsr_id
8279 vnfr_id
= db_vnfr
["_id"]
8280 osm_config
["osm"]["vnf_id"] = vnfr_id
8282 namespace
= "{nsi}.{ns}".format(nsi
=nsi_id
if nsi_id
else "", ns
=nsr_id
)
8284 if vca_type
== "native_charm":
8287 index_number
= vdu_index
or 0
8290 element_type
= "VNF"
8291 element_under_configuration
= vnfr_id
8292 namespace
+= ".{}-{}".format(vnfr_id
, index_number
)
8294 namespace
+= ".{}-{}".format(vdu_id
, index_number
)
8295 element_type
= "VDU"
8296 element_under_configuration
= "{}-{}".format(vdu_id
, index_number
)
8297 osm_config
["osm"]["vdu_id"] = vdu_id
8299 namespace
+= ".{}".format(kdu_name
)
8300 element_type
= "KDU"
8301 element_under_configuration
= kdu_name
8302 osm_config
["osm"]["kdu_name"] = kdu_name
8305 if base_folder
["pkg-dir"]:
8306 artifact_path
= "{}/{}/{}/{}".format(
8307 base_folder
["folder"],
8308 base_folder
["pkg-dir"],
8311 in ("native_charm", "lxc_proxy_charm", "k8s_proxy_charm")
8316 artifact_path
= "{}/Scripts/{}/{}/".format(
8317 base_folder
["folder"],
8320 in ("native_charm", "lxc_proxy_charm", "k8s_proxy_charm")
8325 self
.logger
.debug("Artifact path > {}".format(artifact_path
))
8327 # get initial_config_primitive_list that applies to this element
8328 initial_config_primitive_list
= config_descriptor
.get(
8329 "initial-config-primitive"
8333 "Initial config primitive list > {}".format(
8334 initial_config_primitive_list
8338 # add config if not present for NS charm
8339 ee_descriptor_id
= ee_config_descriptor
.get("id")
8340 self
.logger
.debug("EE Descriptor > {}".format(ee_descriptor_id
))
8341 initial_config_primitive_list
= get_ee_sorted_initial_config_primitive_list(
8342 initial_config_primitive_list
, vca_deployed
, ee_descriptor_id
8346 "Initial config primitive list #2 > {}".format(
8347 initial_config_primitive_list
8350 # n2vc_redesign STEP 3.1
8351 # find old ee_id if exists
8352 ee_id
= vca_deployed
.get("ee_id")
8354 vca_id
= self
.get_vca_id(db_vnfr
, db_nsr
)
8355 # create or register execution environment in VCA. Only for native charms when healing
8356 if vca_type
== "native_charm":
8357 step
= "Waiting to VM being up and getting IP address"
8358 self
.logger
.debug(logging_text
+ step
)
8359 rw_mgmt_ip
= await self
.wait_vm_up_insert_key_ro(
8368 credentials
= {"hostname": rw_mgmt_ip
}
8370 username
= deep_get(
8371 config_descriptor
, ("config-access", "ssh-access", "default-user")
8373 # TODO remove this when changes on IM regarding config-access:ssh-access:default-user were
8374 # merged. Meanwhile let's get username from initial-config-primitive
8375 if not username
and initial_config_primitive_list
:
8376 for config_primitive
in initial_config_primitive_list
:
8377 for param
in config_primitive
.get("parameter", ()):
8378 if param
["name"] == "ssh-username":
8379 username
= param
["value"]
8383 "Cannot determine the username neither with 'initial-config-primitive' nor with "
8384 "'config-access.ssh-access.default-user'"
8386 credentials
["username"] = username
8388 # n2vc_redesign STEP 3.2
8389 # TODO: Before healing at RO it is needed to destroy native charm units to be deleted.
8390 self
._write
_configuration
_status
(
8392 vca_index
=vca_index
,
8393 status
="REGISTERING",
8394 element_under_configuration
=element_under_configuration
,
8395 element_type
=element_type
,
8398 step
= "register execution environment {}".format(credentials
)
8399 self
.logger
.debug(logging_text
+ step
)
8400 ee_id
= await self
.vca_map
[vca_type
].register_execution_environment(
8401 credentials
=credentials
,
8402 namespace
=namespace
,
8407 # update ee_id en db
8409 "_admin.deployed.VCA.{}.ee_id".format(vca_index
): ee_id
,
8411 self
.update_db_2("nsrs", nsr_id
, db_dict_ee_id
)
8413 # for compatibility with MON/POL modules, the need model and application name at database
8414 # TODO ask MON/POL if needed to not assuming anymore the format "model_name.application_name"
8415 # Not sure if this need to be done when healing
8417 ee_id_parts = ee_id.split(".")
8418 db_nsr_update = {db_update_entry + "ee_id": ee_id}
8419 if len(ee_id_parts) >= 2:
8420 model_name = ee_id_parts[0]
8421 application_name = ee_id_parts[1]
8422 db_nsr_update[db_update_entry + "model"] = model_name
8423 db_nsr_update[db_update_entry + "application"] = application_name
8426 # n2vc_redesign STEP 3.3
8427 # Install configuration software. Only for native charms.
8428 step
= "Install configuration Software"
8430 self
._write
_configuration
_status
(
8432 vca_index
=vca_index
,
8433 status
="INSTALLING SW",
8434 element_under_configuration
=element_under_configuration
,
8435 element_type
=element_type
,
8436 # other_update=db_nsr_update,
8440 # TODO check if already done
8441 self
.logger
.debug(logging_text
+ step
)
8443 if vca_type
== "native_charm":
8444 config_primitive
= next(
8445 (p
for p
in initial_config_primitive_list
if p
["name"] == "config"),
8448 if config_primitive
:
8449 config
= self
._map
_primitive
_params
(
8450 config_primitive
, {}, deploy_params
8452 await self
.vca_map
[vca_type
].install_configuration_sw(
8454 artifact_path
=artifact_path
,
8462 # write in db flag of configuration_sw already installed
8464 "nsrs", nsr_id
, {db_update_entry
+ "config_sw_installed": True}
8467 # Not sure if this need to be done when healing
8469 # add relations for this VCA (wait for other peers related with this VCA)
8470 await self._add_vca_relations(
8471 logging_text=logging_text,
8474 vca_index=vca_index,
8478 # if SSH access is required, then get execution environment SSH public
8479 # if native charm we have waited already to VM be UP
8480 if vca_type
in ("k8s_proxy_charm", "lxc_proxy_charm", "helm-v3"):
8483 # self.logger.debug("get ssh key block")
8485 config_descriptor
, ("config-access", "ssh-access", "required")
8487 # self.logger.debug("ssh key needed")
8488 # Needed to inject a ssh key
8491 ("config-access", "ssh-access", "default-user"),
8493 step
= "Install configuration Software, getting public ssh key"
8494 pub_key
= await self
.vca_map
[vca_type
].get_ee_ssh_public__key(
8495 ee_id
=ee_id
, db_dict
=db_dict
, vca_id
=vca_id
8498 step
= "Insert public key into VM user={} ssh_key={}".format(
8502 # self.logger.debug("no need to get ssh key")
8503 step
= "Waiting to VM being up and getting IP address"
8504 self
.logger
.debug(logging_text
+ step
)
8506 # n2vc_redesign STEP 5.1
8507 # wait for RO (ip-address) Insert pub_key into VM
8508 # IMPORTANT: We need do wait for RO to complete healing operation.
8509 await self
._wait
_heal
_ro
(nsr_id
, self
.timeout
.ns_heal
)
8512 rw_mgmt_ip
= await self
.wait_kdu_up(
8513 logging_text
, nsr_id
, vnfr_id
, kdu_name
8516 rw_mgmt_ip
= await self
.wait_vm_up_insert_key_ro(
8526 rw_mgmt_ip
= None # This is for a NS configuration
8528 self
.logger
.debug(logging_text
+ " VM_ip_address={}".format(rw_mgmt_ip
))
8530 # store rw_mgmt_ip in deploy params for later replacement
8531 deploy_params
["rw_mgmt_ip"] = rw_mgmt_ip
8534 # get run-day1 operation parameter
8535 runDay1
= deploy_params
.get("run-day1", False)
8537 "Healing vnf={}, vdu={}, runDay1 ={}".format(vnfr_id
, vdu_id
, runDay1
)
8540 # n2vc_redesign STEP 6 Execute initial config primitive
8541 step
= "execute initial config primitive"
8543 # wait for dependent primitives execution (NS -> VNF -> VDU)
8544 if initial_config_primitive_list
:
8545 await self
._wait
_dependent
_n
2vc
(
8546 nsr_id
, vca_deployed_list
, vca_index
8549 # stage, in function of element type: vdu, kdu, vnf or ns
8550 my_vca
= vca_deployed_list
[vca_index
]
8551 if my_vca
.get("vdu_id") or my_vca
.get("kdu_name"):
8553 stage
[0] = "Stage 3/5: running Day-1 primitives for VDU."
8554 elif my_vca
.get("member-vnf-index"):
8556 stage
[0] = "Stage 4/5: running Day-1 primitives for VNF."
8559 stage
[0] = "Stage 5/5: running Day-1 primitives for NS."
8561 self
._write
_configuration
_status
(
8562 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="EXECUTING PRIMITIVE"
8565 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
)
8567 check_if_terminated_needed
= True
8568 for initial_config_primitive
in initial_config_primitive_list
:
8569 # adding information on the vca_deployed if it is a NS execution environment
8570 if not vca_deployed
["member-vnf-index"]:
8571 deploy_params
["ns_config_info"] = json
.dumps(
8572 self
._get
_ns
_config
_info
(nsr_id
)
8574 # TODO check if already done
8575 primitive_params_
= self
._map
_primitive
_params
(
8576 initial_config_primitive
, {}, deploy_params
8579 step
= "execute primitive '{}' params '{}'".format(
8580 initial_config_primitive
["name"], primitive_params_
8582 self
.logger
.debug(logging_text
+ step
)
8583 await self
.vca_map
[vca_type
].exec_primitive(
8585 primitive_name
=initial_config_primitive
["name"],
8586 params_dict
=primitive_params_
,
8591 # Once some primitive has been exec, check and write at db if it needs to exec terminated primitives
8592 if check_if_terminated_needed
:
8593 if config_descriptor
.get("terminate-config-primitive"):
8597 {db_update_entry
+ "needed_terminate": True},
8599 check_if_terminated_needed
= False
8601 # TODO register in database that primitive is done
8603 # STEP 7 Configure metrics
8604 # Not sure if this need to be done when healing
8606 if vca_type == "helm" or vca_type == "helm-v3":
8607 prometheus_jobs = await self.extract_prometheus_scrape_jobs(
8609 artifact_path=artifact_path,
8610 ee_config_descriptor=ee_config_descriptor,
8613 target_ip=rw_mgmt_ip,
8619 {db_update_entry + "prometheus_jobs": prometheus_jobs},
8622 for job in prometheus_jobs:
8625 {"job_name": job["job_name"]},
8628 fail_on_empty=False,
8632 step
= "instantiated at VCA"
8633 self
.logger
.debug(logging_text
+ step
)
8635 self
._write
_configuration
_status
(
8636 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="READY"
8639 except Exception as e
: # TODO not use Exception but N2VC exception
8640 # self.update_db_2("nsrs", nsr_id, {db_update_entry + "instantiation": "FAILED"})
8642 e
, (DbException
, N2VCException
, LcmException
, asyncio
.CancelledError
)
8645 "Exception while {} : {}".format(step
, e
), exc_info
=True
8647 self
._write
_configuration
_status
(
8648 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="BROKEN"
8650 raise LcmException("{} {}".format(step
, e
)) from e
8652 async def _wait_heal_ro(
8658 while time() <= start_time
+ timeout
:
8659 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
8660 operational_status_ro
= db_nsr
["_admin"]["deployed"]["RO"][
8661 "operational-status"
8663 self
.logger
.debug("Wait Heal RO > {}".format(operational_status_ro
))
8664 if operational_status_ro
!= "healing":
8666 await asyncio
.sleep(15)
8667 else: # timeout_ns_deploy
8668 raise NgRoException("Timeout waiting ns to deploy")
8670 async def vertical_scale(self
, nsr_id
, nslcmop_id
):
8672 Vertical Scale the VDUs in a NS
8674 :param: nsr_id: NS Instance ID
8675 :param: nslcmop_id: nslcmop ID of migrate
8678 # Try to lock HA task here
8679 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
8680 if not task_is_locked_by_me
:
8682 logging_text
= "Task ns={} vertical scale ".format(nsr_id
)
8683 self
.logger
.debug(logging_text
+ "Enter")
8684 # get all needed from database
8686 db_nslcmop_update
= {}
8687 nslcmop_operation_state
= None
8691 # in case of error, indicates what part of scale was failed to put nsr at error status
8692 start_deploy
= time()
8695 # wait for any previous tasks in process
8696 step
= "Waiting for previous operations to terminate"
8697 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
8699 self
._write
_ns
_status
(
8702 current_operation
="VerticalScale",
8703 current_operation_id
=nslcmop_id
,
8705 step
= "Getting nslcmop from database"
8707 step
+ " after having waited for previous tasks to be completed"
8709 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
8710 operationParams
= db_nslcmop
.get("operationParams")
8712 target
.update(operationParams
)
8713 desc
= await self
.RO
.vertical_scale(nsr_id
, target
)
8714 self
.logger
.debug("RO return > {}".format(desc
))
8715 action_id
= desc
["action_id"]
8716 await self
._wait
_ng
_ro
(
8721 self
.timeout
.verticalscale
,
8722 operation
="verticalscale",
8724 except (ROclient
.ROClientException
, DbException
, LcmException
) as e
:
8725 self
.logger
.error("Exit Exception {}".format(e
))
8727 except asyncio
.CancelledError
:
8728 self
.logger
.error("Cancelled Exception while '{}'".format(step
))
8729 exc
= "Operation was cancelled"
8730 except Exception as e
:
8731 exc
= traceback
.format_exc()
8732 self
.logger
.critical(
8733 "Exit Exception {} {}".format(type(e
).__name
__, e
), exc_info
=True
8736 self
._write
_ns
_status
(
8739 current_operation
="IDLE",
8740 current_operation_id
=None,
8743 db_nslcmop_update
["detailed-status"] = "FAILED {}: {}".format(step
, exc
)
8744 nslcmop_operation_state
= "FAILED"
8746 nslcmop_operation_state
= "COMPLETED"
8747 db_nslcmop_update
["detailed-status"] = "Done"
8748 db_nsr_update
["detailed-status"] = "Done"
8750 self
._write
_op
_status
(
8754 operation_state
=nslcmop_operation_state
,
8755 other_update
=db_nslcmop_update
,
8757 if nslcmop_operation_state
:
8761 "nslcmop_id": nslcmop_id
,
8762 "operationState": nslcmop_operation_state
,
8764 await self
.msg
.aiowrite("ns", "verticalscaled", msg
)
8765 except Exception as e
:
8767 logging_text
+ "kafka_write notification Exception {}".format(e
)
8769 self
.logger
.debug(logging_text
+ "Exit")
8770 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_verticalscale")