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
37 from osm_lcm
import ROclient
38 from osm_lcm
.data_utils
.lcm_config
import LcmCfg
39 from osm_lcm
.data_utils
.nsr
import (
42 get_deployed_vca_list
,
45 from osm_lcm
.data_utils
.vca
import (
54 from osm_lcm
.ng_ro
import NgRoClient
, NgRoException
55 from osm_lcm
.lcm_utils
import (
61 check_juju_bundle_existence
,
62 get_charm_artifact_path
,
66 from osm_lcm
.data_utils
.nsd
import (
67 get_ns_configuration_relation_list
,
71 from osm_lcm
.data_utils
.vnfd
import (
77 get_ee_sorted_initial_config_primitive_list
,
78 get_ee_sorted_terminate_config_primitive_list
,
80 get_virtual_link_profiles
,
85 get_number_of_instances
,
87 get_kdu_resource_profile
,
88 find_software_version
,
91 from osm_lcm
.data_utils
.list_utils
import find_in_list
92 from osm_lcm
.data_utils
.vnfr
import (
96 get_volumes_from_instantiation_params
,
98 from osm_lcm
.data_utils
.dict_utils
import parse_yaml_strings
99 from osm_lcm
.data_utils
.database
.vim_account
import VimAccountDB
100 from n2vc
.definitions
import RelationEndpoint
101 from n2vc
.k8s_helm3_conn
import K8sHelm3Connector
102 from n2vc
.k8s_juju_conn
import K8sJujuConnector
104 from osm_common
.dbbase
import DbException
105 from osm_common
.fsbase
import FsException
107 from osm_lcm
.data_utils
.database
.database
import Database
108 from osm_lcm
.data_utils
.filesystem
.filesystem
import Filesystem
109 from osm_lcm
.data_utils
.wim
import (
111 get_target_wim_attrs
,
112 select_feasible_wim_account
,
115 from n2vc
.n2vc_juju_conn
import N2VCJujuConnector
116 from n2vc
.exceptions
import N2VCException
, N2VCNotFound
, K8sException
118 from osm_lcm
.lcm_helm_conn
import LCMHelmConn
119 from osm_lcm
.osm_config
import OsmConfigBuilder
120 from osm_lcm
.prometheus
import parse_job
122 from copy
import copy
, deepcopy
123 from time
import time
124 from uuid
import uuid4
126 from random
import SystemRandom
128 __author__
= "Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>"
131 class NsLcm(LcmBase
):
132 SUBOPERATION_STATUS_NOT_FOUND
= -1
133 SUBOPERATION_STATUS_NEW
= -2
134 SUBOPERATION_STATUS_SKIP
= -3
135 EE_TLS_NAME
= "ee-tls"
136 task_name_deploy_vca
= "Deploying VCA"
137 rel_operation_types
= {
146 def __init__(self
, msg
, lcm_tasks
, config
: LcmCfg
):
148 Init, Connect to database, filesystem storage, and messaging
149 :param config: two level dictionary with configuration. Top level should contain 'database', 'storage',
152 super().__init
__(msg
=msg
, logger
=logging
.getLogger("lcm.ns"))
154 self
.db
= Database().instance
.db
155 self
.fs
= Filesystem().instance
.fs
156 self
.lcm_tasks
= lcm_tasks
157 self
.timeout
= config
.timeout
158 self
.ro_config
= config
.RO
159 self
.vca_config
= config
.VCA
161 # create N2VC connector
162 self
.n2vc
= N2VCJujuConnector(
164 on_update_db
=self
._on
_update
_n
2vc
_db
,
169 self
.conn_helm_ee
= LCMHelmConn(
171 vca_config
=self
.vca_config
,
172 on_update_db
=self
._on
_update
_n
2vc
_db
,
175 self
.k8sclusterhelm3
= K8sHelm3Connector(
176 kubectl_command
=self
.vca_config
.kubectlpath
,
177 helm_command
=self
.vca_config
.helm3path
,
184 self
.k8sclusterjuju
= K8sJujuConnector(
185 kubectl_command
=self
.vca_config
.kubectlpath
,
186 juju_command
=self
.vca_config
.jujupath
,
188 on_update_db
=self
._on
_update
_k
8s
_db
,
193 self
.k8scluster_map
= {
194 "helm-chart-v3": self
.k8sclusterhelm3
,
195 "chart": self
.k8sclusterhelm3
,
196 "juju-bundle": self
.k8sclusterjuju
,
197 "juju": self
.k8sclusterjuju
,
201 "lxc_proxy_charm": self
.n2vc
,
202 "native_charm": self
.n2vc
,
203 "k8s_proxy_charm": self
.n2vc
,
204 "helm": self
.conn_helm_ee
,
205 "helm-v3": self
.conn_helm_ee
,
209 self
.RO
= NgRoClient(**self
.ro_config
.to_dict())
211 self
.op_status_map
= {
212 "instantiation": self
.RO
.status
,
213 "termination": self
.RO
.status
,
214 "migrate": self
.RO
.status
,
215 "healing": self
.RO
.recreate_status
,
216 "verticalscale": self
.RO
.status
,
217 "start_stop_rebuild": self
.RO
.status
,
221 def increment_ip_mac(ip_mac
, vm_index
=1):
222 if not isinstance(ip_mac
, str):
227 dual_ip
= ip_mac
.split(";")
228 if len(dual_ip
) == 2:
230 if ipaddress
.ip_address(ip
).version
== 6:
231 ipv6
= ipaddress
.IPv6Address(ip
)
232 next_ipv6
= str(ipaddress
.IPv6Address(int(ipv6
) + 1))
233 elif ipaddress
.ip_address(ip
).version
== 4:
234 ipv4
= ipaddress
.IPv4Address(ip
)
235 next_ipv4
= str(ipaddress
.IPv4Address(int(ipv4
) + 1))
236 return [next_ipv4
, next_ipv6
]
237 # try with ipv4 look for last dot
238 i
= ip_mac
.rfind(".")
241 return "{}{}".format(ip_mac
[:i
], int(ip_mac
[i
:]) + vm_index
)
242 # try with ipv6 or mac look for last colon. Operate in hex
243 i
= ip_mac
.rfind(":")
246 # format in hex, len can be 2 for mac or 4 for ipv6
247 return ("{}{:0" + str(len(ip_mac
) - i
) + "x}").format(
248 ip_mac
[:i
], int(ip_mac
[i
:], 16) + vm_index
254 async def _on_update_n2vc_db(self
, table
, filter, path
, updated_data
, vca_id
=None):
255 # remove last dot from path (if exists)
256 if path
.endswith("."):
259 # self.logger.debug('_on_update_n2vc_db(table={}, filter={}, path={}, updated_data={}'
260 # .format(table, filter, path, updated_data))
262 nsr_id
= filter.get("_id")
264 # read ns record from database
265 nsr
= self
.db
.get_one(table
="nsrs", q_filter
=filter)
266 current_ns_status
= nsr
.get("nsState")
268 # get vca status for NS
269 status_dict
= await self
.n2vc
.get_status(
270 namespace
="." + nsr_id
, yaml_format
=False, vca_id
=vca_id
275 db_dict
["vcaStatus"] = status_dict
277 # update configurationStatus for this VCA
279 vca_index
= int(path
[path
.rfind(".") + 1 :])
282 target_dict
=nsr
, key_list
=("_admin", "deployed", "VCA")
284 vca_status
= vca_list
[vca_index
].get("status")
286 configuration_status_list
= nsr
.get("configurationStatus")
287 config_status
= configuration_status_list
[vca_index
].get("status")
289 if config_status
== "BROKEN" and vca_status
!= "failed":
290 db_dict
["configurationStatus"][vca_index
] = "READY"
291 elif config_status
!= "BROKEN" and vca_status
== "failed":
292 db_dict
["configurationStatus"][vca_index
] = "BROKEN"
293 except Exception as e
:
294 # not update configurationStatus
295 self
.logger
.debug("Error updating vca_index (ignore): {}".format(e
))
297 # if nsState = 'READY' check if juju is reporting some error => nsState = 'DEGRADED'
298 # if nsState = 'DEGRADED' check if all is OK
300 if current_ns_status
in ("READY", "DEGRADED"):
301 error_description
= ""
303 if status_dict
.get("machines"):
304 for machine_id
in status_dict
.get("machines"):
305 machine
= status_dict
.get("machines").get(machine_id
)
306 # check machine agent-status
307 if machine
.get("agent-status"):
308 s
= machine
.get("agent-status").get("status")
311 error_description
+= (
312 "machine {} agent-status={} ; ".format(
316 # check machine instance status
317 if machine
.get("instance-status"):
318 s
= machine
.get("instance-status").get("status")
321 error_description
+= (
322 "machine {} instance-status={} ; ".format(
327 if status_dict
.get("applications"):
328 for app_id
in status_dict
.get("applications"):
329 app
= status_dict
.get("applications").get(app_id
)
330 # check application status
331 if app
.get("status"):
332 s
= app
.get("status").get("status")
335 error_description
+= (
336 "application {} status={} ; ".format(app_id
, s
)
339 if error_description
:
340 db_dict
["errorDescription"] = error_description
341 if current_ns_status
== "READY" and is_degraded
:
342 db_dict
["nsState"] = "DEGRADED"
343 if current_ns_status
== "DEGRADED" and not is_degraded
:
344 db_dict
["nsState"] = "READY"
347 self
.update_db_2("nsrs", nsr_id
, db_dict
)
349 except (asyncio
.CancelledError
, asyncio
.TimeoutError
):
351 except Exception as e
:
352 self
.logger
.warn("Error updating NS state for ns={}: {}".format(nsr_id
, e
))
354 async def _on_update_k8s_db(
355 self
, cluster_uuid
, kdu_instance
, filter=None, vca_id
=None, cluster_type
="juju"
358 Updating vca status in NSR record
359 :param cluster_uuid: UUID of a k8s cluster
360 :param kdu_instance: The unique name of the KDU instance
361 :param filter: To get nsr_id
362 :cluster_type: The cluster type (juju, k8s)
366 # self.logger.debug("_on_update_k8s_db(cluster_uuid={}, kdu_instance={}, filter={}"
367 # .format(cluster_uuid, kdu_instance, filter))
369 nsr_id
= filter.get("_id")
371 vca_status
= await self
.k8scluster_map
[cluster_type
].status_kdu(
372 cluster_uuid
=cluster_uuid
,
373 kdu_instance
=kdu_instance
,
375 complete_status
=True,
381 db_dict
["vcaStatus"] = {nsr_id
: vca_status
}
384 f
"Obtained VCA status for cluster type '{cluster_type}': {vca_status}"
388 self
.update_db_2("nsrs", nsr_id
, db_dict
)
389 except (asyncio
.CancelledError
, asyncio
.TimeoutError
):
391 except Exception as e
:
392 self
.logger
.warn("Error updating NS state for ns={}: {}".format(nsr_id
, e
))
395 def _parse_cloud_init(cloud_init_text
, additional_params
, vnfd_id
, vdu_id
):
398 undefined
=StrictUndefined
,
399 autoescape
=select_autoescape(default_for_string
=True, default
=True),
401 template
= env
.from_string(cloud_init_text
)
402 return template
.render(additional_params
or {})
403 except UndefinedError
as e
:
405 "Variable {} at vnfd[id={}]:vdu[id={}]:cloud-init/cloud-init-"
406 "file, must be provided in the instantiation parameters inside the "
407 "'additionalParamsForVnf/Vdu' block".format(e
, vnfd_id
, vdu_id
)
409 except (TemplateError
, TemplateNotFound
) as e
:
411 "Error parsing Jinja2 to cloud-init content at vnfd[id={}]:vdu[id={}]: {}".format(
416 def _get_vdu_cloud_init_content(self
, vdu
, vnfd
):
417 cloud_init_content
= cloud_init_file
= None
419 if vdu
.get("cloud-init-file"):
420 base_folder
= vnfd
["_admin"]["storage"]
421 if base_folder
["pkg-dir"]:
422 cloud_init_file
= "{}/{}/cloud_init/{}".format(
423 base_folder
["folder"],
424 base_folder
["pkg-dir"],
425 vdu
["cloud-init-file"],
428 cloud_init_file
= "{}/Scripts/cloud_init/{}".format(
429 base_folder
["folder"],
430 vdu
["cloud-init-file"],
432 with self
.fs
.file_open(cloud_init_file
, "r") as ci_file
:
433 cloud_init_content
= ci_file
.read()
434 elif vdu
.get("cloud-init"):
435 cloud_init_content
= vdu
["cloud-init"]
437 return cloud_init_content
438 except FsException
as e
:
440 "Error reading vnfd[id={}]:vdu[id={}]:cloud-init-file={}: {}".format(
441 vnfd
["id"], vdu
["id"], cloud_init_file
, e
445 def _get_vdu_additional_params(self
, db_vnfr
, vdu_id
):
447 (vdur
for vdur
in db_vnfr
.get("vdur") if vdu_id
== vdur
["vdu-id-ref"]), {}
449 additional_params
= vdur
.get("additionalParams")
450 return parse_yaml_strings(additional_params
)
453 def ip_profile_2_RO(ip_profile
):
454 RO_ip_profile
= deepcopy(ip_profile
)
455 if "dns-server" in RO_ip_profile
:
456 if isinstance(RO_ip_profile
["dns-server"], list):
457 RO_ip_profile
["dns-address"] = []
458 for ds
in RO_ip_profile
.pop("dns-server"):
459 RO_ip_profile
["dns-address"].append(ds
["address"])
461 RO_ip_profile
["dns-address"] = RO_ip_profile
.pop("dns-server")
462 if RO_ip_profile
.get("ip-version") == "ipv4":
463 RO_ip_profile
["ip-version"] = "IPv4"
464 if RO_ip_profile
.get("ip-version") == "ipv6":
465 RO_ip_profile
["ip-version"] = "IPv6"
466 if "dhcp-params" in RO_ip_profile
:
467 RO_ip_profile
["dhcp"] = RO_ip_profile
.pop("dhcp-params")
470 def scale_vnfr(self
, db_vnfr
, vdu_create
=None, vdu_delete
=None, mark_delete
=False):
471 db_vdu_push_list
= []
473 db_update
= {"_admin.modified": time()}
475 for vdu_id
, vdu_count
in vdu_create
.items():
479 for vdur
in reversed(db_vnfr
["vdur"])
480 if vdur
["vdu-id-ref"] == vdu_id
485 # Read the template saved in the db:
487 "No vdur in the database. Using the vdur-template to scale"
489 vdur_template
= db_vnfr
.get("vdur-template")
490 if not vdur_template
:
492 "Error scaling OUT VNFR for {}. No vnfr or template exists".format(
496 vdur
= vdur_template
[0]
497 # Delete a template from the database after using it
500 {"_id": db_vnfr
["_id"]},
502 pull
={"vdur-template": {"_id": vdur
["_id"]}},
504 for count
in range(vdu_count
):
505 vdur_copy
= deepcopy(vdur
)
506 vdur_copy
["status"] = "BUILD"
507 vdur_copy
["status-detailed"] = None
508 vdur_copy
["ip-address"] = None
509 vdur_copy
["_id"] = str(uuid4())
510 vdur_copy
["count-index"] += count
+ 1
511 vdur_copy
["id"] = "{}-{}".format(
512 vdur_copy
["vdu-id-ref"], vdur_copy
["count-index"]
514 vdur_copy
.pop("vim_info", None)
515 for iface
in vdur_copy
["interfaces"]:
516 if iface
.get("fixed-ip"):
517 iface
["ip-address"] = self
.increment_ip_mac(
518 iface
["ip-address"], count
+ 1
521 iface
.pop("ip-address", None)
522 if iface
.get("fixed-mac"):
523 iface
["mac-address"] = self
.increment_ip_mac(
524 iface
["mac-address"], count
+ 1
527 iface
.pop("mac-address", None)
531 ) # only first vdu can be managment of vnf
532 db_vdu_push_list
.append(vdur_copy
)
533 # self.logger.debug("scale out, adding vdu={}".format(vdur_copy))
535 if len(db_vnfr
["vdur"]) == 1:
536 # The scale will move to 0 instances
538 "Scaling to 0 !, creating the template with the last vdur"
540 template_vdur
= [db_vnfr
["vdur"][0]]
541 for vdu_id
, vdu_count
in vdu_delete
.items():
543 indexes_to_delete
= [
545 for iv
in enumerate(db_vnfr
["vdur"])
546 if iv
[1]["vdu-id-ref"] == vdu_id
550 "vdur.{}.status".format(i
): "DELETING"
551 for i
in indexes_to_delete
[-vdu_count
:]
555 # it must be deleted one by one because common.db does not allow otherwise
558 for v
in reversed(db_vnfr
["vdur"])
559 if v
["vdu-id-ref"] == vdu_id
561 for vdu
in vdus_to_delete
[:vdu_count
]:
564 {"_id": db_vnfr
["_id"]},
566 pull
={"vdur": {"_id": vdu
["_id"]}},
570 db_push
["vdur"] = db_vdu_push_list
572 db_push
["vdur-template"] = template_vdur
575 db_vnfr
["vdur-template"] = template_vdur
576 self
.db
.set_one("vnfrs", {"_id": db_vnfr
["_id"]}, db_update
, push_list
=db_push
)
577 # modify passed dictionary db_vnfr
578 db_vnfr_
= self
.db
.get_one("vnfrs", {"_id": db_vnfr
["_id"]})
579 db_vnfr
["vdur"] = db_vnfr_
["vdur"]
581 def ns_update_nsr(self
, ns_update_nsr
, db_nsr
, nsr_desc_RO
):
583 Updates database nsr with the RO info for the created vld
584 :param ns_update_nsr: dictionary to be filled with the updated info
585 :param db_nsr: content of db_nsr. This is also modified
586 :param nsr_desc_RO: nsr descriptor from RO
587 :return: Nothing, LcmException is raised on errors
590 for vld_index
, vld
in enumerate(get_iterable(db_nsr
, "vld")):
591 for net_RO
in get_iterable(nsr_desc_RO
, "nets"):
592 if vld
["id"] != net_RO
.get("ns_net_osm_id"):
594 vld
["vim-id"] = net_RO
.get("vim_net_id")
595 vld
["name"] = net_RO
.get("vim_name")
596 vld
["status"] = net_RO
.get("status")
597 vld
["status-detailed"] = net_RO
.get("error_msg")
598 ns_update_nsr
["vld.{}".format(vld_index
)] = vld
602 "ns_update_nsr: Not found vld={} at RO info".format(vld
["id"])
605 def set_vnfr_at_error(self
, db_vnfrs
, error_text
):
607 for db_vnfr
in db_vnfrs
.values():
608 vnfr_update
= {"status": "ERROR"}
609 for vdu_index
, vdur
in enumerate(get_iterable(db_vnfr
, "vdur")):
610 if "status" not in vdur
:
611 vdur
["status"] = "ERROR"
612 vnfr_update
["vdur.{}.status".format(vdu_index
)] = "ERROR"
614 vdur
["status-detailed"] = str(error_text
)
616 "vdur.{}.status-detailed".format(vdu_index
)
618 self
.update_db_2("vnfrs", db_vnfr
["_id"], vnfr_update
)
619 except DbException
as e
:
620 self
.logger
.error("Cannot update vnf. {}".format(e
))
622 def _get_ns_config_info(self
, nsr_id
):
624 Generates a mapping between vnf,vdu elements and the N2VC id
625 :param nsr_id: id of nsr to get last database _admin.deployed.VCA that contains this list
626 :return: a dictionary with {osm-config-mapping: {}} where its element contains:
627 "<member-vnf-index>": <N2VC-id> for a vnf configuration, or
628 "<member-vnf-index>.<vdu.id>.<vdu replica(0, 1,..)>": <N2VC-id> for a vdu configuration
630 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
631 vca_deployed_list
= db_nsr
["_admin"]["deployed"]["VCA"]
633 ns_config_info
= {"osm-config-mapping": mapping
}
634 for vca
in vca_deployed_list
:
635 if not vca
["member-vnf-index"]:
637 if not vca
["vdu_id"]:
638 mapping
[vca
["member-vnf-index"]] = vca
["application"]
642 vca
["member-vnf-index"], vca
["vdu_id"], vca
["vdu_count_index"]
644 ] = vca
["application"]
645 return ns_config_info
647 async def _instantiate_ng_ro(
663 def get_vim_account(vim_account_id
):
665 if vim_account_id
in db_vims
:
666 return db_vims
[vim_account_id
]
667 db_vim
= self
.db
.get_one("vim_accounts", {"_id": vim_account_id
})
668 db_vims
[vim_account_id
] = db_vim
671 # modify target_vld info with instantiation parameters
672 def parse_vld_instantiation_params(
673 target_vim
, target_vld
, vld_params
, target_sdn
675 if vld_params
.get("ip-profile"):
676 target_vld
["vim_info"][target_vim
]["ip_profile"] = vld_to_ro_ip_profile(
677 vld_params
["ip-profile"]
679 if vld_params
.get("provider-network"):
680 target_vld
["vim_info"][target_vim
]["provider_network"] = vld_params
[
683 if "sdn-ports" in vld_params
["provider-network"] and target_sdn
:
684 target_vld
["vim_info"][target_sdn
]["sdn-ports"] = vld_params
[
688 # check if WIM is needed; if needed, choose a feasible WIM able to connect VIMs
689 # if wim_account_id is specified in vld_params, validate if it is feasible.
690 wim_account_id
, db_wim
= select_feasible_wim_account(
691 db_nsr
, db_vnfrs
, target_vld
, vld_params
, self
.logger
695 # WIM is needed and a feasible one was found, populate WIM target and SDN ports
696 self
.logger
.info("WIM selected: {:s}".format(str(wim_account_id
)))
697 # update vld_params with correct WIM account Id
698 vld_params
["wimAccountId"] = wim_account_id
700 target_wim
= "wim:{}".format(wim_account_id
)
701 target_wim_attrs
= get_target_wim_attrs(nsr_id
, target_vld
, vld_params
)
702 sdn_ports
= get_sdn_ports(vld_params
, db_wim
)
703 if len(sdn_ports
) > 0:
704 target_vld
["vim_info"][target_wim
] = target_wim_attrs
705 target_vld
["vim_info"][target_wim
]["sdn-ports"] = sdn_ports
708 "Target VLD with WIM data: {:s}".format(str(target_vld
))
711 for param
in ("vim-network-name", "vim-network-id"):
712 if vld_params
.get(param
):
713 if isinstance(vld_params
[param
], dict):
714 for vim
, vim_net
in vld_params
[param
].items():
715 other_target_vim
= "vim:" + vim
717 target_vld
["vim_info"],
718 (other_target_vim
, param
.replace("-", "_")),
721 else: # isinstance str
722 target_vld
["vim_info"][target_vim
][
723 param
.replace("-", "_")
724 ] = vld_params
[param
]
725 if vld_params
.get("common_id"):
726 target_vld
["common_id"] = vld_params
.get("common_id")
728 # modify target["ns"]["vld"] with instantiation parameters to override vnf vim-account
729 def update_ns_vld_target(target
, ns_params
):
730 for vnf_params
in ns_params
.get("vnf", ()):
731 if vnf_params
.get("vimAccountId"):
735 for vnfr
in db_vnfrs
.values()
736 if vnf_params
["member-vnf-index"]
737 == vnfr
["member-vnf-index-ref"]
741 vdur
= next((vdur
for vdur
in target_vnf
.get("vdur", ())), None)
744 for a_index
, a_vld
in enumerate(target
["ns"]["vld"]):
745 target_vld
= find_in_list(
746 get_iterable(vdur
, "interfaces"),
747 lambda iface
: iface
.get("ns-vld-id") == a_vld
["name"],
750 vld_params
= find_in_list(
751 get_iterable(ns_params
, "vld"),
752 lambda v_vld
: v_vld
["name"] in (a_vld
["name"], a_vld
["id"]),
755 if vnf_params
.get("vimAccountId") not in a_vld
.get(
758 target_vim_network_list
= [
759 v
for _
, v
in a_vld
.get("vim_info").items()
761 target_vim_network_name
= next(
763 item
.get("vim_network_name", "")
764 for item
in target_vim_network_list
769 target
["ns"]["vld"][a_index
].get("vim_info").update(
771 "vim:{}".format(vnf_params
["vimAccountId"]): {
772 "vim_network_name": target_vim_network_name
,
778 for param
in ("vim-network-name", "vim-network-id"):
779 if vld_params
.get(param
) and isinstance(
780 vld_params
[param
], dict
782 for vim
, vim_net
in vld_params
[
785 other_target_vim
= "vim:" + vim
787 target
["ns"]["vld"][a_index
].get(
792 param
.replace("-", "_"),
797 nslcmop_id
= db_nslcmop
["_id"]
799 "name": db_nsr
["name"],
802 "image": deepcopy(db_nsr
["image"]),
803 "flavor": deepcopy(db_nsr
["flavor"]),
804 "action_id": nslcmop_id
,
805 "cloud_init_content": {},
807 for image
in target
["image"]:
808 image
["vim_info"] = {}
809 for flavor
in target
["flavor"]:
810 flavor
["vim_info"] = {}
811 if db_nsr
.get("shared-volumes"):
812 target
["shared-volumes"] = deepcopy(db_nsr
["shared-volumes"])
813 for shared_volumes
in target
["shared-volumes"]:
814 shared_volumes
["vim_info"] = {}
815 if db_nsr
.get("affinity-or-anti-affinity-group"):
816 target
["affinity-or-anti-affinity-group"] = deepcopy(
817 db_nsr
["affinity-or-anti-affinity-group"]
819 for affinity_or_anti_affinity_group
in target
[
820 "affinity-or-anti-affinity-group"
822 affinity_or_anti_affinity_group
["vim_info"] = {}
824 if db_nslcmop
.get("lcmOperationType") != "instantiate":
825 # get parameters of instantiation:
826 db_nslcmop_instantiate
= self
.db
.get_list(
829 "nsInstanceId": db_nslcmop
["nsInstanceId"],
830 "lcmOperationType": "instantiate",
833 ns_params
= db_nslcmop_instantiate
.get("operationParams")
835 ns_params
= db_nslcmop
.get("operationParams")
836 ssh_keys_instantiation
= ns_params
.get("ssh_keys") or []
837 ssh_keys_all
= ssh_keys_instantiation
+ (n2vc_key_list
or [])
840 for vld_index
, vld
in enumerate(db_nsr
.get("vld")):
841 target_vim
= "vim:{}".format(ns_params
["vimAccountId"])
845 "mgmt-network": vld
.get("mgmt-network", False),
846 "type": vld
.get("type"),
849 "vim_network_name": vld
.get("vim-network-name"),
850 "vim_account_id": ns_params
["vimAccountId"],
854 # check if this network needs SDN assist
855 if vld
.get("pci-interfaces"):
856 db_vim
= get_vim_account(ns_params
["vimAccountId"])
857 if vim_config
:= db_vim
.get("config"):
858 if sdnc_id
:= vim_config
.get("sdn-controller"):
859 sdn_vld
= "nsrs:{}:vld.{}".format(nsr_id
, vld
["id"])
860 target_sdn
= "sdn:{}".format(sdnc_id
)
861 target_vld
["vim_info"][target_sdn
] = {
863 "target_vim": target_vim
,
865 "type": vld
.get("type"),
868 nsd_vnf_profiles
= get_vnf_profiles(nsd
)
869 for nsd_vnf_profile
in nsd_vnf_profiles
:
870 for cp
in nsd_vnf_profile
["virtual-link-connectivity"]:
871 if cp
["virtual-link-profile-id"] == vld
["id"]:
873 "member_vnf:{}.{}".format(
874 cp
["constituent-cpd-id"][0][
875 "constituent-base-element-id"
877 cp
["constituent-cpd-id"][0]["constituent-cpd-id"],
879 ] = "nsrs:{}:vld.{}".format(nsr_id
, vld_index
)
881 # check at nsd descriptor, if there is an ip-profile
883 nsd_vlp
= find_in_list(
884 get_virtual_link_profiles(nsd
),
885 lambda a_link_profile
: a_link_profile
["virtual-link-desc-id"]
890 and nsd_vlp
.get("virtual-link-protocol-data")
891 and nsd_vlp
["virtual-link-protocol-data"].get("l3-protocol-data")
893 vld_params
["ip-profile"] = nsd_vlp
["virtual-link-protocol-data"][
897 # update vld_params with instantiation params
898 vld_instantiation_params
= find_in_list(
899 get_iterable(ns_params
, "vld"),
900 lambda a_vld
: a_vld
["name"] in (vld
["name"], vld
["id"]),
902 if vld_instantiation_params
:
903 vld_params
.update(vld_instantiation_params
)
904 parse_vld_instantiation_params(target_vim
, target_vld
, vld_params
, None)
905 target
["ns"]["vld"].append(target_vld
)
906 # Update the target ns_vld if vnf vim_account is overriden by instantiation params
907 update_ns_vld_target(target
, ns_params
)
909 for vnfr
in db_vnfrs
.values():
911 db_vnfds
, lambda db_vnf
: db_vnf
["id"] == vnfr
["vnfd-ref"]
913 vnf_params
= find_in_list(
914 get_iterable(ns_params
, "vnf"),
915 lambda a_vnf
: a_vnf
["member-vnf-index"] == vnfr
["member-vnf-index-ref"],
917 target_vnf
= deepcopy(vnfr
)
918 target_vim
= "vim:{}".format(vnfr
["vim-account-id"])
919 for vld
in target_vnf
.get("vld", ()):
920 # check if connected to a ns.vld, to fill target'
921 vnf_cp
= find_in_list(
922 vnfd
.get("int-virtual-link-desc", ()),
923 lambda cpd
: cpd
.get("id") == vld
["id"],
926 ns_cp
= "member_vnf:{}.{}".format(
927 vnfr
["member-vnf-index-ref"], vnf_cp
["id"]
929 if cp2target
.get(ns_cp
):
930 vld
["target"] = cp2target
[ns_cp
]
933 target_vim
: {"vim_network_name": vld
.get("vim-network-name")}
935 # check if this network needs SDN assist
937 if vld
.get("pci-interfaces"):
938 db_vim
= get_vim_account(vnfr
["vim-account-id"])
939 sdnc_id
= db_vim
["config"].get("sdn-controller")
941 sdn_vld
= "vnfrs:{}:vld.{}".format(target_vnf
["_id"], vld
["id"])
942 target_sdn
= "sdn:{}".format(sdnc_id
)
943 vld
["vim_info"][target_sdn
] = {
945 "target_vim": target_vim
,
947 "type": vld
.get("type"),
950 # check at vnfd descriptor, if there is an ip-profile
952 vnfd_vlp
= find_in_list(
953 get_virtual_link_profiles(vnfd
),
954 lambda a_link_profile
: a_link_profile
["id"] == vld
["id"],
958 and vnfd_vlp
.get("virtual-link-protocol-data")
959 and vnfd_vlp
["virtual-link-protocol-data"].get("l3-protocol-data")
961 vld_params
["ip-profile"] = vnfd_vlp
["virtual-link-protocol-data"][
964 # update vld_params with instantiation params
966 vld_instantiation_params
= find_in_list(
967 get_iterable(vnf_params
, "internal-vld"),
968 lambda i_vld
: i_vld
["name"] == vld
["id"],
970 if vld_instantiation_params
:
971 vld_params
.update(vld_instantiation_params
)
972 parse_vld_instantiation_params(target_vim
, vld
, vld_params
, target_sdn
)
975 for vdur
in target_vnf
.get("vdur", ()):
976 if vdur
.get("status") == "DELETING" or vdur
.get("pdu-type"):
977 continue # This vdu must not be created
978 vdur
["vim_info"] = {"vim_account_id": vnfr
["vim-account-id"]}
980 self
.logger
.debug("NS > ssh_keys > {}".format(ssh_keys_all
))
983 vdu_configuration
= get_configuration(vnfd
, vdur
["vdu-id-ref"])
984 vnf_configuration
= get_configuration(vnfd
, vnfd
["id"])
987 and vdu_configuration
.get("config-access")
988 and vdu_configuration
.get("config-access").get("ssh-access")
990 vdur
["ssh-keys"] = ssh_keys_all
991 vdur
["ssh-access-required"] = vdu_configuration
[
993 ]["ssh-access"]["required"]
996 and vnf_configuration
.get("config-access")
997 and vnf_configuration
.get("config-access").get("ssh-access")
998 and any(iface
.get("mgmt-vnf") for iface
in vdur
["interfaces"])
1000 vdur
["ssh-keys"] = ssh_keys_all
1001 vdur
["ssh-access-required"] = vnf_configuration
[
1003 ]["ssh-access"]["required"]
1004 elif ssh_keys_instantiation
and find_in_list(
1005 vdur
["interfaces"], lambda iface
: iface
.get("mgmt-vnf")
1007 vdur
["ssh-keys"] = ssh_keys_instantiation
1009 self
.logger
.debug("NS > vdur > {}".format(vdur
))
1011 vdud
= get_vdu(vnfd
, vdur
["vdu-id-ref"])
1013 if vdud
.get("cloud-init-file"):
1014 vdur
["cloud-init"] = "{}:file:{}".format(
1015 vnfd
["_id"], vdud
.get("cloud-init-file")
1017 # read file and put content at target.cloul_init_content. Avoid ng_ro to use shared package system
1018 if vdur
["cloud-init"] not in target
["cloud_init_content"]:
1019 base_folder
= vnfd
["_admin"]["storage"]
1020 if base_folder
["pkg-dir"]:
1021 cloud_init_file
= "{}/{}/cloud_init/{}".format(
1022 base_folder
["folder"],
1023 base_folder
["pkg-dir"],
1024 vdud
.get("cloud-init-file"),
1027 cloud_init_file
= "{}/Scripts/cloud_init/{}".format(
1028 base_folder
["folder"],
1029 vdud
.get("cloud-init-file"),
1031 with self
.fs
.file_open(cloud_init_file
, "r") as ci_file
:
1032 target
["cloud_init_content"][
1035 elif vdud
.get("cloud-init"):
1036 vdur
["cloud-init"] = "{}:vdu:{}".format(
1037 vnfd
["_id"], get_vdu_index(vnfd
, vdur
["vdu-id-ref"])
1039 # put content at target.cloul_init_content. Avoid ng_ro read vnfd descriptor
1040 target
["cloud_init_content"][vdur
["cloud-init"]] = vdud
[
1043 vdur
["additionalParams"] = vdur
.get("additionalParams") or {}
1044 deploy_params_vdu
= self
._format
_additional
_params
(
1045 vdur
.get("additionalParams") or {}
1047 deploy_params_vdu
["OSM"] = get_osm_params(
1048 vnfr
, vdur
["vdu-id-ref"], vdur
["count-index"]
1050 vdur
["additionalParams"] = deploy_params_vdu
1053 ns_flavor
= target
["flavor"][int(vdur
["ns-flavor-id"])]
1054 if target_vim
not in ns_flavor
["vim_info"]:
1055 ns_flavor
["vim_info"][target_vim
] = {}
1058 # in case alternative images are provided we must check if they should be applied
1059 # for the vim_type, modify the vim_type taking into account
1060 ns_image_id
= int(vdur
["ns-image-id"])
1061 if vdur
.get("alt-image-ids"):
1062 db_vim
= get_vim_account(vnfr
["vim-account-id"])
1063 vim_type
= db_vim
["vim_type"]
1064 for alt_image_id
in vdur
.get("alt-image-ids"):
1065 ns_alt_image
= target
["image"][int(alt_image_id
)]
1066 if vim_type
== ns_alt_image
.get("vim-type"):
1067 # must use alternative image
1069 "use alternative image id: {}".format(alt_image_id
)
1071 ns_image_id
= alt_image_id
1072 vdur
["ns-image-id"] = ns_image_id
1074 ns_image
= target
["image"][int(ns_image_id
)]
1075 if target_vim
not in ns_image
["vim_info"]:
1076 ns_image
["vim_info"][target_vim
] = {}
1079 if vdur
.get("affinity-or-anti-affinity-group-id"):
1080 for ags_id
in vdur
["affinity-or-anti-affinity-group-id"]:
1081 ns_ags
= target
["affinity-or-anti-affinity-group"][int(ags_id
)]
1082 if target_vim
not in ns_ags
["vim_info"]:
1083 ns_ags
["vim_info"][target_vim
] = {}
1086 if vdur
.get("shared-volumes-id"):
1087 for sv_id
in vdur
["shared-volumes-id"]:
1088 ns_sv
= find_in_list(
1089 target
["shared-volumes"], lambda sv
: sv_id
in sv
["id"]
1092 ns_sv
["vim_info"][target_vim
] = {}
1094 vdur
["vim_info"] = {target_vim
: {}}
1095 # instantiation parameters
1097 vdu_instantiation_params
= find_in_list(
1098 get_iterable(vnf_params
, "vdu"),
1099 lambda i_vdu
: i_vdu
["id"] == vdud
["id"],
1101 if vdu_instantiation_params
:
1102 # Parse the vdu_volumes from the instantiation params
1103 vdu_volumes
= get_volumes_from_instantiation_params(
1104 vdu_instantiation_params
, vdud
1106 vdur
["additionalParams"]["OSM"]["vdu_volumes"] = vdu_volumes
1107 vdur
["additionalParams"]["OSM"][
1109 ] = vdu_instantiation_params
.get("vim-flavor-id")
1110 vdur_list
.append(vdur
)
1111 target_vnf
["vdur"] = vdur_list
1112 target
["vnf"].append(target_vnf
)
1114 self
.logger
.debug("Send to RO > nsr_id={} target={}".format(nsr_id
, target
))
1115 desc
= await self
.RO
.deploy(nsr_id
, target
)
1116 self
.logger
.debug("RO return > {}".format(desc
))
1117 action_id
= desc
["action_id"]
1118 await self
._wait
_ng
_ro
(
1125 operation
="instantiation",
1130 "_admin.deployed.RO.operational-status": "running",
1131 "detailed-status": " ".join(stage
),
1133 # db_nsr["_admin.deployed.RO.detailed-status"] = "Deployed at VIM"
1134 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
1135 self
._write
_op
_status
(nslcmop_id
, stage
)
1137 logging_text
+ "ns deployed at RO. RO_id={}".format(action_id
)
1141 async def _wait_ng_ro(
1151 detailed_status_old
= None
1153 start_time
= start_time
or time()
1154 while time() <= start_time
+ timeout
:
1155 desc_status
= await self
.op_status_map
[operation
](nsr_id
, action_id
)
1156 self
.logger
.debug("Wait NG RO > {}".format(desc_status
))
1157 if desc_status
["status"] == "FAILED":
1158 raise NgRoException(desc_status
["details"])
1159 elif desc_status
["status"] == "BUILD":
1161 stage
[2] = "VIM: ({})".format(desc_status
["details"])
1162 elif desc_status
["status"] == "DONE":
1164 stage
[2] = "Deployed at VIM"
1167 assert False, "ROclient.check_ns_status returns unknown {}".format(
1168 desc_status
["status"]
1170 if stage
and nslcmop_id
and stage
[2] != detailed_status_old
:
1171 detailed_status_old
= stage
[2]
1172 db_nsr_update
["detailed-status"] = " ".join(stage
)
1173 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
1174 self
._write
_op
_status
(nslcmop_id
, stage
)
1175 await asyncio
.sleep(15)
1176 else: # timeout_ns_deploy
1177 raise NgRoException("Timeout waiting ns to deploy")
1179 async def _terminate_ng_ro(
1180 self
, logging_text
, nsr_deployed
, nsr_id
, nslcmop_id
, stage
1185 start_deploy
= time()
1192 "action_id": nslcmop_id
,
1194 desc
= await self
.RO
.deploy(nsr_id
, target
)
1195 action_id
= desc
["action_id"]
1196 db_nsr_update
["_admin.deployed.RO.nsr_status"] = "DELETING"
1199 + "ns terminate action at RO. action_id={}".format(action_id
)
1203 delete_timeout
= 20 * 60 # 20 minutes
1204 await self
._wait
_ng
_ro
(
1211 operation
="termination",
1213 db_nsr_update
["_admin.deployed.RO.nsr_status"] = "DELETED"
1215 await self
.RO
.delete(nsr_id
)
1216 except NgRoException
as e
:
1217 if e
.http_code
== 404: # not found
1218 db_nsr_update
["_admin.deployed.RO.nsr_id"] = None
1219 db_nsr_update
["_admin.deployed.RO.nsr_status"] = "DELETED"
1221 logging_text
+ "RO_action_id={} already deleted".format(action_id
)
1223 elif e
.http_code
== 409: # conflict
1224 failed_detail
.append("delete conflict: {}".format(e
))
1227 + "RO_action_id={} delete conflict: {}".format(action_id
, e
)
1230 failed_detail
.append("delete error: {}".format(e
))
1233 + "RO_action_id={} delete error: {}".format(action_id
, e
)
1235 except Exception as e
:
1236 failed_detail
.append("delete error: {}".format(e
))
1238 logging_text
+ "RO_action_id={} delete error: {}".format(action_id
, e
)
1242 stage
[2] = "Error deleting from VIM"
1244 stage
[2] = "Deleted from VIM"
1245 db_nsr_update
["detailed-status"] = " ".join(stage
)
1246 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
1247 self
._write
_op
_status
(nslcmop_id
, stage
)
1250 raise LcmException("; ".join(failed_detail
))
1253 async def instantiate_RO(
1267 :param logging_text: preffix text to use at logging
1268 :param nsr_id: nsr identity
1269 :param nsd: database content of ns descriptor
1270 :param db_nsr: database content of ns record
1271 :param db_nslcmop: database content of ns operation, in this case, 'instantiate'
1273 :param db_vnfds: database content of vnfds, indexed by id (not _id). {id: {vnfd_object}, ...}
1274 :param n2vc_key_list: ssh-public-key list to be inserted to management vdus via cloud-init
1275 :param stage: list with 3 items: [general stage, tasks, vim_specific]. This task will write over vim_specific
1276 :return: None or exception
1279 start_deploy
= time()
1280 ns_params
= db_nslcmop
.get("operationParams")
1281 if ns_params
and ns_params
.get("timeout_ns_deploy"):
1282 timeout_ns_deploy
= ns_params
["timeout_ns_deploy"]
1284 timeout_ns_deploy
= self
.timeout
.ns_deploy
1286 # Check for and optionally request placement optimization. Database will be updated if placement activated
1287 stage
[2] = "Waiting for Placement."
1288 if await self
._do
_placement
(logging_text
, db_nslcmop
, db_vnfrs
):
1289 # in case of placement change ns_params[vimAcountId) if not present at any vnfrs
1290 for vnfr
in db_vnfrs
.values():
1291 if ns_params
["vimAccountId"] == vnfr
["vim-account-id"]:
1294 ns_params
["vimAccountId"] == vnfr
["vim-account-id"]
1296 return await self
._instantiate
_ng
_ro
(
1309 except Exception as e
:
1310 stage
[2] = "ERROR deploying at VIM"
1311 self
.set_vnfr_at_error(db_vnfrs
, str(e
))
1313 "Error deploying at VIM {}".format(e
),
1314 exc_info
=not isinstance(
1317 ROclient
.ROClientException
,
1326 async def wait_kdu_up(self
, logging_text
, nsr_id
, vnfr_id
, kdu_name
):
1328 Wait for kdu to be up, get ip address
1329 :param logging_text: prefix use for logging
1333 :return: IP address, K8s services
1336 # self.logger.debug(logging_text + "Starting wait_kdu_up")
1339 while nb_tries
< 360:
1340 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnfr_id
})
1344 for x
in get_iterable(db_vnfr
, "kdur")
1345 if x
.get("kdu-name") == kdu_name
1351 "Not found vnfr_id={}, kdu_name={}".format(vnfr_id
, kdu_name
)
1353 if kdur
.get("status"):
1354 if kdur
["status"] in ("READY", "ENABLED"):
1355 return kdur
.get("ip-address"), kdur
.get("services")
1358 "target KDU={} is in error state".format(kdu_name
)
1361 await asyncio
.sleep(10)
1363 raise LcmException("Timeout waiting KDU={} instantiated".format(kdu_name
))
1365 async def wait_vm_up_insert_key_ro(
1366 self
, logging_text
, nsr_id
, vnfr_id
, vdu_id
, vdu_index
, pub_key
=None, user
=None
1369 Wait for ip addres at RO, and optionally, insert public key in virtual machine
1370 :param logging_text: prefix use for logging
1375 :param pub_key: public ssh key to inject, None to skip
1376 :param user: user to apply the public ssh key
1380 self
.logger
.debug(logging_text
+ "Starting wait_vm_up_insert_key_ro")
1382 target_vdu_id
= None
1387 if ro_retries
>= 360: # 1 hour
1389 "Not found _admin.deployed.RO.nsr_id for nsr_id: {}".format(nsr_id
)
1392 await asyncio
.sleep(10)
1395 if not target_vdu_id
:
1396 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnfr_id
})
1398 if not vdu_id
: # for the VNF case
1399 if db_vnfr
.get("status") == "ERROR":
1401 "Cannot inject ssh-key because target VNF is in error state"
1403 ip_address
= db_vnfr
.get("ip-address")
1409 for x
in get_iterable(db_vnfr
, "vdur")
1410 if x
.get("ip-address") == ip_address
1418 for x
in get_iterable(db_vnfr
, "vdur")
1419 if x
.get("vdu-id-ref") == vdu_id
1420 and x
.get("count-index") == vdu_index
1426 not vdur
and len(db_vnfr
.get("vdur", ())) == 1
1427 ): # If only one, this should be the target vdu
1428 vdur
= db_vnfr
["vdur"][0]
1431 "Not found vnfr_id={}, vdu_id={}, vdu_index={}".format(
1432 vnfr_id
, vdu_id
, vdu_index
1435 # New generation RO stores information at "vim_info"
1438 if vdur
.get("vim_info"):
1440 t
for t
in vdur
["vim_info"]
1441 ) # there should be only one key
1442 ng_ro_status
= vdur
["vim_info"][target_vim
].get("vim_status")
1444 vdur
.get("pdu-type")
1445 or vdur
.get("status") == "ACTIVE"
1446 or ng_ro_status
== "ACTIVE"
1448 ip_address
= vdur
.get("ip-address")
1451 target_vdu_id
= vdur
["vdu-id-ref"]
1452 elif vdur
.get("status") == "ERROR" or ng_ro_status
== "ERROR":
1454 "Cannot inject ssh-key because target VM is in error state"
1457 if not target_vdu_id
:
1460 # inject public key into machine
1461 if pub_key
and user
:
1462 self
.logger
.debug(logging_text
+ "Inserting RO key")
1463 self
.logger
.debug("SSH > PubKey > {}".format(pub_key
))
1464 if vdur
.get("pdu-type"):
1465 self
.logger
.error(logging_text
+ "Cannot inject ssh-ky to a PDU")
1470 "action": "inject_ssh_key",
1474 "vnf": [{"_id": vnfr_id
, "vdur": [{"id": vdur
["id"]}]}],
1476 desc
= await self
.RO
.deploy(nsr_id
, target
)
1477 action_id
= desc
["action_id"]
1478 await self
._wait
_ng
_ro
(
1479 nsr_id
, action_id
, timeout
=600, operation
="instantiation"
1482 except NgRoException
as e
:
1484 "Reaching max tries injecting key. Error: {}".format(e
)
1491 async def _wait_dependent_n2vc(self
, nsr_id
, vca_deployed_list
, vca_index
):
1493 Wait until dependent VCA deployments have been finished. NS wait for VNFs and VDUs. VNFs for VDUs
1495 my_vca
= vca_deployed_list
[vca_index
]
1496 if my_vca
.get("vdu_id") or my_vca
.get("kdu_name"):
1497 # vdu or kdu: no dependencies
1501 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
1502 vca_deployed_list
= db_nsr
["_admin"]["deployed"]["VCA"]
1503 configuration_status_list
= db_nsr
["configurationStatus"]
1504 for index
, vca_deployed
in enumerate(configuration_status_list
):
1505 if index
== vca_index
:
1508 if not my_vca
.get("member-vnf-index") or (
1509 vca_deployed
.get("member-vnf-index")
1510 == my_vca
.get("member-vnf-index")
1512 internal_status
= configuration_status_list
[index
].get("status")
1513 if internal_status
== "READY":
1515 elif internal_status
== "BROKEN":
1517 "Configuration aborted because dependent charm/s has failed"
1522 # no dependencies, return
1524 await asyncio
.sleep(10)
1527 raise LcmException("Configuration aborted because dependent charm/s timeout")
1529 def get_vca_id(self
, db_vnfr
: dict, db_nsr
: dict):
1532 vca_id
= deep_get(db_vnfr
, ("vca-id",))
1534 vim_account_id
= deep_get(db_nsr
, ("instantiate_params", "vimAccountId"))
1535 vca_id
= VimAccountDB
.get_vim_account_with_id(vim_account_id
).get("vca")
1538 async def instantiate_N2VC(
1556 ee_config_descriptor
,
1558 nsr_id
= db_nsr
["_id"]
1559 db_update_entry
= "_admin.deployed.VCA.{}.".format(vca_index
)
1560 vca_deployed_list
= db_nsr
["_admin"]["deployed"]["VCA"]
1561 vca_deployed
= db_nsr
["_admin"]["deployed"]["VCA"][vca_index
]
1562 osm_config
= {"osm": {"ns_id": db_nsr
["_id"]}}
1564 "collection": "nsrs",
1565 "filter": {"_id": nsr_id
},
1566 "path": db_update_entry
,
1571 element_under_configuration
= nsr_id
1575 vnfr_id
= db_vnfr
["_id"]
1576 osm_config
["osm"]["vnf_id"] = vnfr_id
1578 namespace
= "{nsi}.{ns}".format(nsi
=nsi_id
if nsi_id
else "", ns
=nsr_id
)
1580 if vca_type
== "native_charm":
1583 index_number
= vdu_index
or 0
1586 element_type
= "VNF"
1587 element_under_configuration
= vnfr_id
1588 namespace
+= ".{}-{}".format(vnfr_id
, index_number
)
1590 namespace
+= ".{}-{}".format(vdu_id
, index_number
)
1591 element_type
= "VDU"
1592 element_under_configuration
= "{}-{}".format(vdu_id
, index_number
)
1593 osm_config
["osm"]["vdu_id"] = vdu_id
1595 namespace
+= ".{}".format(kdu_name
)
1596 element_type
= "KDU"
1597 element_under_configuration
= kdu_name
1598 osm_config
["osm"]["kdu_name"] = kdu_name
1601 if base_folder
["pkg-dir"]:
1602 artifact_path
= "{}/{}/{}/{}".format(
1603 base_folder
["folder"],
1604 base_folder
["pkg-dir"],
1607 in ("native_charm", "lxc_proxy_charm", "k8s_proxy_charm")
1612 artifact_path
= "{}/Scripts/{}/{}/".format(
1613 base_folder
["folder"],
1616 in ("native_charm", "lxc_proxy_charm", "k8s_proxy_charm")
1621 self
.logger
.debug("Artifact path > {}".format(artifact_path
))
1623 # get initial_config_primitive_list that applies to this element
1624 initial_config_primitive_list
= config_descriptor
.get(
1625 "initial-config-primitive"
1629 "Initial config primitive list > {}".format(
1630 initial_config_primitive_list
1634 # add config if not present for NS charm
1635 ee_descriptor_id
= ee_config_descriptor
.get("id")
1636 self
.logger
.debug("EE Descriptor > {}".format(ee_descriptor_id
))
1637 initial_config_primitive_list
= get_ee_sorted_initial_config_primitive_list(
1638 initial_config_primitive_list
, vca_deployed
, ee_descriptor_id
1642 "Initial config primitive list #2 > {}".format(
1643 initial_config_primitive_list
1646 # n2vc_redesign STEP 3.1
1647 # find old ee_id if exists
1648 ee_id
= vca_deployed
.get("ee_id")
1650 vca_id
= self
.get_vca_id(db_vnfr
, db_nsr
)
1651 # create or register execution environment in VCA
1652 if vca_type
in ("lxc_proxy_charm", "k8s_proxy_charm", "helm-v3"):
1653 self
._write
_configuration
_status
(
1655 vca_index
=vca_index
,
1657 element_under_configuration
=element_under_configuration
,
1658 element_type
=element_type
,
1661 step
= "create execution environment"
1662 self
.logger
.debug(logging_text
+ step
)
1666 if vca_type
== "k8s_proxy_charm":
1667 ee_id
= await self
.vca_map
[vca_type
].install_k8s_proxy_charm(
1668 charm_name
=artifact_path
[artifact_path
.rfind("/") + 1 :],
1669 namespace
=namespace
,
1670 artifact_path
=artifact_path
,
1674 elif vca_type
== "helm-v3":
1675 ee_id
, credentials
= await self
.vca_map
[
1677 ].create_execution_environment(
1682 artifact_path
=artifact_path
,
1683 chart_model
=vca_name
,
1687 ee_id
, credentials
= await self
.vca_map
[
1689 ].create_execution_environment(
1690 namespace
=namespace
,
1696 elif vca_type
== "native_charm":
1697 step
= "Waiting to VM being up and getting IP address"
1698 self
.logger
.debug(logging_text
+ step
)
1699 rw_mgmt_ip
= await self
.wait_vm_up_insert_key_ro(
1708 credentials
= {"hostname": rw_mgmt_ip
}
1710 username
= deep_get(
1711 config_descriptor
, ("config-access", "ssh-access", "default-user")
1713 # TODO remove this when changes on IM regarding config-access:ssh-access:default-user were
1714 # merged. Meanwhile let's get username from initial-config-primitive
1715 if not username
and initial_config_primitive_list
:
1716 for config_primitive
in initial_config_primitive_list
:
1717 for param
in config_primitive
.get("parameter", ()):
1718 if param
["name"] == "ssh-username":
1719 username
= param
["value"]
1723 "Cannot determine the username neither with 'initial-config-primitive' nor with "
1724 "'config-access.ssh-access.default-user'"
1726 credentials
["username"] = username
1727 # n2vc_redesign STEP 3.2
1729 self
._write
_configuration
_status
(
1731 vca_index
=vca_index
,
1732 status
="REGISTERING",
1733 element_under_configuration
=element_under_configuration
,
1734 element_type
=element_type
,
1737 step
= "register execution environment {}".format(credentials
)
1738 self
.logger
.debug(logging_text
+ step
)
1739 ee_id
= await self
.vca_map
[vca_type
].register_execution_environment(
1740 credentials
=credentials
,
1741 namespace
=namespace
,
1746 # for compatibility with MON/POL modules, the need model and application name at database
1747 # TODO ask MON/POL if needed to not assuming anymore the format "model_name.application_name"
1748 ee_id_parts
= ee_id
.split(".")
1749 db_nsr_update
= {db_update_entry
+ "ee_id": ee_id
}
1750 if len(ee_id_parts
) >= 2:
1751 model_name
= ee_id_parts
[0]
1752 application_name
= ee_id_parts
[1]
1753 db_nsr_update
[db_update_entry
+ "model"] = model_name
1754 db_nsr_update
[db_update_entry
+ "application"] = application_name
1756 # n2vc_redesign STEP 3.3
1757 step
= "Install configuration Software"
1759 self
._write
_configuration
_status
(
1761 vca_index
=vca_index
,
1762 status
="INSTALLING SW",
1763 element_under_configuration
=element_under_configuration
,
1764 element_type
=element_type
,
1765 other_update
=db_nsr_update
,
1768 # TODO check if already done
1769 self
.logger
.debug(logging_text
+ step
)
1771 if vca_type
== "native_charm":
1772 config_primitive
= next(
1773 (p
for p
in initial_config_primitive_list
if p
["name"] == "config"),
1776 if config_primitive
:
1777 config
= self
._map
_primitive
_params
(
1778 config_primitive
, {}, deploy_params
1781 if vca_type
== "lxc_proxy_charm":
1782 if element_type
== "NS":
1783 num_units
= db_nsr
.get("config-units") or 1
1784 elif element_type
== "VNF":
1785 num_units
= db_vnfr
.get("config-units") or 1
1786 elif element_type
== "VDU":
1787 for v
in db_vnfr
["vdur"]:
1788 if vdu_id
== v
["vdu-id-ref"]:
1789 num_units
= v
.get("config-units") or 1
1791 if vca_type
!= "k8s_proxy_charm":
1792 await self
.vca_map
[vca_type
].install_configuration_sw(
1794 artifact_path
=artifact_path
,
1797 num_units
=num_units
,
1802 # write in db flag of configuration_sw already installed
1804 "nsrs", nsr_id
, {db_update_entry
+ "config_sw_installed": True}
1807 # add relations for this VCA (wait for other peers related with this VCA)
1808 is_relation_added
= await self
._add
_vca
_relations
(
1809 logging_text
=logging_text
,
1812 vca_index
=vca_index
,
1815 if not is_relation_added
:
1816 raise LcmException("Relations could not be added to VCA.")
1818 # if SSH access is required, then get execution environment SSH public
1819 # if native charm we have waited already to VM be UP
1820 if vca_type
in ("k8s_proxy_charm", "lxc_proxy_charm", "helm-v3"):
1823 # self.logger.debug("get ssh key block")
1825 config_descriptor
, ("config-access", "ssh-access", "required")
1827 # self.logger.debug("ssh key needed")
1828 # Needed to inject a ssh key
1831 ("config-access", "ssh-access", "default-user"),
1833 step
= "Install configuration Software, getting public ssh key"
1834 pub_key
= await self
.vca_map
[vca_type
].get_ee_ssh_public__key(
1835 ee_id
=ee_id
, db_dict
=db_dict
, vca_id
=vca_id
1838 step
= "Insert public key into VM user={} ssh_key={}".format(
1842 # self.logger.debug("no need to get ssh key")
1843 step
= "Waiting to VM being up and getting IP address"
1844 self
.logger
.debug(logging_text
+ step
)
1846 # default rw_mgmt_ip to None, avoiding the non definition of the variable
1849 # n2vc_redesign STEP 5.1
1850 # wait for RO (ip-address) Insert pub_key into VM
1853 rw_mgmt_ip
, services
= await self
.wait_kdu_up(
1854 logging_text
, nsr_id
, vnfr_id
, kdu_name
1856 vnfd
= self
.db
.get_one(
1858 {"_id": f
'{db_vnfr["vnfd-id"]}:{db_vnfr["revision"]}'},
1860 kdu
= get_kdu(vnfd
, kdu_name
)
1862 service
["name"] for service
in get_kdu_services(kdu
)
1864 exposed_services
= []
1865 for service
in services
:
1866 if any(s
in service
["name"] for s
in kdu_services
):
1867 exposed_services
.append(service
)
1868 await self
.vca_map
[vca_type
].exec_primitive(
1870 primitive_name
="config",
1872 "osm-config": json
.dumps(
1874 k8s
={"services": exposed_services
}
1881 # This verification is needed in order to avoid trying to add a public key
1882 # to a VM, when the VNF is a KNF (in the edge case where the user creates a VCA
1883 # for a KNF and not for its KDUs, the previous verification gives False, and the code
1884 # jumps to this block, meaning that there is the need to verify if the VNF is actually a VNF
1886 elif db_vnfr
.get("vdur"):
1887 rw_mgmt_ip
= await self
.wait_vm_up_insert_key_ro(
1897 self
.logger
.debug(logging_text
+ " VM_ip_address={}".format(rw_mgmt_ip
))
1899 # store rw_mgmt_ip in deploy params for later replacement
1900 deploy_params
["rw_mgmt_ip"] = rw_mgmt_ip
1902 # n2vc_redesign STEP 6 Execute initial config primitive
1903 step
= "execute initial config primitive"
1905 # wait for dependent primitives execution (NS -> VNF -> VDU)
1906 if initial_config_primitive_list
:
1907 await self
._wait
_dependent
_n
2vc
(nsr_id
, vca_deployed_list
, vca_index
)
1909 # stage, in function of element type: vdu, kdu, vnf or ns
1910 my_vca
= vca_deployed_list
[vca_index
]
1911 if my_vca
.get("vdu_id") or my_vca
.get("kdu_name"):
1913 stage
[0] = "Stage 3/5: running Day-1 primitives for VDU."
1914 elif my_vca
.get("member-vnf-index"):
1916 stage
[0] = "Stage 4/5: running Day-1 primitives for VNF."
1919 stage
[0] = "Stage 5/5: running Day-1 primitives for NS."
1921 self
._write
_configuration
_status
(
1922 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="EXECUTING PRIMITIVE"
1925 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
)
1927 check_if_terminated_needed
= True
1928 for initial_config_primitive
in initial_config_primitive_list
:
1929 # adding information on the vca_deployed if it is a NS execution environment
1930 if not vca_deployed
["member-vnf-index"]:
1931 deploy_params
["ns_config_info"] = json
.dumps(
1932 self
._get
_ns
_config
_info
(nsr_id
)
1934 # TODO check if already done
1935 primitive_params_
= self
._map
_primitive
_params
(
1936 initial_config_primitive
, {}, deploy_params
1939 step
= "execute primitive '{}' params '{}'".format(
1940 initial_config_primitive
["name"], primitive_params_
1942 self
.logger
.debug(logging_text
+ step
)
1943 await self
.vca_map
[vca_type
].exec_primitive(
1945 primitive_name
=initial_config_primitive
["name"],
1946 params_dict
=primitive_params_
,
1951 # Once some primitive has been exec, check and write at db if it needs to exec terminated primitives
1952 if check_if_terminated_needed
:
1953 if config_descriptor
.get("terminate-config-primitive"):
1955 "nsrs", nsr_id
, {db_update_entry
+ "needed_terminate": True}
1957 check_if_terminated_needed
= False
1959 # TODO register in database that primitive is done
1961 # STEP 7 Configure metrics
1962 if vca_type
== "helm-v3":
1963 # TODO: review for those cases where the helm chart is a reference and
1964 # is not part of the NF package
1965 prometheus_jobs
= await self
.extract_prometheus_scrape_jobs(
1967 artifact_path
=artifact_path
,
1968 ee_config_descriptor
=ee_config_descriptor
,
1971 target_ip
=rw_mgmt_ip
,
1972 element_type
=element_type
,
1973 vnf_member_index
=db_vnfr
.get("member-vnf-index-ref", ""),
1975 vdu_index
=vdu_index
,
1977 kdu_index
=kdu_index
,
1983 {db_update_entry
+ "prometheus_jobs": prometheus_jobs
},
1986 for job
in prometheus_jobs
:
1989 {"job_name": job
["job_name"]},
1992 fail_on_empty
=False,
1995 step
= "instantiated at VCA"
1996 self
.logger
.debug(logging_text
+ step
)
1998 self
._write
_configuration
_status
(
1999 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="READY"
2002 except Exception as e
: # TODO not use Exception but N2VC exception
2003 # self.update_db_2("nsrs", nsr_id, {db_update_entry + "instantiation": "FAILED"})
2005 e
, (DbException
, N2VCException
, LcmException
, asyncio
.CancelledError
)
2008 "Exception while {} : {}".format(step
, e
), exc_info
=True
2010 self
._write
_configuration
_status
(
2011 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="BROKEN"
2013 raise LcmException("{}. {}".format(step
, e
)) from e
2015 def _write_ns_status(
2019 current_operation
: str,
2020 current_operation_id
: str,
2021 error_description
: str = None,
2022 error_detail
: str = None,
2023 other_update
: dict = None,
2026 Update db_nsr fields.
2029 :param current_operation:
2030 :param current_operation_id:
2031 :param error_description:
2032 :param error_detail:
2033 :param other_update: Other required changes at database if provided, will be cleared
2037 db_dict
= other_update
or {}
2040 ] = current_operation_id
# for backward compatibility
2041 db_dict
["_admin.current-operation"] = current_operation_id
2042 db_dict
["_admin.operation-type"] = (
2043 current_operation
if current_operation
!= "IDLE" else None
2045 db_dict
["currentOperation"] = current_operation
2046 db_dict
["currentOperationID"] = current_operation_id
2047 db_dict
["errorDescription"] = error_description
2048 db_dict
["errorDetail"] = error_detail
2051 db_dict
["nsState"] = ns_state
2052 self
.update_db_2("nsrs", nsr_id
, db_dict
)
2053 except DbException
as e
:
2054 self
.logger
.warn("Error writing NS status, ns={}: {}".format(nsr_id
, e
))
2056 def _write_op_status(
2060 error_message
: str = None,
2061 queuePosition
: int = 0,
2062 operation_state
: str = None,
2063 other_update
: dict = None,
2066 db_dict
= other_update
or {}
2067 db_dict
["queuePosition"] = queuePosition
2068 if isinstance(stage
, list):
2069 db_dict
["stage"] = stage
[0]
2070 db_dict
["detailed-status"] = " ".join(stage
)
2071 elif stage
is not None:
2072 db_dict
["stage"] = str(stage
)
2074 if error_message
is not None:
2075 db_dict
["errorMessage"] = error_message
2076 if operation_state
is not None:
2077 db_dict
["operationState"] = operation_state
2078 db_dict
["statusEnteredTime"] = time()
2079 self
.update_db_2("nslcmops", op_id
, db_dict
)
2080 except DbException
as e
:
2082 "Error writing OPERATION status for op_id: {} -> {}".format(op_id
, e
)
2085 def _write_all_config_status(self
, db_nsr
: dict, status
: str):
2087 nsr_id
= db_nsr
["_id"]
2088 # configurationStatus
2089 config_status
= db_nsr
.get("configurationStatus")
2092 "configurationStatus.{}.status".format(index
): status
2093 for index
, v
in enumerate(config_status
)
2097 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
2099 except DbException
as e
:
2101 "Error writing all configuration status, ns={}: {}".format(nsr_id
, e
)
2104 def _write_configuration_status(
2109 element_under_configuration
: str = None,
2110 element_type
: str = None,
2111 other_update
: dict = None,
2113 # self.logger.debug('_write_configuration_status(): vca_index={}, status={}'
2114 # .format(vca_index, status))
2117 db_path
= "configurationStatus.{}.".format(vca_index
)
2118 db_dict
= other_update
or {}
2120 db_dict
[db_path
+ "status"] = status
2121 if element_under_configuration
:
2123 db_path
+ "elementUnderConfiguration"
2124 ] = element_under_configuration
2126 db_dict
[db_path
+ "elementType"] = element_type
2127 self
.update_db_2("nsrs", nsr_id
, db_dict
)
2128 except DbException
as e
:
2130 "Error writing configuration status={}, ns={}, vca_index={}: {}".format(
2131 status
, nsr_id
, vca_index
, e
2135 async def _do_placement(self
, logging_text
, db_nslcmop
, db_vnfrs
):
2137 Check and computes the placement, (vim account where to deploy). If it is decided by an external tool, it
2138 sends the request via kafka and wait until the result is wrote at database (nslcmops _admin.plca).
2139 Database is used because the result can be obtained from a different LCM worker in case of HA.
2140 :param logging_text: contains the prefix for logging, with the ns and nslcmop identifiers
2141 :param db_nslcmop: database content of nslcmop
2142 :param db_vnfrs: database content of vnfrs, indexed by member-vnf-index.
2143 :return: True if some modification is done. Modifies database vnfrs and parameter db_vnfr with the
2144 computed 'vim-account-id'
2147 nslcmop_id
= db_nslcmop
["_id"]
2148 placement_engine
= deep_get(db_nslcmop
, ("operationParams", "placement-engine"))
2149 if placement_engine
== "PLA":
2151 logging_text
+ "Invoke and wait for placement optimization"
2153 await self
.msg
.aiowrite("pla", "get_placement", {"nslcmopId": nslcmop_id
})
2154 db_poll_interval
= 5
2155 wait
= db_poll_interval
* 10
2157 while not pla_result
and wait
>= 0:
2158 await asyncio
.sleep(db_poll_interval
)
2159 wait
-= db_poll_interval
2160 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
2161 pla_result
= deep_get(db_nslcmop
, ("_admin", "pla"))
2165 "Placement timeout for nslcmopId={}".format(nslcmop_id
)
2168 for pla_vnf
in pla_result
["vnf"]:
2169 vnfr
= db_vnfrs
.get(pla_vnf
["member-vnf-index"])
2170 if not pla_vnf
.get("vimAccountId") or not vnfr
:
2175 {"_id": vnfr
["_id"]},
2176 {"vim-account-id": pla_vnf
["vimAccountId"]},
2179 vnfr
["vim-account-id"] = pla_vnf
["vimAccountId"]
2182 def _gather_vnfr_healing_alerts(self
, vnfr
, vnfd
):
2184 nsr_id
= vnfr
["nsr-id-ref"]
2185 df
= vnfd
.get("df", [{}])[0]
2186 # Checking for auto-healing configuration
2187 if "healing-aspect" in df
:
2188 healing_aspects
= df
["healing-aspect"]
2189 for healing
in healing_aspects
:
2190 for healing_policy
in healing
.get("healing-policy", ()):
2191 vdu_id
= healing_policy
["vdu-id"]
2193 (vdur
for vdur
in vnfr
["vdur"] if vdu_id
== vdur
["vdu-id-ref"]),
2198 metric_name
= "vm_status"
2199 vdu_name
= vdur
.get("name")
2200 vnf_member_index
= vnfr
["member-vnf-index-ref"]
2202 name
= f
"healing_{uuid}"
2203 action
= healing_policy
2204 # action_on_recovery = healing.get("action-on-recovery")
2205 # cooldown_time = healing.get("cooldown-time")
2206 # day1 = healing.get("day1")
2210 "metric": metric_name
,
2213 "vnf_member_index": vnf_member_index
,
2214 "vdu_name": vdu_name
,
2216 "alarm_status": "ok",
2217 "action_type": "healing",
2220 alerts
.append(alert
)
2223 def _gather_vnfr_scaling_alerts(self
, vnfr
, vnfd
):
2225 nsr_id
= vnfr
["nsr-id-ref"]
2226 df
= vnfd
.get("df", [{}])[0]
2227 # Checking for auto-scaling configuration
2228 if "scaling-aspect" in df
:
2229 scaling_aspects
= df
["scaling-aspect"]
2230 all_vnfd_monitoring_params
= {}
2231 for ivld
in vnfd
.get("int-virtual-link-desc", ()):
2232 for mp
in ivld
.get("monitoring-parameters", ()):
2233 all_vnfd_monitoring_params
[mp
.get("id")] = mp
2234 for vdu
in vnfd
.get("vdu", ()):
2235 for mp
in vdu
.get("monitoring-parameter", ()):
2236 all_vnfd_monitoring_params
[mp
.get("id")] = mp
2237 for df
in vnfd
.get("df", ()):
2238 for mp
in df
.get("monitoring-parameter", ()):
2239 all_vnfd_monitoring_params
[mp
.get("id")] = mp
2240 for scaling_aspect
in scaling_aspects
:
2241 scaling_group_name
= scaling_aspect
.get("name", "")
2242 # Get monitored VDUs
2243 all_monitored_vdus
= set()
2244 for delta
in scaling_aspect
.get("aspect-delta-details", {}).get(
2247 for vdu_delta
in delta
.get("vdu-delta", ()):
2248 all_monitored_vdus
.add(vdu_delta
.get("id"))
2249 monitored_vdurs
= list(
2251 lambda vdur
: vdur
["vdu-id-ref"] in all_monitored_vdus
,
2255 if not monitored_vdurs
:
2257 "Scaling criteria is referring to a vnf-monitoring-param that does not contain a reference to a vdu or vnf metric"
2260 for scaling_policy
in scaling_aspect
.get("scaling-policy", ()):
2261 if scaling_policy
["scaling-type"] != "automatic":
2263 threshold_time
= scaling_policy
.get("threshold-time", "1")
2264 cooldown_time
= scaling_policy
.get("cooldown-time", "0")
2265 for scaling_criteria
in scaling_policy
["scaling-criteria"]:
2266 monitoring_param_ref
= scaling_criteria
.get(
2267 "vnf-monitoring-param-ref"
2269 vnf_monitoring_param
= all_vnfd_monitoring_params
[
2270 monitoring_param_ref
2272 for vdur
in monitored_vdurs
:
2273 vdu_id
= vdur
["vdu-id-ref"]
2274 metric_name
= vnf_monitoring_param
.get("performance-metric")
2275 metric_name
= f
"osm_{metric_name}"
2276 vnf_member_index
= vnfr
["member-vnf-index-ref"]
2277 scalein_threshold
= scaling_criteria
.get(
2278 "scale-in-threshold"
2280 scaleout_threshold
= scaling_criteria
.get(
2281 "scale-out-threshold"
2283 # Looking for min/max-number-of-instances
2284 instances_min_number
= 1
2285 instances_max_number
= 1
2286 vdu_profile
= df
["vdu-profile"]
2289 item
for item
in vdu_profile
if item
["id"] == vdu_id
2291 instances_min_number
= profile
.get(
2292 "min-number-of-instances", 1
2294 instances_max_number
= profile
.get(
2295 "max-number-of-instances", 1
2298 if scalein_threshold
:
2300 name
= f
"scalein_{uuid}"
2301 operation
= scaling_criteria
[
2302 "scale-in-relational-operation"
2304 rel_operator
= self
.rel_operation_types
.get(
2307 metric_selector
= f
'{metric_name}{{ns_id="{nsr_id}", vnf_member_index="{vnf_member_index}", vdu_id="{vdu_id}"}}'
2308 expression
= f
"(count ({metric_selector}) > {instances_min_number}) and (avg({metric_selector}) {rel_operator} {scalein_threshold})"
2311 "vnf_member_index": vnf_member_index
,
2317 "for": str(threshold_time
) + "m",
2320 action
= scaling_policy
2322 "scaling-group": scaling_group_name
,
2323 "cooldown-time": cooldown_time
,
2328 "metric": metric_name
,
2331 "vnf_member_index": vnf_member_index
,
2334 "alarm_status": "ok",
2335 "action_type": "scale_in",
2337 "prometheus_config": prom_cfg
,
2339 alerts
.append(alert
)
2341 if scaleout_threshold
:
2343 name
= f
"scaleout_{uuid}"
2344 operation
= scaling_criteria
[
2345 "scale-out-relational-operation"
2347 rel_operator
= self
.rel_operation_types
.get(
2350 metric_selector
= f
'{metric_name}{{ns_id="{nsr_id}", vnf_member_index="{vnf_member_index}", vdu_id="{vdu_id}"}}'
2351 expression
= f
"(count ({metric_selector}) < {instances_max_number}) and (avg({metric_selector}) {rel_operator} {scaleout_threshold})"
2354 "vnf_member_index": vnf_member_index
,
2360 "for": str(threshold_time
) + "m",
2363 action
= scaling_policy
2365 "scaling-group": scaling_group_name
,
2366 "cooldown-time": cooldown_time
,
2371 "metric": metric_name
,
2374 "vnf_member_index": vnf_member_index
,
2377 "alarm_status": "ok",
2378 "action_type": "scale_out",
2380 "prometheus_config": prom_cfg
,
2382 alerts
.append(alert
)
2385 def _gather_vnfr_alarm_alerts(self
, vnfr
, vnfd
):
2387 nsr_id
= vnfr
["nsr-id-ref"]
2388 vnf_member_index
= vnfr
["member-vnf-index-ref"]
2390 # Checking for VNF alarm configuration
2391 for vdur
in vnfr
["vdur"]:
2392 vdu_id
= vdur
["vdu-id-ref"]
2393 vdu
= next(filter(lambda vdu
: vdu
["id"] == vdu_id
, vnfd
["vdu"]))
2395 # Get VDU monitoring params, since alerts are based on them
2396 vdu_monitoring_params
= {}
2397 for mp
in vdu
.get("monitoring-parameter", []):
2398 vdu_monitoring_params
[mp
.get("id")] = mp
2399 if not vdu_monitoring_params
:
2401 "VDU alarm refers to a VDU monitoring param, but there are no VDU monitoring params in the VDU"
2404 # Get alarms in the VDU
2405 alarm_descriptors
= vdu
["alarm"]
2406 # Create VDU alarms for each alarm in the VDU
2407 for alarm_descriptor
in alarm_descriptors
:
2408 # Check that the VDU alarm refers to a proper monitoring param
2409 alarm_monitoring_param
= alarm_descriptor
.get(
2410 "vnf-monitoring-param-ref", ""
2412 vdu_specific_monitoring_param
= vdu_monitoring_params
.get(
2413 alarm_monitoring_param
, {}
2415 if not vdu_specific_monitoring_param
:
2417 "VDU alarm refers to a VDU monitoring param not present in the VDU"
2420 metric_name
= vdu_specific_monitoring_param
.get(
2421 "performance-metric"
2425 "VDU alarm refers to a VDU monitoring param that has no associated performance-metric"
2428 # Set params of the alarm to be created in Prometheus
2429 metric_name
= f
"osm_{metric_name}"
2430 metric_threshold
= alarm_descriptor
.get("value")
2432 alert_name
= f
"vdu_alarm_{uuid}"
2433 operation
= alarm_descriptor
["operation"]
2434 rel_operator
= self
.rel_operation_types
.get(operation
, "<=")
2435 metric_selector
= f
'{metric_name}{{ns_id="{nsr_id}", vnf_member_index="{vnf_member_index}", vdu_id="{vdu_id}"}}'
2436 expression
= f
"{metric_selector} {rel_operator} {metric_threshold}"
2439 "vnf_member_index": vnf_member_index
,
2441 "vdu_name": "{{ $labels.vdu_name }}",
2444 "alert": alert_name
,
2446 "for": "1m", # default value. Ideally, this should be related to an IM param, but there is not such param
2449 alarm_action
= dict()
2450 for action_type
in ["ok", "insufficient-data", "alarm"]:
2452 "actions" in alarm_descriptor
2453 and action_type
in alarm_descriptor
["actions"]
2455 alarm_action
[action_type
] = alarm_descriptor
["actions"][
2461 "metric": metric_name
,
2464 "vnf_member_index": vnf_member_index
,
2467 "alarm_status": "ok",
2468 "action_type": "vdu_alarm",
2469 "action": alarm_action
,
2470 "prometheus_config": prom_cfg
,
2472 alerts
.append(alert
)
2475 def update_nsrs_with_pla_result(self
, params
):
2477 nslcmop_id
= deep_get(params
, ("placement", "nslcmopId"))
2479 "nslcmops", nslcmop_id
, {"_admin.pla": params
.get("placement")}
2481 except Exception as e
:
2482 self
.logger
.warn("Update failed for nslcmop_id={}:{}".format(nslcmop_id
, e
))
2484 async def instantiate(self
, nsr_id
, nslcmop_id
):
2487 :param nsr_id: ns instance to deploy
2488 :param nslcmop_id: operation to run
2492 # Try to lock HA task here
2493 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
2494 if not task_is_locked_by_me
:
2496 "instantiate() task is not locked by me, ns={}".format(nsr_id
)
2500 logging_text
= "Task ns={} instantiate={} ".format(nsr_id
, nslcmop_id
)
2501 self
.logger
.debug(logging_text
+ "Enter")
2503 # get all needed from database
2505 # database nsrs record
2508 # database nslcmops record
2511 # update operation on nsrs
2513 # update operation on nslcmops
2514 db_nslcmop_update
= {}
2516 timeout_ns_deploy
= self
.timeout
.ns_deploy
2518 nslcmop_operation_state
= None
2519 db_vnfrs
= {} # vnf's info indexed by member-index
2521 tasks_dict_info
= {} # from task to info text
2525 "Stage 1/5: preparation of the environment.",
2526 "Waiting for previous operations to terminate.",
2529 # ^ stage, step, VIM progress
2531 # wait for any previous tasks in process
2532 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
2534 # STEP 0: Reading database (nslcmops, nsrs, nsds, vnfrs, vnfds)
2535 stage
[1] = "Reading from database."
2536 # nsState="BUILDING", currentOperation="INSTANTIATING", currentOperationID=nslcmop_id
2537 db_nsr_update
["detailed-status"] = "creating"
2538 db_nsr_update
["operational-status"] = "init"
2539 self
._write
_ns
_status
(
2541 ns_state
="BUILDING",
2542 current_operation
="INSTANTIATING",
2543 current_operation_id
=nslcmop_id
,
2544 other_update
=db_nsr_update
,
2546 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
, queuePosition
=0)
2548 # read from db: operation
2549 stage
[1] = "Getting nslcmop={} from db.".format(nslcmop_id
)
2550 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
2551 if db_nslcmop
["operationParams"].get("additionalParamsForVnf"):
2552 db_nslcmop
["operationParams"]["additionalParamsForVnf"] = json
.loads(
2553 db_nslcmop
["operationParams"]["additionalParamsForVnf"]
2555 ns_params
= db_nslcmop
.get("operationParams")
2556 if ns_params
and ns_params
.get("timeout_ns_deploy"):
2557 timeout_ns_deploy
= ns_params
["timeout_ns_deploy"]
2560 stage
[1] = "Getting nsr={} from db.".format(nsr_id
)
2561 self
.logger
.debug(logging_text
+ stage
[1])
2562 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
2563 stage
[1] = "Getting nsd={} from db.".format(db_nsr
["nsd-id"])
2564 self
.logger
.debug(logging_text
+ stage
[1])
2565 nsd
= self
.db
.get_one("nsds", {"_id": db_nsr
["nsd-id"]})
2566 self
.fs
.sync(db_nsr
["nsd-id"])
2568 # nsr_name = db_nsr["name"] # TODO short-name??
2570 # read from db: vnf's of this ns
2571 stage
[1] = "Getting vnfrs from db."
2572 self
.logger
.debug(logging_text
+ stage
[1])
2573 db_vnfrs_list
= self
.db
.get_list("vnfrs", {"nsr-id-ref": nsr_id
})
2575 # read from db: vnfd's for every vnf
2576 db_vnfds
= [] # every vnfd data
2578 # for each vnf in ns, read vnfd
2579 for vnfr
in db_vnfrs_list
:
2580 if vnfr
.get("kdur"):
2582 for kdur
in vnfr
["kdur"]:
2583 if kdur
.get("additionalParams"):
2584 kdur
["additionalParams"] = json
.loads(
2585 kdur
["additionalParams"]
2587 kdur_list
.append(kdur
)
2588 vnfr
["kdur"] = kdur_list
2590 db_vnfrs
[vnfr
["member-vnf-index-ref"]] = vnfr
2591 vnfd_id
= vnfr
["vnfd-id"]
2592 vnfd_ref
= vnfr
["vnfd-ref"]
2593 self
.fs
.sync(vnfd_id
)
2595 # if we haven't this vnfd, read it from db
2596 if vnfd_id
not in db_vnfds
:
2598 stage
[1] = "Getting vnfd={} id='{}' from db.".format(
2601 self
.logger
.debug(logging_text
+ stage
[1])
2602 vnfd
= self
.db
.get_one("vnfds", {"_id": vnfd_id
})
2605 db_vnfds
.append(vnfd
)
2607 # Get or generates the _admin.deployed.VCA list
2608 vca_deployed_list
= None
2609 if db_nsr
["_admin"].get("deployed"):
2610 vca_deployed_list
= db_nsr
["_admin"]["deployed"].get("VCA")
2611 if vca_deployed_list
is None:
2612 vca_deployed_list
= []
2613 configuration_status_list
= []
2614 db_nsr_update
["_admin.deployed.VCA"] = vca_deployed_list
2615 db_nsr_update
["configurationStatus"] = configuration_status_list
2616 # add _admin.deployed.VCA to db_nsr dictionary, value=vca_deployed_list
2617 populate_dict(db_nsr
, ("_admin", "deployed", "VCA"), vca_deployed_list
)
2618 elif isinstance(vca_deployed_list
, dict):
2619 # maintain backward compatibility. Change a dict to list at database
2620 vca_deployed_list
= list(vca_deployed_list
.values())
2621 db_nsr_update
["_admin.deployed.VCA"] = vca_deployed_list
2622 populate_dict(db_nsr
, ("_admin", "deployed", "VCA"), vca_deployed_list
)
2625 deep_get(db_nsr
, ("_admin", "deployed", "RO", "vnfd")), list
2627 populate_dict(db_nsr
, ("_admin", "deployed", "RO", "vnfd"), [])
2628 db_nsr_update
["_admin.deployed.RO.vnfd"] = []
2630 # set state to INSTANTIATED. When instantiated NBI will not delete directly
2631 db_nsr_update
["_admin.nsState"] = "INSTANTIATED"
2632 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
2634 "vnfrs", {"nsr-id-ref": nsr_id
}, {"_admin.nsState": "INSTANTIATED"}
2637 # n2vc_redesign STEP 2 Deploy Network Scenario
2638 stage
[0] = "Stage 2/5: deployment of KDUs, VMs and execution environments."
2639 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
)
2641 stage
[1] = "Deploying KDUs."
2642 # self.logger.debug(logging_text + "Before deploy_kdus")
2643 # Call to deploy_kdus in case exists the "vdu:kdu" param
2644 await self
.deploy_kdus(
2645 logging_text
=logging_text
,
2647 nslcmop_id
=nslcmop_id
,
2650 task_instantiation_info
=tasks_dict_info
,
2653 stage
[1] = "Getting VCA public key."
2654 # n2vc_redesign STEP 1 Get VCA public ssh-key
2655 # feature 1429. Add n2vc public key to needed VMs
2656 n2vc_key
= self
.n2vc
.get_public_key()
2657 n2vc_key_list
= [n2vc_key
]
2658 if self
.vca_config
.public_key
:
2659 n2vc_key_list
.append(self
.vca_config
.public_key
)
2661 stage
[1] = "Deploying NS at VIM."
2662 task_ro
= asyncio
.ensure_future(
2663 self
.instantiate_RO(
2664 logging_text
=logging_text
,
2668 db_nslcmop
=db_nslcmop
,
2671 n2vc_key_list
=n2vc_key_list
,
2675 self
.lcm_tasks
.register("ns", nsr_id
, nslcmop_id
, "instantiate_RO", task_ro
)
2676 tasks_dict_info
[task_ro
] = "Deploying at VIM"
2678 # n2vc_redesign STEP 3 to 6 Deploy N2VC
2679 stage
[1] = "Deploying Execution Environments."
2680 self
.logger
.debug(logging_text
+ stage
[1])
2682 # create namespace and certificate if any helm based EE is present in the NS
2683 if check_helm_ee_in_ns(db_vnfds
):
2684 await self
.vca_map
["helm-v3"].setup_ns_namespace(
2687 # create TLS certificates
2688 await self
.vca_map
["helm-v3"].create_tls_certificate(
2689 secret_name
=self
.EE_TLS_NAME
,
2692 usage
="server auth",
2696 nsi_id
= None # TODO put nsi_id when this nsr belongs to a NSI
2697 for vnf_profile
in get_vnf_profiles(nsd
):
2698 vnfd_id
= vnf_profile
["vnfd-id"]
2699 vnfd
= find_in_list(db_vnfds
, lambda a_vnf
: a_vnf
["id"] == vnfd_id
)
2700 member_vnf_index
= str(vnf_profile
["id"])
2701 db_vnfr
= db_vnfrs
[member_vnf_index
]
2702 base_folder
= vnfd
["_admin"]["storage"]
2709 # Get additional parameters
2710 deploy_params
= {"OSM": get_osm_params(db_vnfr
)}
2711 if db_vnfr
.get("additionalParamsForVnf"):
2712 deploy_params
.update(
2713 parse_yaml_strings(db_vnfr
["additionalParamsForVnf"].copy())
2716 descriptor_config
= get_configuration(vnfd
, vnfd
["id"])
2717 if descriptor_config
:
2719 logging_text
=logging_text
2720 + "member_vnf_index={} ".format(member_vnf_index
),
2723 nslcmop_id
=nslcmop_id
,
2729 member_vnf_index
=member_vnf_index
,
2730 vdu_index
=vdu_index
,
2731 kdu_index
=kdu_index
,
2733 deploy_params
=deploy_params
,
2734 descriptor_config
=descriptor_config
,
2735 base_folder
=base_folder
,
2736 task_instantiation_info
=tasks_dict_info
,
2740 # Deploy charms for each VDU that supports one.
2741 for vdud
in get_vdu_list(vnfd
):
2743 descriptor_config
= get_configuration(vnfd
, vdu_id
)
2744 vdur
= find_in_list(
2745 db_vnfr
["vdur"], lambda vdu
: vdu
["vdu-id-ref"] == vdu_id
2748 if vdur
.get("additionalParams"):
2749 deploy_params_vdu
= parse_yaml_strings(vdur
["additionalParams"])
2751 deploy_params_vdu
= deploy_params
2752 deploy_params_vdu
["OSM"] = get_osm_params(
2753 db_vnfr
, vdu_id
, vdu_count_index
=0
2755 vdud_count
= get_number_of_instances(vnfd
, vdu_id
)
2757 self
.logger
.debug("VDUD > {}".format(vdud
))
2759 "Descriptor config > {}".format(descriptor_config
)
2761 if descriptor_config
:
2765 for vdu_index
in range(vdud_count
):
2766 # TODO vnfr_params["rw_mgmt_ip"] = vdur["ip-address"]
2768 logging_text
=logging_text
2769 + "member_vnf_index={}, vdu_id={}, vdu_index={} ".format(
2770 member_vnf_index
, vdu_id
, vdu_index
2774 nslcmop_id
=nslcmop_id
,
2780 kdu_index
=kdu_index
,
2781 member_vnf_index
=member_vnf_index
,
2782 vdu_index
=vdu_index
,
2784 deploy_params
=deploy_params_vdu
,
2785 descriptor_config
=descriptor_config
,
2786 base_folder
=base_folder
,
2787 task_instantiation_info
=tasks_dict_info
,
2790 for kdud
in get_kdu_list(vnfd
):
2791 kdu_name
= kdud
["name"]
2792 descriptor_config
= get_configuration(vnfd
, kdu_name
)
2793 if descriptor_config
:
2797 kdu_index
, kdur
= next(
2799 for x
in enumerate(db_vnfr
["kdur"])
2800 if x
[1]["kdu-name"] == kdu_name
2802 deploy_params_kdu
= {"OSM": get_osm_params(db_vnfr
)}
2803 if kdur
.get("additionalParams"):
2804 deploy_params_kdu
.update(
2805 parse_yaml_strings(kdur
["additionalParams"].copy())
2809 logging_text
=logging_text
,
2812 nslcmop_id
=nslcmop_id
,
2818 member_vnf_index
=member_vnf_index
,
2819 vdu_index
=vdu_index
,
2820 kdu_index
=kdu_index
,
2822 deploy_params
=deploy_params_kdu
,
2823 descriptor_config
=descriptor_config
,
2824 base_folder
=base_folder
,
2825 task_instantiation_info
=tasks_dict_info
,
2829 # Check if each vnf has exporter for metric collection if so update prometheus job records
2830 if "exporters-endpoints" in vnfd
.get("df")[0]:
2831 exporter_config
= vnfd
.get("df")[0].get("exporters-endpoints")
2832 self
.logger
.debug("exporter config :{}".format(exporter_config
))
2833 artifact_path
= "{}/{}/{}".format(
2834 base_folder
["folder"],
2835 base_folder
["pkg-dir"],
2836 "exporter-endpoint",
2839 ee_config_descriptor
= exporter_config
2840 vnfr_id
= db_vnfr
["id"]
2841 rw_mgmt_ip
= await self
.wait_vm_up_insert_key_ro(
2850 self
.logger
.debug("rw_mgmt_ip:{}".format(rw_mgmt_ip
))
2851 self
.logger
.debug("Artifact_path:{}".format(artifact_path
))
2852 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnfr_id
})
2853 vdu_id_for_prom
= None
2854 vdu_index_for_prom
= None
2855 for x
in get_iterable(db_vnfr
, "vdur"):
2856 vdu_id_for_prom
= x
.get("vdu-id-ref")
2857 vdu_index_for_prom
= x
.get("count-index")
2858 prometheus_jobs
= await self
.extract_prometheus_scrape_jobs(
2860 artifact_path
=artifact_path
,
2861 ee_config_descriptor
=ee_config_descriptor
,
2864 target_ip
=rw_mgmt_ip
,
2866 vdu_id
=vdu_id_for_prom
,
2867 vdu_index
=vdu_index_for_prom
,
2870 self
.logger
.debug("Prometheus job:{}".format(prometheus_jobs
))
2872 db_nsr_update
["_admin.deployed.prometheus_jobs"] = prometheus_jobs
2879 for job
in prometheus_jobs
:
2882 {"job_name": job
["job_name"]},
2885 fail_on_empty
=False,
2888 # Check if this NS has a charm configuration
2889 descriptor_config
= nsd
.get("ns-configuration")
2890 if descriptor_config
and descriptor_config
.get("juju"):
2893 member_vnf_index
= None
2900 # Get additional parameters
2901 deploy_params
= {"OSM": {"vim_account_id": ns_params
["vimAccountId"]}}
2902 if db_nsr
.get("additionalParamsForNs"):
2903 deploy_params
.update(
2904 parse_yaml_strings(db_nsr
["additionalParamsForNs"].copy())
2906 base_folder
= nsd
["_admin"]["storage"]
2908 logging_text
=logging_text
,
2911 nslcmop_id
=nslcmop_id
,
2917 member_vnf_index
=member_vnf_index
,
2918 vdu_index
=vdu_index
,
2919 kdu_index
=kdu_index
,
2921 deploy_params
=deploy_params
,
2922 descriptor_config
=descriptor_config
,
2923 base_folder
=base_folder
,
2924 task_instantiation_info
=tasks_dict_info
,
2928 # rest of staff will be done at finally
2931 ROclient
.ROClientException
,
2937 logging_text
+ "Exit Exception while '{}': {}".format(stage
[1], e
)
2940 except asyncio
.CancelledError
:
2942 logging_text
+ "Cancelled Exception while '{}'".format(stage
[1])
2944 exc
= "Operation was cancelled"
2945 except Exception as e
:
2946 exc
= traceback
.format_exc()
2947 self
.logger
.critical(
2948 logging_text
+ "Exit Exception while '{}': {}".format(stage
[1], e
),
2953 error_list
.append(str(exc
))
2955 # wait for pending tasks
2957 stage
[1] = "Waiting for instantiate pending tasks."
2958 self
.logger
.debug(logging_text
+ stage
[1])
2959 error_list
+= await self
._wait
_for
_tasks
(
2967 stage
[1] = stage
[2] = ""
2968 except asyncio
.CancelledError
:
2969 error_list
.append("Cancelled")
2970 await self
._cancel
_pending
_tasks
(logging_text
, tasks_dict_info
)
2971 await self
._wait
_for
_tasks
(
2979 except Exception as exc
:
2980 error_list
.append(str(exc
))
2982 # update operation-status
2983 db_nsr_update
["operational-status"] = "running"
2984 # let's begin with VCA 'configured' status (later we can change it)
2985 db_nsr_update
["config-status"] = "configured"
2986 for task
, task_name
in tasks_dict_info
.items():
2987 if not task
.done() or task
.cancelled() or task
.exception():
2988 if task_name
.startswith(self
.task_name_deploy_vca
):
2989 # A N2VC task is pending
2990 db_nsr_update
["config-status"] = "failed"
2992 # RO or KDU task is pending
2993 db_nsr_update
["operational-status"] = "failed"
2995 # update status at database
2997 error_detail
= ". ".join(error_list
)
2998 self
.logger
.error(logging_text
+ error_detail
)
2999 error_description_nslcmop
= "{} Detail: {}".format(
3000 stage
[0], error_detail
3002 error_description_nsr
= "Operation: INSTANTIATING.{}, {}".format(
3003 nslcmop_id
, stage
[0]
3006 db_nsr_update
["detailed-status"] = (
3007 error_description_nsr
+ " Detail: " + error_detail
3009 db_nslcmop_update
["detailed-status"] = error_detail
3010 nslcmop_operation_state
= "FAILED"
3014 error_description_nsr
= error_description_nslcmop
= None
3016 db_nsr_update
["detailed-status"] = "Done"
3017 db_nslcmop_update
["detailed-status"] = "Done"
3018 nslcmop_operation_state
= "COMPLETED"
3019 # Gather auto-healing and auto-scaling alerts for each vnfr
3022 for vnfr
in self
.db
.get_list("vnfrs", {"nsr-id-ref": nsr_id
}):
3024 (sub
for sub
in db_vnfds
if sub
["_id"] == vnfr
["vnfd-id"]), None
3026 healing_alerts
= self
._gather
_vnfr
_healing
_alerts
(vnfr
, vnfd
)
3027 for alert
in healing_alerts
:
3028 self
.logger
.info(f
"Storing healing alert in MongoDB: {alert}")
3029 self
.db
.create("alerts", alert
)
3031 scaling_alerts
= self
._gather
_vnfr
_scaling
_alerts
(vnfr
, vnfd
)
3032 for alert
in scaling_alerts
:
3033 self
.logger
.info(f
"Storing scaling alert in MongoDB: {alert}")
3034 self
.db
.create("alerts", alert
)
3036 alarm_alerts
= self
._gather
_vnfr
_alarm
_alerts
(vnfr
, vnfd
)
3037 for alert
in alarm_alerts
:
3038 self
.logger
.info(f
"Storing VNF alarm alert in MongoDB: {alert}")
3039 self
.db
.create("alerts", alert
)
3041 self
._write
_ns
_status
(
3044 current_operation
="IDLE",
3045 current_operation_id
=None,
3046 error_description
=error_description_nsr
,
3047 error_detail
=error_detail
,
3048 other_update
=db_nsr_update
,
3050 self
._write
_op
_status
(
3053 error_message
=error_description_nslcmop
,
3054 operation_state
=nslcmop_operation_state
,
3055 other_update
=db_nslcmop_update
,
3058 if nslcmop_operation_state
:
3060 await self
.msg
.aiowrite(
3065 "nslcmop_id": nslcmop_id
,
3066 "operationState": nslcmop_operation_state
,
3067 "startTime": db_nslcmop
["startTime"],
3068 "links": db_nslcmop
["links"],
3069 "operationParams": {
3070 "nsInstanceId": nsr_id
,
3071 "nsdId": db_nsr
["nsd-id"],
3075 except Exception as e
:
3077 logging_text
+ "kafka_write notification Exception {}".format(e
)
3080 self
.logger
.debug(logging_text
+ "Exit")
3081 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_instantiate")
3083 def _get_vnfd(self
, vnfd_id
: str, projects_read
: str, cached_vnfds
: Dict
[str, Any
]):
3084 if vnfd_id
not in cached_vnfds
:
3085 cached_vnfds
[vnfd_id
] = self
.db
.get_one(
3086 "vnfds", {"id": vnfd_id
, "_admin.projects_read": projects_read
}
3088 return cached_vnfds
[vnfd_id
]
3090 def _get_vnfr(self
, nsr_id
: str, vnf_profile_id
: str, cached_vnfrs
: Dict
[str, Any
]):
3091 if vnf_profile_id
not in cached_vnfrs
:
3092 cached_vnfrs
[vnf_profile_id
] = self
.db
.get_one(
3095 "member-vnf-index-ref": vnf_profile_id
,
3096 "nsr-id-ref": nsr_id
,
3099 return cached_vnfrs
[vnf_profile_id
]
3101 def _is_deployed_vca_in_relation(
3102 self
, vca
: DeployedVCA
, relation
: Relation
3105 for endpoint
in (relation
.provider
, relation
.requirer
):
3106 if endpoint
["kdu-resource-profile-id"]:
3109 vca
.vnf_profile_id
== endpoint
.vnf_profile_id
3110 and vca
.vdu_profile_id
== endpoint
.vdu_profile_id
3111 and vca
.execution_environment_ref
== endpoint
.execution_environment_ref
3117 def _update_ee_relation_data_with_implicit_data(
3118 self
, nsr_id
, nsd
, ee_relation_data
, cached_vnfds
, vnf_profile_id
: str = None
3120 ee_relation_data
= safe_get_ee_relation(
3121 nsr_id
, ee_relation_data
, vnf_profile_id
=vnf_profile_id
3123 ee_relation_level
= EELevel
.get_level(ee_relation_data
)
3124 if (ee_relation_level
in (EELevel
.VNF
, EELevel
.VDU
)) and not ee_relation_data
[
3125 "execution-environment-ref"
3127 vnf_profile
= get_vnf_profile(nsd
, ee_relation_data
["vnf-profile-id"])
3128 vnfd_id
= vnf_profile
["vnfd-id"]
3129 project
= nsd
["_admin"]["projects_read"][0]
3130 db_vnfd
= self
._get
_vnfd
(vnfd_id
, project
, cached_vnfds
)
3133 if ee_relation_level
== EELevel
.VNF
3134 else ee_relation_data
["vdu-profile-id"]
3136 ee
= get_juju_ee_ref(db_vnfd
, entity_id
)
3139 f
"not execution environments found for ee_relation {ee_relation_data}"
3141 ee_relation_data
["execution-environment-ref"] = ee
["id"]
3142 return ee_relation_data
3144 def _get_ns_relations(
3147 nsd
: Dict
[str, Any
],
3149 cached_vnfds
: Dict
[str, Any
],
3150 ) -> List
[Relation
]:
3152 db_ns_relations
= get_ns_configuration_relation_list(nsd
)
3153 for r
in db_ns_relations
:
3154 provider_dict
= None
3155 requirer_dict
= None
3156 if all(key
in r
for key
in ("provider", "requirer")):
3157 provider_dict
= r
["provider"]
3158 requirer_dict
= r
["requirer"]
3159 elif "entities" in r
:
3160 provider_id
= r
["entities"][0]["id"]
3163 "endpoint": r
["entities"][0]["endpoint"],
3165 if provider_id
!= nsd
["id"]:
3166 provider_dict
["vnf-profile-id"] = provider_id
3167 requirer_id
= r
["entities"][1]["id"]
3170 "endpoint": r
["entities"][1]["endpoint"],
3172 if requirer_id
!= nsd
["id"]:
3173 requirer_dict
["vnf-profile-id"] = requirer_id
3176 "provider/requirer or entities must be included in the relation."
3178 relation_provider
= self
._update
_ee
_relation
_data
_with
_implicit
_data
(
3179 nsr_id
, nsd
, provider_dict
, cached_vnfds
3181 relation_requirer
= self
._update
_ee
_relation
_data
_with
_implicit
_data
(
3182 nsr_id
, nsd
, requirer_dict
, cached_vnfds
3184 provider
= EERelation(relation_provider
)
3185 requirer
= EERelation(relation_requirer
)
3186 relation
= Relation(r
["name"], provider
, requirer
)
3187 vca_in_relation
= self
._is
_deployed
_vca
_in
_relation
(vca
, relation
)
3189 relations
.append(relation
)
3192 def _get_vnf_relations(
3195 nsd
: Dict
[str, Any
],
3197 cached_vnfds
: Dict
[str, Any
],
3198 ) -> List
[Relation
]:
3200 if vca
.target_element
== "ns":
3201 self
.logger
.debug("VCA is a NS charm, not a VNF.")
3203 vnf_profile
= get_vnf_profile(nsd
, vca
.vnf_profile_id
)
3204 vnf_profile_id
= vnf_profile
["id"]
3205 vnfd_id
= vnf_profile
["vnfd-id"]
3206 project
= nsd
["_admin"]["projects_read"][0]
3207 db_vnfd
= self
._get
_vnfd
(vnfd_id
, project
, cached_vnfds
)
3208 db_vnf_relations
= get_relation_list(db_vnfd
, vnfd_id
)
3209 for r
in db_vnf_relations
:
3210 provider_dict
= None
3211 requirer_dict
= None
3212 if all(key
in r
for key
in ("provider", "requirer")):
3213 provider_dict
= r
["provider"]
3214 requirer_dict
= r
["requirer"]
3215 elif "entities" in r
:
3216 provider_id
= r
["entities"][0]["id"]
3219 "vnf-profile-id": vnf_profile_id
,
3220 "endpoint": r
["entities"][0]["endpoint"],
3222 if provider_id
!= vnfd_id
:
3223 provider_dict
["vdu-profile-id"] = provider_id
3224 requirer_id
= r
["entities"][1]["id"]
3227 "vnf-profile-id": vnf_profile_id
,
3228 "endpoint": r
["entities"][1]["endpoint"],
3230 if requirer_id
!= vnfd_id
:
3231 requirer_dict
["vdu-profile-id"] = requirer_id
3234 "provider/requirer or entities must be included in the relation."
3236 relation_provider
= self
._update
_ee
_relation
_data
_with
_implicit
_data
(
3237 nsr_id
, nsd
, provider_dict
, cached_vnfds
, vnf_profile_id
=vnf_profile_id
3239 relation_requirer
= self
._update
_ee
_relation
_data
_with
_implicit
_data
(
3240 nsr_id
, nsd
, requirer_dict
, cached_vnfds
, vnf_profile_id
=vnf_profile_id
3242 provider
= EERelation(relation_provider
)
3243 requirer
= EERelation(relation_requirer
)
3244 relation
= Relation(r
["name"], provider
, requirer
)
3245 vca_in_relation
= self
._is
_deployed
_vca
_in
_relation
(vca
, relation
)
3247 relations
.append(relation
)
3250 def _get_kdu_resource_data(
3252 ee_relation
: EERelation
,
3253 db_nsr
: Dict
[str, Any
],
3254 cached_vnfds
: Dict
[str, Any
],
3255 ) -> DeployedK8sResource
:
3256 nsd
= get_nsd(db_nsr
)
3257 vnf_profiles
= get_vnf_profiles(nsd
)
3258 vnfd_id
= find_in_list(
3260 lambda vnf_profile
: vnf_profile
["id"] == ee_relation
.vnf_profile_id
,
3262 project
= nsd
["_admin"]["projects_read"][0]
3263 db_vnfd
= self
._get
_vnfd
(vnfd_id
, project
, cached_vnfds
)
3264 kdu_resource_profile
= get_kdu_resource_profile(
3265 db_vnfd
, ee_relation
.kdu_resource_profile_id
3267 kdu_name
= kdu_resource_profile
["kdu-name"]
3268 deployed_kdu
, _
= get_deployed_kdu(
3269 db_nsr
.get("_admin", ()).get("deployed", ()),
3271 ee_relation
.vnf_profile_id
,
3273 deployed_kdu
.update({"resource-name": kdu_resource_profile
["resource-name"]})
3276 def _get_deployed_component(
3278 ee_relation
: EERelation
,
3279 db_nsr
: Dict
[str, Any
],
3280 cached_vnfds
: Dict
[str, Any
],
3281 ) -> DeployedComponent
:
3282 nsr_id
= db_nsr
["_id"]
3283 deployed_component
= None
3284 ee_level
= EELevel
.get_level(ee_relation
)
3285 if ee_level
== EELevel
.NS
:
3286 vca
= get_deployed_vca(db_nsr
, {"vdu_id": None, "member-vnf-index": None})
3288 deployed_component
= DeployedVCA(nsr_id
, vca
)
3289 elif ee_level
== EELevel
.VNF
:
3290 vca
= get_deployed_vca(
3294 "member-vnf-index": ee_relation
.vnf_profile_id
,
3295 "ee_descriptor_id": ee_relation
.execution_environment_ref
,
3299 deployed_component
= DeployedVCA(nsr_id
, vca
)
3300 elif ee_level
== EELevel
.VDU
:
3301 vca
= get_deployed_vca(
3304 "vdu_id": ee_relation
.vdu_profile_id
,
3305 "member-vnf-index": ee_relation
.vnf_profile_id
,
3306 "ee_descriptor_id": ee_relation
.execution_environment_ref
,
3310 deployed_component
= DeployedVCA(nsr_id
, vca
)
3311 elif ee_level
== EELevel
.KDU
:
3312 kdu_resource_data
= self
._get
_kdu
_resource
_data
(
3313 ee_relation
, db_nsr
, cached_vnfds
3315 if kdu_resource_data
:
3316 deployed_component
= DeployedK8sResource(kdu_resource_data
)
3317 return deployed_component
3319 async def _add_relation(
3323 db_nsr
: Dict
[str, Any
],
3324 cached_vnfds
: Dict
[str, Any
],
3325 cached_vnfrs
: Dict
[str, Any
],
3327 deployed_provider
= self
._get
_deployed
_component
(
3328 relation
.provider
, db_nsr
, cached_vnfds
3330 deployed_requirer
= self
._get
_deployed
_component
(
3331 relation
.requirer
, db_nsr
, cached_vnfds
3335 and deployed_requirer
3336 and deployed_provider
.config_sw_installed
3337 and deployed_requirer
.config_sw_installed
3339 provider_db_vnfr
= (
3341 relation
.provider
.nsr_id
,
3342 relation
.provider
.vnf_profile_id
,
3345 if relation
.provider
.vnf_profile_id
3348 requirer_db_vnfr
= (
3350 relation
.requirer
.nsr_id
,
3351 relation
.requirer
.vnf_profile_id
,
3354 if relation
.requirer
.vnf_profile_id
3357 provider_vca_id
= self
.get_vca_id(provider_db_vnfr
, db_nsr
)
3358 requirer_vca_id
= self
.get_vca_id(requirer_db_vnfr
, db_nsr
)
3359 provider_relation_endpoint
= RelationEndpoint(
3360 deployed_provider
.ee_id
,
3362 relation
.provider
.endpoint
,
3364 requirer_relation_endpoint
= RelationEndpoint(
3365 deployed_requirer
.ee_id
,
3367 relation
.requirer
.endpoint
,
3370 await self
.vca_map
[vca_type
].add_relation(
3371 provider
=provider_relation_endpoint
,
3372 requirer
=requirer_relation_endpoint
,
3374 except N2VCException
as exception
:
3375 self
.logger
.error(exception
)
3376 raise LcmException(exception
)
3380 async def _add_vca_relations(
3386 timeout
: int = 3600,
3389 # 1. find all relations for this VCA
3390 # 2. wait for other peers related
3394 # STEP 1: find all relations for this VCA
3397 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
3398 nsd
= get_nsd(db_nsr
)
3401 deployed_vca_dict
= get_deployed_vca_list(db_nsr
)[vca_index
]
3402 my_vca
= DeployedVCA(nsr_id
, deployed_vca_dict
)
3407 relations
.extend(self
._get
_ns
_relations
(nsr_id
, nsd
, my_vca
, cached_vnfds
))
3408 relations
.extend(self
._get
_vnf
_relations
(nsr_id
, nsd
, my_vca
, cached_vnfds
))
3410 # if no relations, terminate
3412 self
.logger
.debug(logging_text
+ " No relations")
3415 self
.logger
.debug(logging_text
+ " adding relations {}".format(relations
))
3422 if now
- start
>= timeout
:
3423 self
.logger
.error(logging_text
+ " : timeout adding relations")
3426 # reload nsr from database (we need to update record: _admin.deployed.VCA)
3427 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
3429 # for each relation, find the VCA's related
3430 for relation
in relations
.copy():
3431 added
= await self
._add
_relation
(
3439 relations
.remove(relation
)
3442 self
.logger
.debug("Relations added")
3444 await asyncio
.sleep(5.0)
3448 except Exception as e
:
3449 self
.logger
.warn(logging_text
+ " ERROR adding relations: {}".format(e
))
3452 async def _install_kdu(
3460 k8s_instance_info
: dict,
3461 k8params
: dict = None,
3466 k8sclustertype
= k8s_instance_info
["k8scluster-type"]
3469 "collection": "nsrs",
3470 "filter": {"_id": nsr_id
},
3471 "path": nsr_db_path
,
3474 if k8s_instance_info
.get("kdu-deployment-name"):
3475 kdu_instance
= k8s_instance_info
.get("kdu-deployment-name")
3477 kdu_instance
= self
.k8scluster_map
[
3479 ].generate_kdu_instance_name(
3480 db_dict
=db_dict_install
,
3481 kdu_model
=k8s_instance_info
["kdu-model"],
3482 kdu_name
=k8s_instance_info
["kdu-name"],
3485 # Update the nsrs table with the kdu-instance value
3489 _desc
={nsr_db_path
+ ".kdu-instance": kdu_instance
},
3492 # Update the nsrs table with the actual namespace being used, if the k8scluster-type is `juju` or
3493 # `juju-bundle`. This verification is needed because there is not a standard/homogeneous namespace
3494 # between the Helm Charts and Juju Bundles-based KNFs. If we found a way of having an homogeneous
3495 # namespace, this first verification could be removed, and the next step would be done for any kind
3497 # TODO -> find a way to have an homogeneous namespace between the Helm Charts and Juju Bundles-based
3498 # KNFs (Bug 2027: https://osm.etsi.org/bugzilla/show_bug.cgi?id=2027)
3499 if k8sclustertype
in ("juju", "juju-bundle"):
3500 # First, verify if the current namespace is present in the `_admin.projects_read` (if not, it means
3501 # that the user passed a namespace which he wants its KDU to be deployed in)
3507 "_admin.projects_write": k8s_instance_info
["namespace"],
3508 "_admin.projects_read": k8s_instance_info
["namespace"],
3514 f
"Updating namespace/model for Juju Bundle from {k8s_instance_info['namespace']} to {kdu_instance}"
3519 _desc
={f
"{nsr_db_path}.namespace": kdu_instance
},
3521 k8s_instance_info
["namespace"] = kdu_instance
3523 await self
.k8scluster_map
[k8sclustertype
].install(
3524 cluster_uuid
=k8s_instance_info
["k8scluster-uuid"],
3525 kdu_model
=k8s_instance_info
["kdu-model"],
3528 db_dict
=db_dict_install
,
3530 kdu_name
=k8s_instance_info
["kdu-name"],
3531 namespace
=k8s_instance_info
["namespace"],
3532 kdu_instance
=kdu_instance
,
3536 # Obtain services to obtain management service ip
3537 services
= await self
.k8scluster_map
[k8sclustertype
].get_services(
3538 cluster_uuid
=k8s_instance_info
["k8scluster-uuid"],
3539 kdu_instance
=kdu_instance
,
3540 namespace
=k8s_instance_info
["namespace"],
3543 # Obtain management service info (if exists)
3544 vnfr_update_dict
= {}
3545 kdu_config
= get_configuration(vnfd
, kdud
["name"])
3547 target_ee_list
= kdu_config
.get("execution-environment-list", [])
3552 vnfr_update_dict
["kdur.{}.services".format(kdu_index
)] = services
3555 for service
in kdud
.get("service", [])
3556 if service
.get("mgmt-service")
3558 for mgmt_service
in mgmt_services
:
3559 for service
in services
:
3560 if service
["name"].startswith(mgmt_service
["name"]):
3561 # Mgmt service found, Obtain service ip
3562 ip
= service
.get("external_ip", service
.get("cluster_ip"))
3563 if isinstance(ip
, list) and len(ip
) == 1:
3567 "kdur.{}.ip-address".format(kdu_index
)
3570 # Check if must update also mgmt ip at the vnf
3571 service_external_cp
= mgmt_service
.get(
3572 "external-connection-point-ref"
3574 if service_external_cp
:
3576 deep_get(vnfd
, ("mgmt-interface", "cp"))
3577 == service_external_cp
3579 vnfr_update_dict
["ip-address"] = ip
3584 "external-connection-point-ref", ""
3586 == service_external_cp
,
3589 "kdur.{}.ip-address".format(kdu_index
)
3594 "Mgmt service name: {} not found".format(
3595 mgmt_service
["name"]
3599 vnfr_update_dict
["kdur.{}.status".format(kdu_index
)] = "READY"
3600 self
.update_db_2("vnfrs", vnfr_data
.get("_id"), vnfr_update_dict
)
3602 kdu_config
= get_configuration(vnfd
, k8s_instance_info
["kdu-name"])
3605 and kdu_config
.get("initial-config-primitive")
3606 and get_juju_ee_ref(vnfd
, k8s_instance_info
["kdu-name"]) is None
3608 initial_config_primitive_list
= kdu_config
.get(
3609 "initial-config-primitive"
3611 initial_config_primitive_list
.sort(key
=lambda val
: int(val
["seq"]))
3613 for initial_config_primitive
in initial_config_primitive_list
:
3614 primitive_params_
= self
._map
_primitive
_params
(
3615 initial_config_primitive
, {}, {}
3618 await asyncio
.wait_for(
3619 self
.k8scluster_map
[k8sclustertype
].exec_primitive(
3620 cluster_uuid
=k8s_instance_info
["k8scluster-uuid"],
3621 kdu_instance
=kdu_instance
,
3622 primitive_name
=initial_config_primitive
["name"],
3623 params
=primitive_params_
,
3624 db_dict
=db_dict_install
,
3630 except Exception as e
:
3631 # Prepare update db with error and raise exception
3634 "nsrs", nsr_id
, {nsr_db_path
+ ".detailed-status": str(e
)}
3638 vnfr_data
.get("_id"),
3639 {"kdur.{}.status".format(kdu_index
): "ERROR"},
3641 except Exception as error
:
3642 # ignore to keep original exception
3643 self
.logger
.warning(
3644 f
"An exception occurred while updating DB: {str(error)}"
3646 # reraise original error
3651 async def deploy_kdus(
3658 task_instantiation_info
,
3660 # Launch kdus if present in the descriptor
3662 k8scluster_id_2_uuic
= {
3663 "helm-chart-v3": {},
3667 async def _get_cluster_id(cluster_id
, cluster_type
):
3668 nonlocal k8scluster_id_2_uuic
3669 if cluster_id
in k8scluster_id_2_uuic
[cluster_type
]:
3670 return k8scluster_id_2_uuic
[cluster_type
][cluster_id
]
3672 # check if K8scluster is creating and wait look if previous tasks in process
3673 task_name
, task_dependency
= self
.lcm_tasks
.lookfor_related(
3674 "k8scluster", cluster_id
3677 text
= "Waiting for related tasks '{}' on k8scluster {} to be completed".format(
3678 task_name
, cluster_id
3680 self
.logger
.debug(logging_text
+ text
)
3681 await asyncio
.wait(task_dependency
, timeout
=3600)
3683 db_k8scluster
= self
.db
.get_one(
3684 "k8sclusters", {"_id": cluster_id
}, fail_on_empty
=False
3686 if not db_k8scluster
:
3687 raise LcmException("K8s cluster {} cannot be found".format(cluster_id
))
3689 k8s_id
= deep_get(db_k8scluster
, ("_admin", cluster_type
, "id"))
3691 if cluster_type
== "helm-chart-v3":
3693 # backward compatibility for existing clusters that have not been initialized for helm v3
3694 k8s_credentials
= yaml
.safe_dump(
3695 db_k8scluster
.get("credentials")
3697 k8s_id
, uninstall_sw
= await self
.k8sclusterhelm3
.init_env(
3698 k8s_credentials
, reuse_cluster_uuid
=cluster_id
3700 db_k8scluster_update
= {}
3701 db_k8scluster_update
["_admin.helm-chart-v3.error_msg"] = None
3702 db_k8scluster_update
["_admin.helm-chart-v3.id"] = k8s_id
3703 db_k8scluster_update
[
3704 "_admin.helm-chart-v3.created"
3706 db_k8scluster_update
[
3707 "_admin.helm-chart-v3.operationalState"
3710 "k8sclusters", cluster_id
, db_k8scluster_update
3712 except Exception as e
:
3715 + "error initializing helm-v3 cluster: {}".format(str(e
))
3718 "K8s cluster '{}' has not been initialized for '{}'".format(
3719 cluster_id
, cluster_type
3724 "K8s cluster '{}' has not been initialized for '{}'".format(
3725 cluster_id
, cluster_type
3728 k8scluster_id_2_uuic
[cluster_type
][cluster_id
] = k8s_id
3731 logging_text
+= "Deploy kdus: "
3734 db_nsr_update
= {"_admin.deployed.K8s": []}
3735 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
3738 updated_cluster_list
= []
3739 updated_v3_cluster_list
= []
3741 for vnfr_data
in db_vnfrs
.values():
3742 vca_id
= self
.get_vca_id(vnfr_data
, {})
3743 for kdu_index
, kdur
in enumerate(get_iterable(vnfr_data
, "kdur")):
3744 # Step 0: Prepare and set parameters
3745 desc_params
= parse_yaml_strings(kdur
.get("additionalParams"))
3746 vnfd_id
= vnfr_data
.get("vnfd-id")
3747 vnfd_with_id
= find_in_list(
3748 db_vnfds
, lambda vnfd
: vnfd
["_id"] == vnfd_id
3752 for kdud
in vnfd_with_id
["kdu"]
3753 if kdud
["name"] == kdur
["kdu-name"]
3755 namespace
= kdur
.get("k8s-namespace")
3756 kdu_deployment_name
= kdur
.get("kdu-deployment-name")
3757 if kdur
.get("helm-chart"):
3758 kdumodel
= kdur
["helm-chart"]
3759 # Default version: helm3, if helm-version is v2 assign v2
3760 k8sclustertype
= "helm-chart-v3"
3761 self
.logger
.debug("kdur: {}".format(kdur
))
3762 elif kdur
.get("juju-bundle"):
3763 kdumodel
= kdur
["juju-bundle"]
3764 k8sclustertype
= "juju-bundle"
3767 "kdu type for kdu='{}.{}' is neither helm-chart nor "
3768 "juju-bundle. Maybe an old NBI version is running".format(
3769 vnfr_data
["member-vnf-index-ref"], kdur
["kdu-name"]
3772 # check if kdumodel is a file and exists
3774 vnfd_with_id
= find_in_list(
3775 db_vnfds
, lambda vnfd
: vnfd
["_id"] == vnfd_id
3777 storage
= deep_get(vnfd_with_id
, ("_admin", "storage"))
3778 if storage
: # may be not present if vnfd has not artifacts
3779 # path format: /vnfdid/pkkdir/helm-charts|juju-bundles/kdumodel
3780 if storage
["pkg-dir"]:
3781 filename
= "{}/{}/{}s/{}".format(
3788 filename
= "{}/Scripts/{}s/{}".format(
3793 if self
.fs
.file_exists(
3794 filename
, mode
="file"
3795 ) or self
.fs
.file_exists(filename
, mode
="dir"):
3796 kdumodel
= self
.fs
.path
+ filename
3797 except (asyncio
.TimeoutError
, asyncio
.CancelledError
):
3799 except Exception as e
: # it is not a file
3800 self
.logger
.warning(f
"An exception occurred: {str(e)}")
3802 k8s_cluster_id
= kdur
["k8s-cluster"]["id"]
3803 step
= "Synchronize repos for k8s cluster '{}'".format(
3806 cluster_uuid
= await _get_cluster_id(k8s_cluster_id
, k8sclustertype
)
3810 k8sclustertype
== "helm-chart"
3811 and cluster_uuid
not in updated_cluster_list
3813 k8sclustertype
== "helm-chart-v3"
3814 and cluster_uuid
not in updated_v3_cluster_list
3816 del_repo_list
, added_repo_dict
= await asyncio
.ensure_future(
3817 self
.k8scluster_map
[k8sclustertype
].synchronize_repos(
3818 cluster_uuid
=cluster_uuid
3821 if del_repo_list
or added_repo_dict
:
3822 if k8sclustertype
== "helm-chart":
3824 "_admin.helm_charts_added." + item
: None
3825 for item
in del_repo_list
3828 "_admin.helm_charts_added." + item
: name
3829 for item
, name
in added_repo_dict
.items()
3831 updated_cluster_list
.append(cluster_uuid
)
3832 elif k8sclustertype
== "helm-chart-v3":
3834 "_admin.helm_charts_v3_added." + item
: None
3835 for item
in del_repo_list
3838 "_admin.helm_charts_v3_added." + item
: name
3839 for item
, name
in added_repo_dict
.items()
3841 updated_v3_cluster_list
.append(cluster_uuid
)
3843 logging_text
+ "repos synchronized on k8s cluster "
3844 "'{}' to_delete: {}, to_add: {}".format(
3845 k8s_cluster_id
, del_repo_list
, added_repo_dict
3850 {"_id": k8s_cluster_id
},
3856 step
= "Instantiating KDU {}.{} in k8s cluster {}".format(
3857 vnfr_data
["member-vnf-index-ref"],
3861 k8s_instance_info
= {
3862 "kdu-instance": None,
3863 "k8scluster-uuid": cluster_uuid
,
3864 "k8scluster-type": k8sclustertype
,
3865 "member-vnf-index": vnfr_data
["member-vnf-index-ref"],
3866 "kdu-name": kdur
["kdu-name"],
3867 "kdu-model": kdumodel
,
3868 "namespace": namespace
,
3869 "kdu-deployment-name": kdu_deployment_name
,
3871 db_path
= "_admin.deployed.K8s.{}".format(index
)
3872 db_nsr_update
[db_path
] = k8s_instance_info
3873 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
3874 vnfd_with_id
= find_in_list(
3875 db_vnfds
, lambda vnf
: vnf
["_id"] == vnfd_id
3877 task
= asyncio
.ensure_future(
3886 k8params
=desc_params
,
3891 self
.lcm_tasks
.register(
3895 "instantiate_KDU-{}".format(index
),
3898 task_instantiation_info
[task
] = "Deploying KDU {}".format(
3904 except (LcmException
, asyncio
.CancelledError
):
3906 except Exception as e
:
3907 msg
= "Exception {} while {}: {}".format(type(e
).__name
__, step
, e
)
3908 if isinstance(e
, (N2VCException
, DbException
)):
3909 self
.logger
.error(logging_text
+ msg
)
3911 self
.logger
.critical(logging_text
+ msg
, exc_info
=True)
3912 raise LcmException(msg
)
3915 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
3935 task_instantiation_info
,
3938 # launch instantiate_N2VC in a asyncio task and register task object
3939 # Look where information of this charm is at database <nsrs>._admin.deployed.VCA
3940 # if not found, create one entry and update database
3941 # fill db_nsr._admin.deployed.VCA.<index>
3944 logging_text
+ "_deploy_n2vc vnfd_id={}, vdu_id={}".format(vnfd_id
, vdu_id
)
3948 get_charm_name
= False
3949 if "execution-environment-list" in descriptor_config
:
3950 ee_list
= descriptor_config
.get("execution-environment-list", [])
3951 elif "juju" in descriptor_config
:
3952 ee_list
= [descriptor_config
] # ns charms
3953 if "execution-environment-list" not in descriptor_config
:
3954 # charm name is only required for ns charms
3955 get_charm_name
= True
3956 else: # other types as script are not supported
3959 for ee_item
in ee_list
:
3962 + "_deploy_n2vc ee_item juju={}, helm={}".format(
3963 ee_item
.get("juju"), ee_item
.get("helm-chart")
3966 ee_descriptor_id
= ee_item
.get("id")
3967 vca_name
, charm_name
, vca_type
= self
.get_vca_info(
3968 ee_item
, db_nsr
, get_charm_name
3972 logging_text
+ "skipping, non juju/charm/helm configuration"
3977 for vca_index
, vca_deployed
in enumerate(
3978 db_nsr
["_admin"]["deployed"]["VCA"]
3980 if not vca_deployed
:
3983 vca_deployed
.get("member-vnf-index") == member_vnf_index
3984 and vca_deployed
.get("vdu_id") == vdu_id
3985 and vca_deployed
.get("kdu_name") == kdu_name
3986 and vca_deployed
.get("vdu_count_index", 0) == vdu_index
3987 and vca_deployed
.get("ee_descriptor_id") == ee_descriptor_id
3991 # not found, create one.
3993 "ns" if not member_vnf_index
else "vnf/{}".format(member_vnf_index
)
3996 target
+= "/vdu/{}/{}".format(vdu_id
, vdu_index
or 0)
3998 target
+= "/kdu/{}".format(kdu_name
)
4000 "target_element": target
,
4001 # ^ target_element will replace member-vnf-index, kdu_name, vdu_id ... in a single string
4002 "member-vnf-index": member_vnf_index
,
4004 "kdu_name": kdu_name
,
4005 "vdu_count_index": vdu_index
,
4006 "operational-status": "init", # TODO revise
4007 "detailed-status": "", # TODO revise
4008 "step": "initial-deploy", # TODO revise
4010 "vdu_name": vdu_name
,
4012 "ee_descriptor_id": ee_descriptor_id
,
4013 "charm_name": charm_name
,
4017 # create VCA and configurationStatus in db
4019 "_admin.deployed.VCA.{}".format(vca_index
): vca_deployed
,
4020 "configurationStatus.{}".format(vca_index
): dict(),
4022 self
.update_db_2("nsrs", nsr_id
, db_dict
)
4024 db_nsr
["_admin"]["deployed"]["VCA"].append(vca_deployed
)
4026 self
.logger
.debug("N2VC > NSR_ID > {}".format(nsr_id
))
4027 self
.logger
.debug("N2VC > DB_NSR > {}".format(db_nsr
))
4028 self
.logger
.debug("N2VC > VCA_DEPLOYED > {}".format(vca_deployed
))
4031 task_n2vc
= asyncio
.ensure_future(
4032 self
.instantiate_N2VC(
4033 logging_text
=logging_text
,
4034 vca_index
=vca_index
,
4040 vdu_index
=vdu_index
,
4041 kdu_index
=kdu_index
,
4042 deploy_params
=deploy_params
,
4043 config_descriptor
=descriptor_config
,
4044 base_folder
=base_folder
,
4045 nslcmop_id
=nslcmop_id
,
4049 ee_config_descriptor
=ee_item
,
4052 self
.lcm_tasks
.register(
4056 "instantiate_N2VC-{}".format(vca_index
),
4059 task_instantiation_info
[
4061 ] = self
.task_name_deploy_vca
+ " {}.{}".format(
4062 member_vnf_index
or "", vdu_id
or ""
4065 def _format_additional_params(self
, params
):
4066 params
= params
or {}
4067 for key
, value
in params
.items():
4068 if str(value
).startswith("!!yaml "):
4069 params
[key
] = yaml
.safe_load(value
[7:])
4072 def _get_terminate_primitive_params(self
, seq
, vnf_index
):
4073 primitive
= seq
.get("name")
4074 primitive_params
= {}
4076 "member_vnf_index": vnf_index
,
4077 "primitive": primitive
,
4078 "primitive_params": primitive_params
,
4081 return self
._map
_primitive
_params
(seq
, params
, desc_params
)
4085 def _retry_or_skip_suboperation(self
, db_nslcmop
, op_index
):
4086 op
= deep_get(db_nslcmop
, ("_admin", "operations"), [])[op_index
]
4087 if op
.get("operationState") == "COMPLETED":
4088 # b. Skip sub-operation
4089 # _ns_execute_primitive() or RO.create_action() will NOT be executed
4090 return self
.SUBOPERATION_STATUS_SKIP
4092 # c. retry executing sub-operation
4093 # The sub-operation exists, and operationState != 'COMPLETED'
4094 # Update operationState = 'PROCESSING' to indicate a retry.
4095 operationState
= "PROCESSING"
4096 detailed_status
= "In progress"
4097 self
._update
_suboperation
_status
(
4098 db_nslcmop
, op_index
, operationState
, detailed_status
4100 # Return the sub-operation index
4101 # _ns_execute_primitive() or RO.create_action() will be called from scale()
4102 # with arguments extracted from the sub-operation
4105 # Find a sub-operation where all keys in a matching dictionary must match
4106 # Returns the index of the matching sub-operation, or SUBOPERATION_STATUS_NOT_FOUND if no match
4107 def _find_suboperation(self
, db_nslcmop
, match
):
4108 if db_nslcmop
and match
:
4109 op_list
= db_nslcmop
.get("_admin", {}).get("operations", [])
4110 for i
, op
in enumerate(op_list
):
4111 if all(op
.get(k
) == match
[k
] for k
in match
):
4113 return self
.SUBOPERATION_STATUS_NOT_FOUND
4115 # Update status for a sub-operation given its index
4116 def _update_suboperation_status(
4117 self
, db_nslcmop
, op_index
, operationState
, detailed_status
4119 # Update DB for HA tasks
4120 q_filter
= {"_id": db_nslcmop
["_id"]}
4122 "_admin.operations.{}.operationState".format(op_index
): operationState
,
4123 "_admin.operations.{}.detailed-status".format(op_index
): detailed_status
,
4126 "nslcmops", q_filter
=q_filter
, update_dict
=update_dict
, fail_on_empty
=False
4129 # Add sub-operation, return the index of the added sub-operation
4130 # Optionally, set operationState, detailed-status, and operationType
4131 # Status and type are currently set for 'scale' sub-operations:
4132 # 'operationState' : 'PROCESSING' | 'COMPLETED' | 'FAILED'
4133 # 'detailed-status' : status message
4134 # 'operationType': may be any type, in the case of scaling: 'PRE-SCALE' | 'POST-SCALE'
4135 # Status and operation type are currently only used for 'scale', but NOT for 'terminate' sub-operations.
4136 def _add_suboperation(
4144 mapped_primitive_params
,
4145 operationState
=None,
4146 detailed_status
=None,
4149 RO_scaling_info
=None,
4152 return self
.SUBOPERATION_STATUS_NOT_FOUND
4153 # Get the "_admin.operations" list, if it exists
4154 db_nslcmop_admin
= db_nslcmop
.get("_admin", {})
4155 op_list
= db_nslcmop_admin
.get("operations")
4156 # Create or append to the "_admin.operations" list
4158 "member_vnf_index": vnf_index
,
4160 "vdu_count_index": vdu_count_index
,
4161 "primitive": primitive
,
4162 "primitive_params": mapped_primitive_params
,
4165 new_op
["operationState"] = operationState
4167 new_op
["detailed-status"] = detailed_status
4169 new_op
["lcmOperationType"] = operationType
4171 new_op
["RO_nsr_id"] = RO_nsr_id
4173 new_op
["RO_scaling_info"] = RO_scaling_info
4175 # No existing operations, create key 'operations' with current operation as first list element
4176 db_nslcmop_admin
.update({"operations": [new_op
]})
4177 op_list
= db_nslcmop_admin
.get("operations")
4179 # Existing operations, append operation to list
4180 op_list
.append(new_op
)
4182 db_nslcmop_update
= {"_admin.operations": op_list
}
4183 self
.update_db_2("nslcmops", db_nslcmop
["_id"], db_nslcmop_update
)
4184 op_index
= len(op_list
) - 1
4187 # Helper methods for scale() sub-operations
4189 # pre-scale/post-scale:
4190 # Check for 3 different cases:
4191 # a. New: First time execution, return SUBOPERATION_STATUS_NEW
4192 # b. Skip: Existing sub-operation exists, operationState == 'COMPLETED', return SUBOPERATION_STATUS_SKIP
4193 # c. retry: Existing sub-operation exists, operationState != 'COMPLETED', return op_index to re-execute
4194 def _check_or_add_scale_suboperation(
4198 vnf_config_primitive
,
4202 RO_scaling_info
=None,
4204 # Find this sub-operation
4205 if RO_nsr_id
and RO_scaling_info
:
4206 operationType
= "SCALE-RO"
4208 "member_vnf_index": vnf_index
,
4209 "RO_nsr_id": RO_nsr_id
,
4210 "RO_scaling_info": RO_scaling_info
,
4214 "member_vnf_index": vnf_index
,
4215 "primitive": vnf_config_primitive
,
4216 "primitive_params": primitive_params
,
4217 "lcmOperationType": operationType
,
4219 op_index
= self
._find
_suboperation
(db_nslcmop
, match
)
4220 if op_index
== self
.SUBOPERATION_STATUS_NOT_FOUND
:
4221 # a. New sub-operation
4222 # The sub-operation does not exist, add it.
4223 # _ns_execute_primitive() will be called from scale() as usual, with non-modified arguments
4224 # The following parameters are set to None for all kind of scaling:
4226 vdu_count_index
= None
4228 if RO_nsr_id
and RO_scaling_info
:
4229 vnf_config_primitive
= None
4230 primitive_params
= None
4233 RO_scaling_info
= None
4234 # Initial status for sub-operation
4235 operationState
= "PROCESSING"
4236 detailed_status
= "In progress"
4237 # Add sub-operation for pre/post-scaling (zero or more operations)
4238 self
._add
_suboperation
(
4244 vnf_config_primitive
,
4252 return self
.SUBOPERATION_STATUS_NEW
4254 # Return either SUBOPERATION_STATUS_SKIP (operationState == 'COMPLETED'),
4255 # or op_index (operationState != 'COMPLETED')
4256 return self
._retry
_or
_skip
_suboperation
(db_nslcmop
, op_index
)
4258 # Function to return execution_environment id
4260 async def destroy_N2VC(
4268 exec_primitives
=True,
4273 Execute the terminate primitives and destroy the execution environment (if destroy_ee=False
4274 :param logging_text:
4276 :param vca_deployed: Dictionary of deployment info at db_nsr._admin.depoloyed.VCA.<INDEX>
4277 :param config_descriptor: Configuration descriptor of the NSD, VNFD, VNFD.vdu or VNFD.kdu
4278 :param vca_index: index in the database _admin.deployed.VCA
4279 :param destroy_ee: False to do not destroy, because it will be destroyed all of then at once
4280 :param exec_primitives: False to do not execute terminate primitives, because the config is not completed or has
4281 not executed properly
4282 :param scaling_in: True destroys the application, False destroys the model
4283 :return: None or exception
4288 + " vca_index: {}, vca_deployed: {}, config_descriptor: {}, destroy_ee: {}".format(
4289 vca_index
, vca_deployed
, config_descriptor
, destroy_ee
4293 vca_type
= vca_deployed
.get("type", "lxc_proxy_charm")
4295 # execute terminate_primitives
4297 terminate_primitives
= get_ee_sorted_terminate_config_primitive_list(
4298 config_descriptor
.get("terminate-config-primitive"),
4299 vca_deployed
.get("ee_descriptor_id"),
4301 vdu_id
= vca_deployed
.get("vdu_id")
4302 vdu_count_index
= vca_deployed
.get("vdu_count_index")
4303 vdu_name
= vca_deployed
.get("vdu_name")
4304 vnf_index
= vca_deployed
.get("member-vnf-index")
4305 if terminate_primitives
and vca_deployed
.get("needed_terminate"):
4306 for seq
in terminate_primitives
:
4307 # For each sequence in list, get primitive and call _ns_execute_primitive()
4308 step
= "Calling terminate action for vnf_member_index={} primitive={}".format(
4309 vnf_index
, seq
.get("name")
4311 self
.logger
.debug(logging_text
+ step
)
4312 # Create the primitive for each sequence, i.e. "primitive": "touch"
4313 primitive
= seq
.get("name")
4314 mapped_primitive_params
= self
._get
_terminate
_primitive
_params
(
4319 self
._add
_suboperation
(
4326 mapped_primitive_params
,
4328 # Sub-operations: Call _ns_execute_primitive() instead of action()
4330 result
, result_detail
= await self
._ns
_execute
_primitive
(
4331 vca_deployed
["ee_id"],
4333 mapped_primitive_params
,
4337 except LcmException
:
4338 # this happens when VCA is not deployed. In this case it is not needed to terminate
4340 result_ok
= ["COMPLETED", "PARTIALLY_COMPLETED"]
4341 if result
not in result_ok
:
4343 "terminate_primitive {} for vnf_member_index={} fails with "
4344 "error {}".format(seq
.get("name"), vnf_index
, result_detail
)
4346 # set that this VCA do not need terminated
4347 db_update_entry
= "_admin.deployed.VCA.{}.needed_terminate".format(
4351 "nsrs", db_nslcmop
["nsInstanceId"], {db_update_entry
: False}
4354 # Delete Prometheus Jobs if any
4355 # This uses NSR_ID, so it will destroy any jobs under this index
4356 self
.db
.del_list("prometheus_jobs", {"nsr_id": db_nslcmop
["nsInstanceId"]})
4359 await self
.vca_map
[vca_type
].delete_execution_environment(
4360 vca_deployed
["ee_id"],
4361 scaling_in
=scaling_in
,
4366 async def _delete_all_N2VC(self
, db_nsr
: dict, vca_id
: str = None):
4367 self
._write
_all
_config
_status
(db_nsr
=db_nsr
, status
="TERMINATING")
4368 namespace
= "." + db_nsr
["_id"]
4370 await self
.n2vc
.delete_namespace(
4371 namespace
=namespace
,
4372 total_timeout
=self
.timeout
.charm_delete
,
4375 except N2VCNotFound
: # already deleted. Skip
4377 self
._write
_all
_config
_status
(db_nsr
=db_nsr
, status
="DELETED")
4379 async def terminate(self
, nsr_id
, nslcmop_id
):
4380 # Try to lock HA task here
4381 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
4382 if not task_is_locked_by_me
:
4385 logging_text
= "Task ns={} terminate={} ".format(nsr_id
, nslcmop_id
)
4386 self
.logger
.debug(logging_text
+ "Enter")
4387 timeout_ns_terminate
= self
.timeout
.ns_terminate
4390 operation_params
= None
4392 error_list
= [] # annotates all failed error messages
4393 db_nslcmop_update
= {}
4394 autoremove
= False # autoremove after terminated
4395 tasks_dict_info
= {}
4398 "Stage 1/3: Preparing task.",
4399 "Waiting for previous operations to terminate.",
4402 # ^ contains [stage, step, VIM-status]
4404 # wait for any previous tasks in process
4405 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
4407 stage
[1] = "Getting nslcmop={} from db.".format(nslcmop_id
)
4408 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
4409 operation_params
= db_nslcmop
.get("operationParams") or {}
4410 if operation_params
.get("timeout_ns_terminate"):
4411 timeout_ns_terminate
= operation_params
["timeout_ns_terminate"]
4412 stage
[1] = "Getting nsr={} from db.".format(nsr_id
)
4413 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
4415 db_nsr_update
["operational-status"] = "terminating"
4416 db_nsr_update
["config-status"] = "terminating"
4417 self
._write
_ns
_status
(
4419 ns_state
="TERMINATING",
4420 current_operation
="TERMINATING",
4421 current_operation_id
=nslcmop_id
,
4422 other_update
=db_nsr_update
,
4424 self
._write
_op
_status
(op_id
=nslcmop_id
, queuePosition
=0, stage
=stage
)
4425 nsr_deployed
= deepcopy(db_nsr
["_admin"].get("deployed")) or {}
4426 if db_nsr
["_admin"]["nsState"] == "NOT_INSTANTIATED":
4429 stage
[1] = "Getting vnf descriptors from db."
4430 db_vnfrs_list
= self
.db
.get_list("vnfrs", {"nsr-id-ref": nsr_id
})
4432 db_vnfr
["member-vnf-index-ref"]: db_vnfr
for db_vnfr
in db_vnfrs_list
4434 db_vnfds_from_id
= {}
4435 db_vnfds_from_member_index
= {}
4437 for vnfr
in db_vnfrs_list
:
4438 vnfd_id
= vnfr
["vnfd-id"]
4439 if vnfd_id
not in db_vnfds_from_id
:
4440 vnfd
= self
.db
.get_one("vnfds", {"_id": vnfd_id
})
4441 db_vnfds_from_id
[vnfd_id
] = vnfd
4442 db_vnfds_from_member_index
[
4443 vnfr
["member-vnf-index-ref"]
4444 ] = db_vnfds_from_id
[vnfd_id
]
4446 # Destroy individual execution environments when there are terminating primitives.
4447 # Rest of EE will be deleted at once
4448 # TODO - check before calling _destroy_N2VC
4449 # if not operation_params.get("skip_terminate_primitives"):#
4450 # or not vca.get("needed_terminate"):
4451 stage
[0] = "Stage 2/3 execute terminating primitives."
4452 self
.logger
.debug(logging_text
+ stage
[0])
4453 stage
[1] = "Looking execution environment that needs terminate."
4454 self
.logger
.debug(logging_text
+ stage
[1])
4456 for vca_index
, vca
in enumerate(get_iterable(nsr_deployed
, "VCA")):
4457 config_descriptor
= None
4458 vca_member_vnf_index
= vca
.get("member-vnf-index")
4459 vca_id
= self
.get_vca_id(
4460 db_vnfrs_dict
.get(vca_member_vnf_index
)
4461 if vca_member_vnf_index
4465 if not vca
or not vca
.get("ee_id"):
4467 if not vca
.get("member-vnf-index"):
4469 config_descriptor
= db_nsr
.get("ns-configuration")
4470 elif vca
.get("vdu_id"):
4471 db_vnfd
= db_vnfds_from_member_index
[vca
["member-vnf-index"]]
4472 config_descriptor
= get_configuration(db_vnfd
, vca
.get("vdu_id"))
4473 elif vca
.get("kdu_name"):
4474 db_vnfd
= db_vnfds_from_member_index
[vca
["member-vnf-index"]]
4475 config_descriptor
= get_configuration(db_vnfd
, vca
.get("kdu_name"))
4477 db_vnfd
= db_vnfds_from_member_index
[vca
["member-vnf-index"]]
4478 config_descriptor
= get_configuration(db_vnfd
, db_vnfd
["id"])
4479 vca_type
= vca
.get("type")
4480 exec_terminate_primitives
= not operation_params
.get(
4481 "skip_terminate_primitives"
4482 ) and vca
.get("needed_terminate")
4483 # For helm we must destroy_ee. Also for native_charm, as juju_model cannot be deleted if there are
4484 # pending native charms
4485 destroy_ee
= True if vca_type
in ("helm-v3", "native_charm") else False
4486 # self.logger.debug(logging_text + "vca_index: {}, ee_id: {}, vca_type: {} destroy_ee: {}".format(
4487 # vca_index, vca.get("ee_id"), vca_type, destroy_ee))
4488 task
= asyncio
.ensure_future(
4496 exec_terminate_primitives
,
4500 tasks_dict_info
[task
] = "Terminating VCA {}".format(vca
.get("ee_id"))
4502 # wait for pending tasks of terminate primitives
4506 + "Waiting for tasks {}".format(list(tasks_dict_info
.keys()))
4508 error_list
= await self
._wait
_for
_tasks
(
4511 min(self
.timeout
.charm_delete
, timeout_ns_terminate
),
4515 tasks_dict_info
.clear()
4517 return # raise LcmException("; ".join(error_list))
4519 # remove All execution environments at once
4520 stage
[0] = "Stage 3/3 delete all."
4522 if nsr_deployed
.get("VCA"):
4523 stage
[1] = "Deleting all execution environments."
4524 self
.logger
.debug(logging_text
+ stage
[1])
4525 if nsr_deployed
.get("VCA").get("type") != "helm-v3":
4526 vca_id
= self
.get_vca_id({}, db_nsr
)
4527 task_delete_ee
= asyncio
.ensure_future(
4529 self
._delete
_all
_N
2VC
(db_nsr
=db_nsr
, vca_id
=vca_id
),
4530 timeout
=self
.timeout
.charm_delete
,
4533 tasks_dict_info
[task_delete_ee
] = "Terminating all VCA"
4535 # Delete Namespace and Certificates
4536 await self
.vca_map
["helm-v3"].delete_tls_certificate(
4537 namespace
=db_nslcmop
["nsInstanceId"],
4538 certificate_name
=self
.EE_TLS_NAME
,
4540 await self
.vca_map
["helm-v3"].delete_namespace(
4541 namespace
=db_nslcmop
["nsInstanceId"],
4544 # Delete from k8scluster
4545 stage
[1] = "Deleting KDUs."
4546 self
.logger
.debug(logging_text
+ stage
[1])
4547 # print(nsr_deployed)
4548 for kdu
in get_iterable(nsr_deployed
, "K8s"):
4549 if not kdu
or not kdu
.get("kdu-instance"):
4551 kdu_instance
= kdu
.get("kdu-instance")
4552 if kdu
.get("k8scluster-type") in self
.k8scluster_map
:
4553 # TODO: Uninstall kdu instances taking into account they could be deployed in different VIMs
4554 vca_id
= self
.get_vca_id({}, db_nsr
)
4555 task_delete_kdu_instance
= asyncio
.ensure_future(
4556 self
.k8scluster_map
[kdu
["k8scluster-type"]].uninstall(
4557 cluster_uuid
=kdu
.get("k8scluster-uuid"),
4558 kdu_instance
=kdu_instance
,
4560 namespace
=kdu
.get("namespace"),
4566 + "Unknown k8s deployment type {}".format(
4567 kdu
.get("k8scluster-type")
4572 task_delete_kdu_instance
4573 ] = "Terminating KDU '{}'".format(kdu
.get("kdu-name"))
4576 stage
[1] = "Deleting ns from VIM."
4577 if self
.ro_config
.ng
:
4578 task_delete_ro
= asyncio
.ensure_future(
4579 self
._terminate
_ng
_ro
(
4580 logging_text
, nsr_deployed
, nsr_id
, nslcmop_id
, stage
4583 tasks_dict_info
[task_delete_ro
] = "Removing deployment from VIM"
4585 # rest of staff will be done at finally
4588 ROclient
.ROClientException
,
4593 self
.logger
.error(logging_text
+ "Exit Exception {}".format(e
))
4595 except asyncio
.CancelledError
:
4597 logging_text
+ "Cancelled Exception while '{}'".format(stage
[1])
4599 exc
= "Operation was cancelled"
4600 except Exception as e
:
4601 exc
= traceback
.format_exc()
4602 self
.logger
.critical(
4603 logging_text
+ "Exit Exception while '{}': {}".format(stage
[1], e
),
4608 error_list
.append(str(exc
))
4610 # wait for pending tasks
4612 stage
[1] = "Waiting for terminate pending tasks."
4613 self
.logger
.debug(logging_text
+ stage
[1])
4614 error_list
+= await self
._wait
_for
_tasks
(
4617 timeout_ns_terminate
,
4621 stage
[1] = stage
[2] = ""
4622 except asyncio
.CancelledError
:
4623 error_list
.append("Cancelled")
4624 await self
._cancel
_pending
_tasks
(logging_text
, tasks_dict_info
)
4625 await self
._wait
_for
_tasks
(
4628 timeout_ns_terminate
,
4632 except Exception as exc
:
4633 error_list
.append(str(exc
))
4634 # update status at database
4636 error_detail
= "; ".join(error_list
)
4637 # self.logger.error(logging_text + error_detail)
4638 error_description_nslcmop
= "{} Detail: {}".format(
4639 stage
[0], error_detail
4641 error_description_nsr
= "Operation: TERMINATING.{}, {}.".format(
4642 nslcmop_id
, stage
[0]
4645 db_nsr_update
["operational-status"] = "failed"
4646 db_nsr_update
["detailed-status"] = (
4647 error_description_nsr
+ " Detail: " + error_detail
4649 db_nslcmop_update
["detailed-status"] = error_detail
4650 nslcmop_operation_state
= "FAILED"
4654 error_description_nsr
= error_description_nslcmop
= None
4655 ns_state
= "NOT_INSTANTIATED"
4656 db_nsr_update
["operational-status"] = "terminated"
4657 db_nsr_update
["detailed-status"] = "Done"
4658 db_nsr_update
["_admin.nsState"] = "NOT_INSTANTIATED"
4659 db_nslcmop_update
["detailed-status"] = "Done"
4660 nslcmop_operation_state
= "COMPLETED"
4663 self
._write
_ns
_status
(
4666 current_operation
="IDLE",
4667 current_operation_id
=None,
4668 error_description
=error_description_nsr
,
4669 error_detail
=error_detail
,
4670 other_update
=db_nsr_update
,
4672 self
._write
_op
_status
(
4675 error_message
=error_description_nslcmop
,
4676 operation_state
=nslcmop_operation_state
,
4677 other_update
=db_nslcmop_update
,
4679 if ns_state
== "NOT_INSTANTIATED":
4683 {"nsr-id-ref": nsr_id
},
4684 {"_admin.nsState": "NOT_INSTANTIATED"},
4686 except DbException
as e
:
4689 + "Error writing VNFR status for nsr-id-ref: {} -> {}".format(
4693 if operation_params
:
4694 autoremove
= operation_params
.get("autoremove", False)
4695 if nslcmop_operation_state
:
4697 await self
.msg
.aiowrite(
4702 "nslcmop_id": nslcmop_id
,
4703 "operationState": nslcmop_operation_state
,
4704 "autoremove": autoremove
,
4707 except Exception as e
:
4709 logging_text
+ "kafka_write notification Exception {}".format(e
)
4711 self
.logger
.debug(f
"Deleting alerts: ns_id={nsr_id}")
4712 self
.db
.del_list("alerts", {"tags.ns_id": nsr_id
})
4714 self
.logger
.debug(logging_text
+ "Exit")
4715 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_terminate")
4717 async def _wait_for_tasks(
4718 self
, logging_text
, created_tasks_info
, timeout
, stage
, nslcmop_id
, nsr_id
=None
4721 error_detail_list
= []
4723 pending_tasks
= list(created_tasks_info
.keys())
4724 num_tasks
= len(pending_tasks
)
4726 stage
[1] = "{}/{}.".format(num_done
, num_tasks
)
4727 self
._write
_op
_status
(nslcmop_id
, stage
)
4728 while pending_tasks
:
4730 _timeout
= timeout
+ time_start
- time()
4731 done
, pending_tasks
= await asyncio
.wait(
4732 pending_tasks
, timeout
=_timeout
, return_when
=asyncio
.FIRST_COMPLETED
4734 num_done
+= len(done
)
4735 if not done
: # Timeout
4736 for task
in pending_tasks
:
4737 new_error
= created_tasks_info
[task
] + ": Timeout"
4738 error_detail_list
.append(new_error
)
4739 error_list
.append(new_error
)
4742 if task
.cancelled():
4745 exc
= task
.exception()
4747 if isinstance(exc
, asyncio
.TimeoutError
):
4749 new_error
= created_tasks_info
[task
] + ": {}".format(exc
)
4750 error_list
.append(created_tasks_info
[task
])
4751 error_detail_list
.append(new_error
)
4758 ROclient
.ROClientException
,
4764 self
.logger
.error(logging_text
+ new_error
)
4766 exc_traceback
= "".join(
4767 traceback
.format_exception(None, exc
, exc
.__traceback
__)
4771 + created_tasks_info
[task
]
4777 logging_text
+ created_tasks_info
[task
] + ": Done"
4779 stage
[1] = "{}/{}.".format(num_done
, num_tasks
)
4781 stage
[1] += " Errors: " + ". ".join(error_detail_list
) + "."
4782 if nsr_id
: # update also nsr
4787 "errorDescription": "Error at: " + ", ".join(error_list
),
4788 "errorDetail": ". ".join(error_detail_list
),
4791 self
._write
_op
_status
(nslcmop_id
, stage
)
4792 return error_detail_list
4794 async def _cancel_pending_tasks(self
, logging_text
, created_tasks_info
):
4795 for task
, name
in created_tasks_info
.items():
4796 self
.logger
.debug(logging_text
+ "Cancelling task: " + name
)
4800 def _map_primitive_params(primitive_desc
, params
, instantiation_params
):
4802 Generates the params to be provided to charm before executing primitive. If user does not provide a parameter,
4803 The default-value is used. If it is between < > it look for a value at instantiation_params
4804 :param primitive_desc: portion of VNFD/NSD that describes primitive
4805 :param params: Params provided by user
4806 :param instantiation_params: Instantiation params provided by user
4807 :return: a dictionary with the calculated params
4809 calculated_params
= {}
4810 for parameter
in primitive_desc
.get("parameter", ()):
4811 param_name
= parameter
["name"]
4812 if param_name
in params
:
4813 calculated_params
[param_name
] = params
[param_name
]
4814 elif "default-value" in parameter
or "value" in parameter
:
4815 if "value" in parameter
:
4816 calculated_params
[param_name
] = parameter
["value"]
4818 calculated_params
[param_name
] = parameter
["default-value"]
4820 isinstance(calculated_params
[param_name
], str)
4821 and calculated_params
[param_name
].startswith("<")
4822 and calculated_params
[param_name
].endswith(">")
4824 if calculated_params
[param_name
][1:-1] in instantiation_params
:
4825 calculated_params
[param_name
] = instantiation_params
[
4826 calculated_params
[param_name
][1:-1]
4830 "Parameter {} needed to execute primitive {} not provided".format(
4831 calculated_params
[param_name
], primitive_desc
["name"]
4836 "Parameter {} needed to execute primitive {} not provided".format(
4837 param_name
, primitive_desc
["name"]
4841 if isinstance(calculated_params
[param_name
], (dict, list, tuple)):
4842 calculated_params
[param_name
] = yaml
.safe_dump(
4843 calculated_params
[param_name
], default_flow_style
=True, width
=256
4845 elif isinstance(calculated_params
[param_name
], str) and calculated_params
[
4847 ].startswith("!!yaml "):
4848 calculated_params
[param_name
] = calculated_params
[param_name
][7:]
4849 if parameter
.get("data-type") == "INTEGER":
4851 calculated_params
[param_name
] = int(calculated_params
[param_name
])
4852 except ValueError: # error converting string to int
4854 "Parameter {} of primitive {} must be integer".format(
4855 param_name
, primitive_desc
["name"]
4858 elif parameter
.get("data-type") == "BOOLEAN":
4859 calculated_params
[param_name
] = not (
4860 (str(calculated_params
[param_name
])).lower() == "false"
4863 # add always ns_config_info if primitive name is config
4864 if primitive_desc
["name"] == "config":
4865 if "ns_config_info" in instantiation_params
:
4866 calculated_params
["ns_config_info"] = instantiation_params
[
4869 return calculated_params
4871 def _look_for_deployed_vca(
4878 ee_descriptor_id
=None,
4880 # find vca_deployed record for this action. Raise LcmException if not found or there is not any id.
4881 for vca
in deployed_vca
:
4884 if member_vnf_index
!= vca
["member-vnf-index"] or vdu_id
!= vca
["vdu_id"]:
4887 vdu_count_index
is not None
4888 and vdu_count_index
!= vca
["vdu_count_index"]
4891 if kdu_name
and kdu_name
!= vca
["kdu_name"]:
4893 if ee_descriptor_id
and ee_descriptor_id
!= vca
["ee_descriptor_id"]:
4897 # vca_deployed not found
4899 "charm for member_vnf_index={} vdu_id={}.{} kdu_name={} execution-environment-list.id={}"
4900 " is not deployed".format(
4909 ee_id
= vca
.get("ee_id")
4911 "type", "lxc_proxy_charm"
4912 ) # default value for backward compatibility - proxy charm
4915 "charm for member_vnf_index={} vdu_id={} kdu_name={} vdu_count_index={} has not "
4916 "execution environment".format(
4917 member_vnf_index
, vdu_id
, kdu_name
, vdu_count_index
4920 return ee_id
, vca_type
4922 async def _ns_execute_primitive(
4928 retries_interval
=30,
4935 if primitive
== "config":
4936 primitive_params
= {"params": primitive_params
}
4938 vca_type
= vca_type
or "lxc_proxy_charm"
4942 output
= await asyncio
.wait_for(
4943 self
.vca_map
[vca_type
].exec_primitive(
4945 primitive_name
=primitive
,
4946 params_dict
=primitive_params
,
4947 progress_timeout
=self
.timeout
.progress_primitive
,
4948 total_timeout
=self
.timeout
.primitive
,
4953 timeout
=timeout
or self
.timeout
.primitive
,
4957 except asyncio
.CancelledError
:
4959 except Exception as e
:
4963 "Error executing action {} on {} -> {}".format(
4968 await asyncio
.sleep(retries_interval
)
4970 if isinstance(e
, asyncio
.TimeoutError
):
4972 message
="Timed out waiting for action to complete"
4974 return "FAILED", getattr(e
, "message", repr(e
))
4976 return "COMPLETED", output
4978 except (LcmException
, asyncio
.CancelledError
):
4980 except Exception as e
:
4981 return "FAIL", "Error executing action {}: {}".format(primitive
, e
)
4983 async def vca_status_refresh(self
, nsr_id
, nslcmop_id
):
4985 Updating the vca_status with latest juju information in nsrs record
4986 :param: nsr_id: Id of the nsr
4987 :param: nslcmop_id: Id of the nslcmop
4991 self
.logger
.debug("Task ns={} action={} Enter".format(nsr_id
, nslcmop_id
))
4992 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
4993 vca_id
= self
.get_vca_id({}, db_nsr
)
4994 if db_nsr
["_admin"]["deployed"]["K8s"]:
4995 for _
, k8s
in enumerate(db_nsr
["_admin"]["deployed"]["K8s"]):
4996 cluster_uuid
, kdu_instance
, cluster_type
= (
4997 k8s
["k8scluster-uuid"],
4998 k8s
["kdu-instance"],
4999 k8s
["k8scluster-type"],
5001 await self
._on
_update
_k
8s
_db
(
5002 cluster_uuid
=cluster_uuid
,
5003 kdu_instance
=kdu_instance
,
5004 filter={"_id": nsr_id
},
5006 cluster_type
=cluster_type
,
5009 for vca_index
, _
in enumerate(db_nsr
["_admin"]["deployed"]["VCA"]):
5010 table
, filter = "nsrs", {"_id": nsr_id
}
5011 path
= "_admin.deployed.VCA.{}.".format(vca_index
)
5012 await self
._on
_update
_n
2vc
_db
(table
, filter, path
, {})
5014 self
.logger
.debug("Task ns={} action={} Exit".format(nsr_id
, nslcmop_id
))
5015 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_vca_status_refresh")
5017 async def action(self
, nsr_id
, nslcmop_id
):
5018 # Try to lock HA task here
5019 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
5020 if not task_is_locked_by_me
:
5023 logging_text
= "Task ns={} action={} ".format(nsr_id
, nslcmop_id
)
5024 self
.logger
.debug(logging_text
+ "Enter")
5025 # get all needed from database
5029 db_nslcmop_update
= {}
5030 nslcmop_operation_state
= None
5031 error_description_nslcmop
= None
5035 # wait for any previous tasks in process
5036 step
= "Waiting for previous operations to terminate"
5037 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
5039 self
._write
_ns
_status
(
5042 current_operation
="RUNNING ACTION",
5043 current_operation_id
=nslcmop_id
,
5046 step
= "Getting information from database"
5047 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
5048 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
5049 if db_nslcmop
["operationParams"].get("primitive_params"):
5050 db_nslcmop
["operationParams"]["primitive_params"] = json
.loads(
5051 db_nslcmop
["operationParams"]["primitive_params"]
5054 nsr_deployed
= db_nsr
["_admin"].get("deployed")
5055 vnf_index
= db_nslcmop
["operationParams"].get("member_vnf_index")
5056 vdu_id
= db_nslcmop
["operationParams"].get("vdu_id")
5057 kdu_name
= db_nslcmop
["operationParams"].get("kdu_name")
5058 vdu_count_index
= db_nslcmop
["operationParams"].get("vdu_count_index")
5059 primitive
= db_nslcmop
["operationParams"]["primitive"]
5060 primitive_params
= db_nslcmop
["operationParams"]["primitive_params"]
5061 timeout_ns_action
= db_nslcmop
["operationParams"].get(
5062 "timeout_ns_action", self
.timeout
.primitive
5066 step
= "Getting vnfr from database"
5067 db_vnfr
= self
.db
.get_one(
5068 "vnfrs", {"member-vnf-index-ref": vnf_index
, "nsr-id-ref": nsr_id
}
5070 if db_vnfr
.get("kdur"):
5072 for kdur
in db_vnfr
["kdur"]:
5073 if kdur
.get("additionalParams"):
5074 kdur
["additionalParams"] = json
.loads(
5075 kdur
["additionalParams"]
5077 kdur_list
.append(kdur
)
5078 db_vnfr
["kdur"] = kdur_list
5079 step
= "Getting vnfd from database"
5080 db_vnfd
= self
.db
.get_one("vnfds", {"_id": db_vnfr
["vnfd-id"]})
5082 # Sync filesystem before running a primitive
5083 self
.fs
.sync(db_vnfr
["vnfd-id"])
5085 step
= "Getting nsd from database"
5086 db_nsd
= self
.db
.get_one("nsds", {"_id": db_nsr
["nsd-id"]})
5088 vca_id
= self
.get_vca_id(db_vnfr
, db_nsr
)
5089 # for backward compatibility
5090 if nsr_deployed
and isinstance(nsr_deployed
.get("VCA"), dict):
5091 nsr_deployed
["VCA"] = list(nsr_deployed
["VCA"].values())
5092 db_nsr_update
["_admin.deployed.VCA"] = nsr_deployed
["VCA"]
5093 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
5095 # look for primitive
5096 config_primitive_desc
= descriptor_configuration
= None
5098 descriptor_configuration
= get_configuration(db_vnfd
, vdu_id
)
5100 descriptor_configuration
= get_configuration(db_vnfd
, kdu_name
)
5102 descriptor_configuration
= get_configuration(db_vnfd
, db_vnfd
["id"])
5104 descriptor_configuration
= db_nsd
.get("ns-configuration")
5106 if descriptor_configuration
and descriptor_configuration
.get(
5109 for config_primitive
in descriptor_configuration
["config-primitive"]:
5110 if config_primitive
["name"] == primitive
:
5111 config_primitive_desc
= config_primitive
5114 if not config_primitive_desc
:
5115 if not (kdu_name
and primitive
in ("upgrade", "rollback", "status")):
5117 "Primitive {} not found at [ns|vnf|vdu]-configuration:config-primitive ".format(
5121 primitive_name
= primitive
5122 ee_descriptor_id
= None
5124 primitive_name
= config_primitive_desc
.get(
5125 "execution-environment-primitive", primitive
5127 ee_descriptor_id
= config_primitive_desc
.get(
5128 "execution-environment-ref"
5134 (x
for x
in db_vnfr
["vdur"] if x
["vdu-id-ref"] == vdu_id
), None
5136 desc_params
= parse_yaml_strings(vdur
.get("additionalParams"))
5139 (x
for x
in db_vnfr
["kdur"] if x
["kdu-name"] == kdu_name
), None
5141 desc_params
= parse_yaml_strings(kdur
.get("additionalParams"))
5143 desc_params
= parse_yaml_strings(
5144 db_vnfr
.get("additionalParamsForVnf")
5147 desc_params
= parse_yaml_strings(db_nsr
.get("additionalParamsForNs"))
5148 if kdu_name
and get_configuration(db_vnfd
, kdu_name
):
5149 kdu_configuration
= get_configuration(db_vnfd
, kdu_name
)
5151 for primitive
in kdu_configuration
.get("initial-config-primitive", []):
5152 actions
.add(primitive
["name"])
5153 for primitive
in kdu_configuration
.get("config-primitive", []):
5154 actions
.add(primitive
["name"])
5156 nsr_deployed
["K8s"],
5157 lambda kdu
: kdu_name
== kdu
["kdu-name"]
5158 and kdu
["member-vnf-index"] == vnf_index
,
5162 if primitive_name
in actions
5163 and kdu
["k8scluster-type"] != "helm-chart-v3"
5167 # TODO check if ns is in a proper status
5169 primitive_name
in ("upgrade", "rollback", "status") or kdu_action
5171 # kdur and desc_params already set from before
5172 if primitive_params
:
5173 desc_params
.update(primitive_params
)
5174 # TODO Check if we will need something at vnf level
5175 for index
, kdu
in enumerate(get_iterable(nsr_deployed
, "K8s")):
5177 kdu_name
== kdu
["kdu-name"]
5178 and kdu
["member-vnf-index"] == vnf_index
5183 "KDU '{}' for vnf '{}' not deployed".format(kdu_name
, vnf_index
)
5186 if kdu
.get("k8scluster-type") not in self
.k8scluster_map
:
5187 msg
= "unknown k8scluster-type '{}'".format(
5188 kdu
.get("k8scluster-type")
5190 raise LcmException(msg
)
5193 "collection": "nsrs",
5194 "filter": {"_id": nsr_id
},
5195 "path": "_admin.deployed.K8s.{}".format(index
),
5199 + "Exec k8s {} on {}.{}".format(primitive_name
, vnf_index
, kdu_name
)
5201 step
= "Executing kdu {}".format(primitive_name
)
5202 if primitive_name
== "upgrade":
5203 if desc_params
.get("kdu_model"):
5204 kdu_model
= desc_params
.get("kdu_model")
5205 del desc_params
["kdu_model"]
5207 kdu_model
= kdu
.get("kdu-model")
5208 if kdu_model
.count("/") < 2: # helm chart is not embedded
5209 parts
= kdu_model
.split(sep
=":")
5211 kdu_model
= parts
[0]
5212 if desc_params
.get("kdu_atomic_upgrade"):
5213 atomic_upgrade
= desc_params
.get(
5214 "kdu_atomic_upgrade"
5215 ).lower() in ("yes", "true", "1")
5216 del desc_params
["kdu_atomic_upgrade"]
5218 atomic_upgrade
= True
5220 detailed_status
= await asyncio
.wait_for(
5221 self
.k8scluster_map
[kdu
["k8scluster-type"]].upgrade(
5222 cluster_uuid
=kdu
.get("k8scluster-uuid"),
5223 kdu_instance
=kdu
.get("kdu-instance"),
5224 atomic
=atomic_upgrade
,
5225 kdu_model
=kdu_model
,
5228 timeout
=timeout_ns_action
,
5230 timeout
=timeout_ns_action
+ 10,
5233 logging_text
+ " Upgrade of kdu {} done".format(detailed_status
)
5235 elif primitive_name
== "rollback":
5236 detailed_status
= await asyncio
.wait_for(
5237 self
.k8scluster_map
[kdu
["k8scluster-type"]].rollback(
5238 cluster_uuid
=kdu
.get("k8scluster-uuid"),
5239 kdu_instance
=kdu
.get("kdu-instance"),
5242 timeout
=timeout_ns_action
,
5244 elif primitive_name
== "status":
5245 detailed_status
= await asyncio
.wait_for(
5246 self
.k8scluster_map
[kdu
["k8scluster-type"]].status_kdu(
5247 cluster_uuid
=kdu
.get("k8scluster-uuid"),
5248 kdu_instance
=kdu
.get("kdu-instance"),
5251 timeout
=timeout_ns_action
,
5254 kdu_instance
= kdu
.get("kdu-instance") or "{}-{}".format(
5255 kdu
["kdu-name"], nsr_id
5257 params
= self
._map
_primitive
_params
(
5258 config_primitive_desc
, primitive_params
, desc_params
5261 detailed_status
= await asyncio
.wait_for(
5262 self
.k8scluster_map
[kdu
["k8scluster-type"]].exec_primitive(
5263 cluster_uuid
=kdu
.get("k8scluster-uuid"),
5264 kdu_instance
=kdu_instance
,
5265 primitive_name
=primitive_name
,
5268 timeout
=timeout_ns_action
,
5271 timeout
=timeout_ns_action
,
5275 nslcmop_operation_state
= "COMPLETED"
5277 detailed_status
= ""
5278 nslcmop_operation_state
= "FAILED"
5280 ee_id
, vca_type
= self
._look
_for
_deployed
_vca
(
5281 nsr_deployed
["VCA"],
5282 member_vnf_index
=vnf_index
,
5284 vdu_count_index
=vdu_count_index
,
5285 ee_descriptor_id
=ee_descriptor_id
,
5287 for vca_index
, vca_deployed
in enumerate(
5288 db_nsr
["_admin"]["deployed"]["VCA"]
5290 if vca_deployed
.get("member-vnf-index") == vnf_index
:
5292 "collection": "nsrs",
5293 "filter": {"_id": nsr_id
},
5294 "path": "_admin.deployed.VCA.{}.".format(vca_index
),
5298 nslcmop_operation_state
,
5300 ) = await self
._ns
_execute
_primitive
(
5302 primitive
=primitive_name
,
5303 primitive_params
=self
._map
_primitive
_params
(
5304 config_primitive_desc
, primitive_params
, desc_params
5306 timeout
=timeout_ns_action
,
5312 db_nslcmop_update
["detailed-status"] = detailed_status
5313 error_description_nslcmop
= (
5314 detailed_status
if nslcmop_operation_state
== "FAILED" else ""
5318 + "Done with result {} {}".format(
5319 nslcmop_operation_state
, detailed_status
5322 return # database update is called inside finally
5324 except (DbException
, LcmException
, N2VCException
, K8sException
) as e
:
5325 self
.logger
.error(logging_text
+ "Exit Exception {}".format(e
))
5327 except asyncio
.CancelledError
:
5329 logging_text
+ "Cancelled Exception while '{}'".format(step
)
5331 exc
= "Operation was cancelled"
5332 except asyncio
.TimeoutError
:
5333 self
.logger
.error(logging_text
+ "Timeout while '{}'".format(step
))
5335 except Exception as e
:
5336 exc
= traceback
.format_exc()
5337 self
.logger
.critical(
5338 logging_text
+ "Exit Exception {} {}".format(type(e
).__name
__, e
),
5347 ) = error_description_nslcmop
= "FAILED {}: {}".format(step
, exc
)
5348 nslcmop_operation_state
= "FAILED"
5350 self
._write
_ns
_status
(
5354 ], # TODO check if degraded. For the moment use previous status
5355 current_operation
="IDLE",
5356 current_operation_id
=None,
5357 # error_description=error_description_nsr,
5358 # error_detail=error_detail,
5359 other_update
=db_nsr_update
,
5362 self
._write
_op
_status
(
5365 error_message
=error_description_nslcmop
,
5366 operation_state
=nslcmop_operation_state
,
5367 other_update
=db_nslcmop_update
,
5370 if nslcmop_operation_state
:
5372 await self
.msg
.aiowrite(
5377 "nslcmop_id": nslcmop_id
,
5378 "operationState": nslcmop_operation_state
,
5381 except Exception as e
:
5383 logging_text
+ "kafka_write notification Exception {}".format(e
)
5385 self
.logger
.debug(logging_text
+ "Exit")
5386 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_action")
5387 return nslcmop_operation_state
, detailed_status
5389 async def terminate_vdus(
5390 self
, db_vnfr
, member_vnf_index
, db_nsr
, update_db_nslcmops
, stage
, logging_text
5392 """This method terminates VDUs
5395 db_vnfr: VNF instance record
5396 member_vnf_index: VNF index to identify the VDUs to be removed
5397 db_nsr: NS instance record
5398 update_db_nslcmops: Nslcmop update record
5400 vca_scaling_info
= []
5401 scaling_info
= {"scaling_group_name": "vdu_autoscale", "vdu": [], "kdu": []}
5402 scaling_info
["scaling_direction"] = "IN"
5403 scaling_info
["vdu-delete"] = {}
5404 scaling_info
["kdu-delete"] = {}
5405 db_vdur
= db_vnfr
.get("vdur")
5406 vdur_list
= copy(db_vdur
)
5408 for index
, vdu
in enumerate(vdur_list
):
5409 vca_scaling_info
.append(
5411 "osm_vdu_id": vdu
["vdu-id-ref"],
5412 "member-vnf-index": member_vnf_index
,
5414 "vdu_index": count_index
,
5417 scaling_info
["vdu-delete"][vdu
["vdu-id-ref"]] = count_index
5418 scaling_info
["vdu"].append(
5420 "name": vdu
.get("name") or vdu
.get("vdu-name"),
5421 "vdu_id": vdu
["vdu-id-ref"],
5425 for interface
in vdu
["interfaces"]:
5426 scaling_info
["vdu"][index
]["interface"].append(
5428 "name": interface
["name"],
5429 "ip_address": interface
["ip-address"],
5430 "mac_address": interface
.get("mac-address"),
5433 self
.logger
.info("NS update scaling info{}".format(scaling_info
))
5434 stage
[2] = "Terminating VDUs"
5435 if scaling_info
.get("vdu-delete"):
5436 # scale_process = "RO"
5437 if self
.ro_config
.ng
:
5438 await self
._scale
_ng
_ro
(
5447 async def remove_vnf(self
, nsr_id
, nslcmop_id
, vnf_instance_id
):
5448 """This method is to Remove VNF instances from NS.
5451 nsr_id: NS instance id
5452 nslcmop_id: nslcmop id of update
5453 vnf_instance_id: id of the VNF instance to be removed
5456 result: (str, str) COMPLETED/FAILED, details
5460 logging_text
= "Task ns={} update ".format(nsr_id
)
5461 check_vnfr_count
= len(self
.db
.get_list("vnfrs", {"nsr-id-ref": nsr_id
}))
5462 self
.logger
.info("check_vnfr_count {}".format(check_vnfr_count
))
5463 if check_vnfr_count
> 1:
5464 stage
= ["", "", ""]
5465 step
= "Getting nslcmop from database"
5467 step
+ " after having waited for previous tasks to be completed"
5469 # db_nslcmop = self.db.get_one("nslcmops", {"_id": nslcmop_id})
5470 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
5471 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnf_instance_id
})
5472 member_vnf_index
= db_vnfr
["member-vnf-index-ref"]
5473 """ db_vnfr = self.db.get_one(
5474 "vnfrs", {"member-vnf-index-ref": member_vnf_index, "nsr-id-ref": nsr_id}) """
5476 update_db_nslcmops
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
5477 await self
.terminate_vdus(
5486 constituent_vnfr
= db_nsr
.get("constituent-vnfr-ref")
5487 constituent_vnfr
.remove(db_vnfr
.get("_id"))
5488 db_nsr_update
["constituent-vnfr-ref"] = db_nsr
.get(
5489 "constituent-vnfr-ref"
5491 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
5492 self
.db
.del_one("vnfrs", {"_id": db_vnfr
.get("_id")})
5493 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
5494 return "COMPLETED", "Done"
5496 step
= "Terminate VNF Failed with"
5498 "{} Cannot terminate the last VNF in this NS.".format(
5502 except (LcmException
, asyncio
.CancelledError
):
5504 except Exception as e
:
5505 self
.logger
.debug("Error removing VNF {}".format(e
))
5506 return "FAILED", "Error removing VNF {}".format(e
)
5508 async def _ns_redeploy_vnf(
5516 """This method updates and redeploys VNF instances
5519 nsr_id: NS instance id
5520 nslcmop_id: nslcmop id
5521 db_vnfd: VNF descriptor
5522 db_vnfr: VNF instance record
5523 db_nsr: NS instance record
5526 result: (str, str) COMPLETED/FAILED, details
5530 stage
= ["", "", ""]
5531 logging_text
= "Task ns={} update ".format(nsr_id
)
5532 latest_vnfd_revision
= db_vnfd
["_admin"].get("revision")
5533 member_vnf_index
= db_vnfr
["member-vnf-index-ref"]
5535 # Terminate old VNF resources
5536 update_db_nslcmops
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
5537 await self
.terminate_vdus(
5546 # old_vnfd_id = db_vnfr["vnfd-id"]
5547 # new_db_vnfd = self.db.get_one("vnfds", {"_id": vnfd_id})
5548 new_db_vnfd
= db_vnfd
5549 # new_vnfd_ref = new_db_vnfd["id"]
5550 # new_vnfd_id = vnfd_id
5554 for cp
in new_db_vnfd
.get("ext-cpd", ()):
5556 "name": cp
.get("id"),
5557 "connection-point-id": cp
.get("int-cpd", {}).get("cpd"),
5558 "connection-point-vdu-id": cp
.get("int-cpd", {}).get("vdu-id"),
5561 new_vnfr_cp
.append(vnf_cp
)
5562 new_vdur
= update_db_nslcmops
["operationParams"]["newVdur"]
5563 # new_vdur = self._create_vdur_descriptor_from_vnfd(db_nsd, db_vnfd, old_db_vnfd, vnfd_id, db_nsr, member_vnf_index)
5564 # new_vnfr_update = {"vnfd-ref": new_vnfd_ref, "vnfd-id": new_vnfd_id, "connection-point": new_vnfr_cp, "vdur": new_vdur, "ip-address": ""}
5566 "revision": latest_vnfd_revision
,
5567 "connection-point": new_vnfr_cp
,
5571 self
.update_db_2("vnfrs", db_vnfr
["_id"], new_vnfr_update
)
5572 updated_db_vnfr
= self
.db
.get_one(
5574 {"member-vnf-index-ref": member_vnf_index
, "nsr-id-ref": nsr_id
},
5577 # Instantiate new VNF resources
5578 # update_db_nslcmops = self.db.get_one("nslcmops", {"_id": nslcmop_id})
5579 vca_scaling_info
= []
5580 scaling_info
= {"scaling_group_name": "vdu_autoscale", "vdu": [], "kdu": []}
5581 scaling_info
["scaling_direction"] = "OUT"
5582 scaling_info
["vdu-create"] = {}
5583 scaling_info
["kdu-create"] = {}
5584 vdud_instantiate_list
= db_vnfd
["vdu"]
5585 for index
, vdud
in enumerate(vdud_instantiate_list
):
5586 cloud_init_text
= self
._get
_vdu
_cloud
_init
_content
(vdud
, db_vnfd
)
5588 additional_params
= (
5589 self
._get
_vdu
_additional
_params
(updated_db_vnfr
, vdud
["id"])
5592 cloud_init_list
= []
5594 # TODO Information of its own ip is not available because db_vnfr is not updated.
5595 additional_params
["OSM"] = get_osm_params(
5596 updated_db_vnfr
, vdud
["id"], 1
5598 cloud_init_list
.append(
5599 self
._parse
_cloud
_init
(
5606 vca_scaling_info
.append(
5608 "osm_vdu_id": vdud
["id"],
5609 "member-vnf-index": member_vnf_index
,
5611 "vdu_index": count_index
,
5614 scaling_info
["vdu-create"][vdud
["id"]] = count_index
5615 if self
.ro_config
.ng
:
5617 "New Resources to be deployed: {}".format(scaling_info
)
5619 await self
._scale
_ng
_ro
(
5627 return "COMPLETED", "Done"
5628 except (LcmException
, asyncio
.CancelledError
):
5630 except Exception as e
:
5631 self
.logger
.debug("Error updating VNF {}".format(e
))
5632 return "FAILED", "Error updating VNF {}".format(e
)
5634 async def _ns_charm_upgrade(
5640 timeout
: float = None,
5642 """This method upgrade charms in VNF instances
5645 ee_id: Execution environment id
5646 path: Local path to the charm
5648 charm_type: Charm type can be lxc-proxy-charm, native-charm or k8s-proxy-charm
5649 timeout: (Float) Timeout for the ns update operation
5652 result: (str, str) COMPLETED/FAILED, details
5655 charm_type
= charm_type
or "lxc_proxy_charm"
5656 output
= await self
.vca_map
[charm_type
].upgrade_charm(
5660 charm_type
=charm_type
,
5661 timeout
=timeout
or self
.timeout
.ns_update
,
5665 return "COMPLETED", output
5667 except (LcmException
, asyncio
.CancelledError
):
5670 except Exception as e
:
5671 self
.logger
.debug("Error upgrading charm {}".format(path
))
5673 return "FAILED", "Error upgrading charm {}: {}".format(path
, e
)
5675 async def update(self
, nsr_id
, nslcmop_id
):
5676 """Update NS according to different update types
5678 This method performs upgrade of VNF instances then updates the revision
5679 number in VNF record
5682 nsr_id: Network service will be updated
5683 nslcmop_id: ns lcm operation id
5686 It may raise DbException, LcmException, N2VCException, K8sException
5689 # Try to lock HA task here
5690 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
5691 if not task_is_locked_by_me
:
5694 logging_text
= "Task ns={} update={} ".format(nsr_id
, nslcmop_id
)
5695 self
.logger
.debug(logging_text
+ "Enter")
5697 # Set the required variables to be filled up later
5699 db_nslcmop_update
= {}
5701 nslcmop_operation_state
= None
5703 error_description_nslcmop
= ""
5705 change_type
= "updated"
5706 detailed_status
= ""
5707 member_vnf_index
= None
5710 # wait for any previous tasks in process
5711 step
= "Waiting for previous operations to terminate"
5712 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
5713 self
._write
_ns
_status
(
5716 current_operation
="UPDATING",
5717 current_operation_id
=nslcmop_id
,
5720 step
= "Getting nslcmop from database"
5721 db_nslcmop
= self
.db
.get_one(
5722 "nslcmops", {"_id": nslcmop_id
}, fail_on_empty
=False
5724 update_type
= db_nslcmop
["operationParams"]["updateType"]
5726 step
= "Getting nsr from database"
5727 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
5728 old_operational_status
= db_nsr
["operational-status"]
5729 db_nsr_update
["operational-status"] = "updating"
5730 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
5731 nsr_deployed
= db_nsr
["_admin"].get("deployed")
5733 if update_type
== "CHANGE_VNFPKG":
5734 # Get the input parameters given through update request
5735 vnf_instance_id
= db_nslcmop
["operationParams"][
5736 "changeVnfPackageData"
5737 ].get("vnfInstanceId")
5739 vnfd_id
= db_nslcmop
["operationParams"]["changeVnfPackageData"].get(
5742 timeout_seconds
= db_nslcmop
["operationParams"].get("timeout_ns_update")
5744 step
= "Getting vnfr from database"
5745 db_vnfr
= self
.db
.get_one(
5746 "vnfrs", {"_id": vnf_instance_id
}, fail_on_empty
=False
5749 step
= "Getting vnfds from database"
5751 latest_vnfd
= self
.db
.get_one(
5752 "vnfds", {"_id": vnfd_id
}, fail_on_empty
=False
5754 latest_vnfd_revision
= latest_vnfd
["_admin"].get("revision")
5757 current_vnf_revision
= db_vnfr
.get("revision", 1)
5758 current_vnfd
= self
.db
.get_one(
5760 {"_id": vnfd_id
+ ":" + str(current_vnf_revision
)},
5761 fail_on_empty
=False,
5763 # Charm artifact paths will be filled up later
5765 current_charm_artifact_path
,
5766 target_charm_artifact_path
,
5767 charm_artifact_paths
,
5769 ) = ([], [], [], [])
5771 step
= "Checking if revision has changed in VNFD"
5772 if current_vnf_revision
!= latest_vnfd_revision
:
5773 change_type
= "policy_updated"
5775 # There is new revision of VNFD, update operation is required
5776 current_vnfd_path
= vnfd_id
+ ":" + str(current_vnf_revision
)
5777 latest_vnfd_path
= vnfd_id
+ ":" + str(latest_vnfd_revision
)
5779 step
= "Removing the VNFD packages if they exist in the local path"
5780 shutil
.rmtree(self
.fs
.path
+ current_vnfd_path
, ignore_errors
=True)
5781 shutil
.rmtree(self
.fs
.path
+ latest_vnfd_path
, ignore_errors
=True)
5783 step
= "Get the VNFD packages from FSMongo"
5784 self
.fs
.sync(from_path
=latest_vnfd_path
)
5785 self
.fs
.sync(from_path
=current_vnfd_path
)
5788 "Get the charm-type, charm-id, ee-id if there is deployed VCA"
5790 current_base_folder
= current_vnfd
["_admin"]["storage"]
5791 latest_base_folder
= latest_vnfd
["_admin"]["storage"]
5793 for vca_index
, vca_deployed
in enumerate(
5794 get_iterable(nsr_deployed
, "VCA")
5796 vnf_index
= db_vnfr
.get("member-vnf-index-ref")
5798 # Getting charm-id and charm-type
5799 if vca_deployed
.get("member-vnf-index") == vnf_index
:
5800 vca_id
= self
.get_vca_id(db_vnfr
, db_nsr
)
5801 vca_type
= vca_deployed
.get("type")
5802 vdu_count_index
= vca_deployed
.get("vdu_count_index")
5805 ee_id
= vca_deployed
.get("ee_id")
5807 step
= "Getting descriptor config"
5808 if current_vnfd
.get("kdu"):
5809 search_key
= "kdu_name"
5811 search_key
= "vnfd_id"
5813 entity_id
= vca_deployed
.get(search_key
)
5815 descriptor_config
= get_configuration(
5816 current_vnfd
, entity_id
5819 if "execution-environment-list" in descriptor_config
:
5820 ee_list
= descriptor_config
.get(
5821 "execution-environment-list", []
5826 # There could be several charm used in the same VNF
5827 for ee_item
in ee_list
:
5828 if ee_item
.get("juju"):
5829 step
= "Getting charm name"
5830 charm_name
= ee_item
["juju"].get("charm")
5832 step
= "Setting Charm artifact paths"
5833 current_charm_artifact_path
.append(
5834 get_charm_artifact_path(
5835 current_base_folder
,
5838 current_vnf_revision
,
5841 target_charm_artifact_path
.append(
5842 get_charm_artifact_path(
5846 latest_vnfd_revision
,
5849 elif ee_item
.get("helm-chart"):
5850 # add chart to list and all parameters
5851 step
= "Getting helm chart name"
5852 chart_name
= ee_item
.get("helm-chart")
5853 vca_type
= "helm-v3"
5854 step
= "Setting Helm chart artifact paths"
5856 helm_artifacts
.append(
5858 "current_artifact_path": get_charm_artifact_path(
5859 current_base_folder
,
5862 current_vnf_revision
,
5864 "target_artifact_path": get_charm_artifact_path(
5868 latest_vnfd_revision
,
5871 "vca_index": vca_index
,
5872 "vdu_index": vdu_count_index
,
5876 charm_artifact_paths
= zip(
5877 current_charm_artifact_path
, target_charm_artifact_path
5880 step
= "Checking if software version has changed in VNFD"
5881 if find_software_version(current_vnfd
) != find_software_version(
5884 step
= "Checking if existing VNF has charm"
5885 for current_charm_path
, target_charm_path
in list(
5886 charm_artifact_paths
5888 if current_charm_path
:
5890 "Software version change is not supported as VNF instance {} has charm.".format(
5895 step
= "Checking whether the descriptor has SFC"
5896 if db_nsr
.get("nsd", {}).get("vnffgd"):
5898 "Ns update is not allowed for NS with SFC"
5901 # There is no change in the charm package, then redeploy the VNF
5902 # based on new descriptor
5903 step
= "Redeploying VNF"
5904 member_vnf_index
= db_vnfr
["member-vnf-index-ref"]
5905 (result
, detailed_status
) = await self
._ns
_redeploy
_vnf
(
5906 nsr_id
, nslcmop_id
, latest_vnfd
, db_vnfr
, db_nsr
5908 if result
== "FAILED":
5909 nslcmop_operation_state
= result
5910 error_description_nslcmop
= detailed_status
5911 old_operational_status
= "failed"
5912 db_nslcmop_update
["detailed-status"] = detailed_status
5913 db_nsr_update
["detailed-status"] = detailed_status
5914 scaling_aspect
= get_scaling_aspect(latest_vnfd
)
5915 scaling_group_desc
= db_nsr
.get("_admin").get(
5916 "scaling-group", None
5918 if scaling_group_desc
:
5919 for aspect
in scaling_aspect
:
5920 scaling_group_id
= aspect
.get("id")
5921 for scale_index
, scaling_group
in enumerate(
5924 if scaling_group
.get("name") == scaling_group_id
:
5926 "_admin.scaling-group.{}.nb-scale-op".format(
5932 + " step {} Done with result {} {}".format(
5933 step
, nslcmop_operation_state
, detailed_status
5938 step
= "Checking if any charm package has changed or not"
5939 for current_charm_path
, target_charm_path
in list(
5940 charm_artifact_paths
5944 and target_charm_path
5945 and self
.check_charm_hash_changed(
5946 current_charm_path
, target_charm_path
5949 step
= "Checking whether VNF uses juju bundle"
5950 if check_juju_bundle_existence(current_vnfd
):
5952 "Charm upgrade is not supported for the instance which"
5953 " uses juju-bundle: {}".format(
5954 check_juju_bundle_existence(current_vnfd
)
5958 step
= "Upgrading Charm"
5962 ) = await self
._ns
_charm
_upgrade
(
5965 charm_type
=vca_type
,
5966 path
=self
.fs
.path
+ target_charm_path
,
5967 timeout
=timeout_seconds
,
5970 if result
== "FAILED":
5971 nslcmop_operation_state
= result
5972 error_description_nslcmop
= detailed_status
5974 db_nslcmop_update
["detailed-status"] = detailed_status
5977 + " step {} Done with result {} {}".format(
5978 step
, nslcmop_operation_state
, detailed_status
5982 step
= "Updating policies"
5983 member_vnf_index
= db_vnfr
["member-vnf-index-ref"]
5984 result
= "COMPLETED"
5985 detailed_status
= "Done"
5986 db_nslcmop_update
["detailed-status"] = "Done"
5989 for item
in helm_artifacts
:
5991 item
["current_artifact_path"]
5992 and item
["target_artifact_path"]
5993 and self
.check_charm_hash_changed(
5994 item
["current_artifact_path"],
5995 item
["target_artifact_path"],
5999 db_update_entry
= "_admin.deployed.VCA.{}.".format(
6002 vnfr_id
= db_vnfr
["_id"]
6003 osm_config
= {"osm": {"ns_id": nsr_id
, "vnf_id": vnfr_id
}}
6005 "collection": "nsrs",
6006 "filter": {"_id": nsr_id
},
6007 "path": db_update_entry
,
6009 vca_type
, namespace
, helm_id
= get_ee_id_parts(item
["ee_id"])
6010 await self
.vca_map
[vca_type
].upgrade_execution_environment(
6011 namespace
=namespace
,
6015 artifact_path
=item
["target_artifact_path"],
6018 vnf_id
= db_vnfr
.get("vnfd-ref")
6019 config_descriptor
= get_configuration(latest_vnfd
, vnf_id
)
6020 self
.logger
.debug("get ssh key block")
6024 ("config-access", "ssh-access", "required"),
6026 # Needed to inject a ssh key
6029 ("config-access", "ssh-access", "default-user"),
6032 "Install configuration Software, getting public ssh key"
6034 pub_key
= await self
.vca_map
[
6036 ].get_ee_ssh_public__key(
6037 ee_id
=ee_id
, db_dict
=db_dict
, vca_id
=vca_id
6041 "Insert public key into VM user={} ssh_key={}".format(
6045 self
.logger
.debug(logging_text
+ step
)
6047 # wait for RO (ip-address) Insert pub_key into VM
6048 rw_mgmt_ip
= await self
.wait_vm_up_insert_key_ro(
6058 initial_config_primitive_list
= config_descriptor
.get(
6059 "initial-config-primitive"
6061 config_primitive
= next(
6064 for p
in initial_config_primitive_list
6065 if p
["name"] == "config"
6069 if not config_primitive
:
6072 deploy_params
= {"OSM": get_osm_params(db_vnfr
)}
6074 deploy_params
["rw_mgmt_ip"] = rw_mgmt_ip
6075 if db_vnfr
.get("additionalParamsForVnf"):
6076 deploy_params
.update(
6078 db_vnfr
["additionalParamsForVnf"].copy()
6081 primitive_params_
= self
._map
_primitive
_params
(
6082 config_primitive
, {}, deploy_params
6085 step
= "execute primitive '{}' params '{}'".format(
6086 config_primitive
["name"], primitive_params_
6088 self
.logger
.debug(logging_text
+ step
)
6089 await self
.vca_map
[vca_type
].exec_primitive(
6091 primitive_name
=config_primitive
["name"],
6092 params_dict
=primitive_params_
,
6098 step
= "Updating policies"
6099 member_vnf_index
= db_vnfr
["member-vnf-index-ref"]
6100 detailed_status
= "Done"
6101 db_nslcmop_update
["detailed-status"] = "Done"
6103 # If nslcmop_operation_state is None, so any operation is not failed.
6104 if not nslcmop_operation_state
:
6105 nslcmop_operation_state
= "COMPLETED"
6107 # If update CHANGE_VNFPKG nslcmop_operation is successful
6108 # vnf revision need to be updated
6109 vnfr_update
["revision"] = latest_vnfd_revision
6110 self
.update_db_2("vnfrs", db_vnfr
["_id"], vnfr_update
)
6114 + " task Done with result {} {}".format(
6115 nslcmop_operation_state
, detailed_status
6118 elif update_type
== "REMOVE_VNF":
6119 # This part is included in https://osm.etsi.org/gerrit/11876
6120 vnf_instance_id
= db_nslcmop
["operationParams"]["removeVnfInstanceId"]
6121 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnf_instance_id
})
6122 member_vnf_index
= db_vnfr
["member-vnf-index-ref"]
6123 step
= "Removing VNF"
6124 (result
, detailed_status
) = await self
.remove_vnf(
6125 nsr_id
, nslcmop_id
, vnf_instance_id
6127 if result
== "FAILED":
6128 nslcmop_operation_state
= result
6129 error_description_nslcmop
= detailed_status
6130 db_nslcmop_update
["detailed-status"] = detailed_status
6131 change_type
= "vnf_terminated"
6132 if not nslcmop_operation_state
:
6133 nslcmop_operation_state
= "COMPLETED"
6136 + " task Done with result {} {}".format(
6137 nslcmop_operation_state
, detailed_status
6141 elif update_type
== "OPERATE_VNF":
6142 vnf_id
= db_nslcmop
["operationParams"]["operateVnfData"][
6145 operation_type
= db_nslcmop
["operationParams"]["operateVnfData"][
6148 additional_param
= db_nslcmop
["operationParams"]["operateVnfData"][
6151 (result
, detailed_status
) = await self
.rebuild_start_stop(
6152 nsr_id
, nslcmop_id
, vnf_id
, additional_param
, operation_type
6154 if result
== "FAILED":
6155 nslcmop_operation_state
= result
6156 error_description_nslcmop
= detailed_status
6157 db_nslcmop_update
["detailed-status"] = detailed_status
6158 if not nslcmop_operation_state
:
6159 nslcmop_operation_state
= "COMPLETED"
6162 + " task Done with result {} {}".format(
6163 nslcmop_operation_state
, detailed_status
6167 # If nslcmop_operation_state is None, so any operation is not failed.
6168 # All operations are executed in overall.
6169 if not nslcmop_operation_state
:
6170 nslcmop_operation_state
= "COMPLETED"
6171 db_nsr_update
["operational-status"] = old_operational_status
6173 except (DbException
, LcmException
, N2VCException
, K8sException
) as e
:
6174 self
.logger
.error(logging_text
+ "Exit Exception {}".format(e
))
6176 except asyncio
.CancelledError
:
6178 logging_text
+ "Cancelled Exception while '{}'".format(step
)
6180 exc
= "Operation was cancelled"
6181 except asyncio
.TimeoutError
:
6182 self
.logger
.error(logging_text
+ "Timeout while '{}'".format(step
))
6184 except Exception as e
:
6185 exc
= traceback
.format_exc()
6186 self
.logger
.critical(
6187 logging_text
+ "Exit Exception {} {}".format(type(e
).__name
__, e
),
6196 ) = error_description_nslcmop
= "FAILED {}: {}".format(step
, exc
)
6197 nslcmop_operation_state
= "FAILED"
6198 db_nsr_update
["operational-status"] = old_operational_status
6200 self
._write
_ns
_status
(
6202 ns_state
=db_nsr
["nsState"],
6203 current_operation
="IDLE",
6204 current_operation_id
=None,
6205 other_update
=db_nsr_update
,
6208 self
._write
_op
_status
(
6211 error_message
=error_description_nslcmop
,
6212 operation_state
=nslcmop_operation_state
,
6213 other_update
=db_nslcmop_update
,
6216 if nslcmop_operation_state
:
6220 "nslcmop_id": nslcmop_id
,
6221 "operationState": nslcmop_operation_state
,
6224 change_type
in ("vnf_terminated", "policy_updated")
6225 and member_vnf_index
6227 msg
.update({"vnf_member_index": member_vnf_index
})
6228 await self
.msg
.aiowrite("ns", change_type
, msg
)
6229 except Exception as e
:
6231 logging_text
+ "kafka_write notification Exception {}".format(e
)
6233 self
.logger
.debug(logging_text
+ "Exit")
6234 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_update")
6235 return nslcmop_operation_state
, detailed_status
6237 async def scale(self
, nsr_id
, nslcmop_id
):
6238 # Try to lock HA task here
6239 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
6240 if not task_is_locked_by_me
:
6243 logging_text
= "Task ns={} scale={} ".format(nsr_id
, nslcmop_id
)
6244 stage
= ["", "", ""]
6245 tasks_dict_info
= {}
6246 # ^ stage, step, VIM progress
6247 self
.logger
.debug(logging_text
+ "Enter")
6248 # get all needed from database
6250 db_nslcmop_update
= {}
6253 # in case of error, indicates what part of scale was failed to put nsr at error status
6254 scale_process
= None
6255 old_operational_status
= ""
6256 old_config_status
= ""
6260 # wait for any previous tasks in process
6261 step
= "Waiting for previous operations to terminate"
6262 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
6263 self
._write
_ns
_status
(
6266 current_operation
="SCALING",
6267 current_operation_id
=nslcmop_id
,
6270 step
= "Getting nslcmop from database"
6272 step
+ " after having waited for previous tasks to be completed"
6274 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
6276 step
= "Getting nsr from database"
6277 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
6278 old_operational_status
= db_nsr
["operational-status"]
6279 old_config_status
= db_nsr
["config-status"]
6281 step
= "Checking whether the descriptor has SFC"
6282 if db_nsr
.get("nsd", {}).get("vnffgd"):
6283 raise LcmException("Scaling is not allowed for NS with SFC")
6285 step
= "Parsing scaling parameters"
6286 db_nsr_update
["operational-status"] = "scaling"
6287 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
6288 nsr_deployed
= db_nsr
["_admin"].get("deployed")
6290 vnf_index
= db_nslcmop
["operationParams"]["scaleVnfData"][
6292 ]["member-vnf-index"]
6293 scaling_group
= db_nslcmop
["operationParams"]["scaleVnfData"][
6295 ]["scaling-group-descriptor"]
6296 scaling_type
= db_nslcmop
["operationParams"]["scaleVnfData"]["scaleVnfType"]
6297 # for backward compatibility
6298 if nsr_deployed
and isinstance(nsr_deployed
.get("VCA"), dict):
6299 nsr_deployed
["VCA"] = list(nsr_deployed
["VCA"].values())
6300 db_nsr_update
["_admin.deployed.VCA"] = nsr_deployed
["VCA"]
6301 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
6303 step
= "Getting vnfr from database"
6304 db_vnfr
= self
.db
.get_one(
6305 "vnfrs", {"member-vnf-index-ref": vnf_index
, "nsr-id-ref": nsr_id
}
6308 vca_id
= self
.get_vca_id(db_vnfr
, db_nsr
)
6310 step
= "Getting vnfd from database"
6311 db_vnfd
= self
.db
.get_one("vnfds", {"_id": db_vnfr
["vnfd-id"]})
6313 base_folder
= db_vnfd
["_admin"]["storage"]
6315 step
= "Getting scaling-group-descriptor"
6316 scaling_descriptor
= find_in_list(
6317 get_scaling_aspect(db_vnfd
),
6318 lambda scale_desc
: scale_desc
["name"] == scaling_group
,
6320 if not scaling_descriptor
:
6322 "input parameter 'scaleByStepData':'scaling-group-descriptor':'{}' is not present "
6323 "at vnfd:scaling-group-descriptor".format(scaling_group
)
6326 step
= "Sending scale order to VIM"
6327 # TODO check if ns is in a proper status
6329 if not db_nsr
["_admin"].get("scaling-group"):
6334 "_admin.scaling-group": [
6335 {"name": scaling_group
, "nb-scale-op": 0}
6339 admin_scale_index
= 0
6341 for admin_scale_index
, admin_scale_info
in enumerate(
6342 db_nsr
["_admin"]["scaling-group"]
6344 if admin_scale_info
["name"] == scaling_group
:
6345 nb_scale_op
= admin_scale_info
.get("nb-scale-op", 0)
6347 else: # not found, set index one plus last element and add new entry with the name
6348 admin_scale_index
+= 1
6350 "_admin.scaling-group.{}.name".format(admin_scale_index
)
6353 vca_scaling_info
= []
6354 scaling_info
= {"scaling_group_name": scaling_group
, "vdu": [], "kdu": []}
6355 if scaling_type
== "SCALE_OUT":
6356 if "aspect-delta-details" not in scaling_descriptor
:
6358 "Aspect delta details not fount in scaling descriptor {}".format(
6359 scaling_descriptor
["name"]
6362 # count if max-instance-count is reached
6363 deltas
= scaling_descriptor
.get("aspect-delta-details")["deltas"]
6365 scaling_info
["scaling_direction"] = "OUT"
6366 scaling_info
["vdu-create"] = {}
6367 scaling_info
["kdu-create"] = {}
6368 for delta
in deltas
:
6369 for vdu_delta
in delta
.get("vdu-delta", {}):
6370 vdud
= get_vdu(db_vnfd
, vdu_delta
["id"])
6371 # vdu_index also provides the number of instance of the targeted vdu
6372 vdu_count
= vdu_index
= get_vdur_index(db_vnfr
, vdu_delta
)
6373 if vdu_index
<= len(db_vnfr
["vdur"]):
6374 vdu_name_id
= db_vnfr
["vdur"][vdu_index
- 1]["vdu-name"]
6376 db_vnfr
["_id"] + vdu_name_id
+ str(vdu_index
- 1)
6378 prom_job_name
= prom_job_name
.replace("_", "")
6379 prom_job_name
= prom_job_name
.replace("-", "")
6381 prom_job_name
= None
6382 cloud_init_text
= self
._get
_vdu
_cloud
_init
_content
(
6386 additional_params
= (
6387 self
._get
_vdu
_additional
_params
(db_vnfr
, vdud
["id"])
6390 cloud_init_list
= []
6392 vdu_profile
= get_vdu_profile(db_vnfd
, vdu_delta
["id"])
6393 max_instance_count
= 10
6394 if vdu_profile
and "max-number-of-instances" in vdu_profile
:
6395 max_instance_count
= vdu_profile
.get(
6396 "max-number-of-instances", 10
6399 default_instance_num
= get_number_of_instances(
6402 instances_number
= vdu_delta
.get("number-of-instances", 1)
6403 nb_scale_op
+= instances_number
6405 new_instance_count
= nb_scale_op
+ default_instance_num
6406 # Control if new count is over max and vdu count is less than max.
6407 # Then assign new instance count
6408 if new_instance_count
> max_instance_count
> vdu_count
:
6409 instances_number
= new_instance_count
- max_instance_count
6411 instances_number
= instances_number
6413 if new_instance_count
> max_instance_count
:
6415 "reached the limit of {} (max-instance-count) "
6416 "scaling-out operations for the "
6417 "scaling-group-descriptor '{}'".format(
6418 nb_scale_op
, scaling_group
6421 for x
in range(vdu_delta
.get("number-of-instances", 1)):
6423 # TODO Information of its own ip is not available because db_vnfr is not updated.
6424 additional_params
["OSM"] = get_osm_params(
6425 db_vnfr
, vdu_delta
["id"], vdu_index
+ x
6427 cloud_init_list
.append(
6428 self
._parse
_cloud
_init
(
6435 vca_scaling_info
.append(
6437 "osm_vdu_id": vdu_delta
["id"],
6438 "member-vnf-index": vnf_index
,
6440 "vdu_index": vdu_index
+ x
,
6443 scaling_info
["vdu-create"][vdu_delta
["id"]] = instances_number
6444 for kdu_delta
in delta
.get("kdu-resource-delta", {}):
6445 kdu_profile
= get_kdu_resource_profile(db_vnfd
, kdu_delta
["id"])
6446 kdu_name
= kdu_profile
["kdu-name"]
6447 resource_name
= kdu_profile
.get("resource-name", "")
6449 # Might have different kdus in the same delta
6450 # Should have list for each kdu
6451 if not scaling_info
["kdu-create"].get(kdu_name
, None):
6452 scaling_info
["kdu-create"][kdu_name
] = []
6454 kdur
= get_kdur(db_vnfr
, kdu_name
)
6455 if kdur
.get("helm-chart"):
6456 k8s_cluster_type
= "helm-chart-v3"
6457 self
.logger
.debug("kdur: {}".format(kdur
))
6458 elif kdur
.get("juju-bundle"):
6459 k8s_cluster_type
= "juju-bundle"
6462 "kdu type for kdu='{}.{}' is neither helm-chart nor "
6463 "juju-bundle. Maybe an old NBI version is running".format(
6464 db_vnfr
["member-vnf-index-ref"], kdu_name
6468 max_instance_count
= 10
6469 if kdu_profile
and "max-number-of-instances" in kdu_profile
:
6470 max_instance_count
= kdu_profile
.get(
6471 "max-number-of-instances", 10
6474 nb_scale_op
+= kdu_delta
.get("number-of-instances", 1)
6475 deployed_kdu
, _
= get_deployed_kdu(
6476 nsr_deployed
, kdu_name
, vnf_index
6478 if deployed_kdu
is None:
6480 "KDU '{}' for vnf '{}' not deployed".format(
6484 kdu_instance
= deployed_kdu
.get("kdu-instance")
6485 instance_num
= await self
.k8scluster_map
[
6491 cluster_uuid
=deployed_kdu
.get("k8scluster-uuid"),
6492 kdu_model
=deployed_kdu
.get("kdu-model"),
6494 kdu_replica_count
= instance_num
+ kdu_delta
.get(
6495 "number-of-instances", 1
6498 # Control if new count is over max and instance_num is less than max.
6499 # Then assign max instance number to kdu replica count
6500 if kdu_replica_count
> max_instance_count
> instance_num
:
6501 kdu_replica_count
= max_instance_count
6502 if kdu_replica_count
> max_instance_count
:
6504 "reached the limit of {} (max-instance-count) "
6505 "scaling-out operations for the "
6506 "scaling-group-descriptor '{}'".format(
6507 instance_num
, scaling_group
6511 for x
in range(kdu_delta
.get("number-of-instances", 1)):
6512 vca_scaling_info
.append(
6514 "osm_kdu_id": kdu_name
,
6515 "member-vnf-index": vnf_index
,
6517 "kdu_index": instance_num
+ x
- 1,
6520 scaling_info
["kdu-create"][kdu_name
].append(
6522 "member-vnf-index": vnf_index
,
6524 "k8s-cluster-type": k8s_cluster_type
,
6525 "resource-name": resource_name
,
6526 "scale": kdu_replica_count
,
6529 elif scaling_type
== "SCALE_IN":
6530 deltas
= scaling_descriptor
.get("aspect-delta-details")["deltas"]
6532 scaling_info
["scaling_direction"] = "IN"
6533 scaling_info
["vdu-delete"] = {}
6534 scaling_info
["kdu-delete"] = {}
6536 for delta
in deltas
:
6537 for vdu_delta
in delta
.get("vdu-delta", {}):
6538 vdu_count
= vdu_index
= get_vdur_index(db_vnfr
, vdu_delta
)
6539 min_instance_count
= 0
6540 vdu_profile
= get_vdu_profile(db_vnfd
, vdu_delta
["id"])
6541 if vdu_profile
and "min-number-of-instances" in vdu_profile
:
6542 min_instance_count
= vdu_profile
["min-number-of-instances"]
6544 default_instance_num
= get_number_of_instances(
6545 db_vnfd
, vdu_delta
["id"]
6547 instance_num
= vdu_delta
.get("number-of-instances", 1)
6548 nb_scale_op
-= instance_num
6550 new_instance_count
= nb_scale_op
+ default_instance_num
6552 if new_instance_count
< min_instance_count
< vdu_count
:
6553 instances_number
= min_instance_count
- new_instance_count
6555 instances_number
= instance_num
6557 if new_instance_count
< min_instance_count
:
6559 "reached the limit of {} (min-instance-count) scaling-in operations for the "
6560 "scaling-group-descriptor '{}'".format(
6561 nb_scale_op
, scaling_group
6564 for x
in range(vdu_delta
.get("number-of-instances", 1)):
6565 vca_scaling_info
.append(
6567 "osm_vdu_id": vdu_delta
["id"],
6568 "member-vnf-index": vnf_index
,
6570 "vdu_index": vdu_index
- 1 - x
,
6573 scaling_info
["vdu-delete"][vdu_delta
["id"]] = instances_number
6574 for kdu_delta
in delta
.get("kdu-resource-delta", {}):
6575 kdu_profile
= get_kdu_resource_profile(db_vnfd
, kdu_delta
["id"])
6576 kdu_name
= kdu_profile
["kdu-name"]
6577 resource_name
= kdu_profile
.get("resource-name", "")
6579 if not scaling_info
["kdu-delete"].get(kdu_name
, None):
6580 scaling_info
["kdu-delete"][kdu_name
] = []
6582 kdur
= get_kdur(db_vnfr
, kdu_name
)
6583 if kdur
.get("helm-chart"):
6584 k8s_cluster_type
= "helm-chart-v3"
6585 self
.logger
.debug("kdur: {}".format(kdur
))
6586 elif kdur
.get("juju-bundle"):
6587 k8s_cluster_type
= "juju-bundle"
6590 "kdu type for kdu='{}.{}' is neither helm-chart nor "
6591 "juju-bundle. Maybe an old NBI version is running".format(
6592 db_vnfr
["member-vnf-index-ref"], kdur
["kdu-name"]
6596 min_instance_count
= 0
6597 if kdu_profile
and "min-number-of-instances" in kdu_profile
:
6598 min_instance_count
= kdu_profile
["min-number-of-instances"]
6600 nb_scale_op
-= kdu_delta
.get("number-of-instances", 1)
6601 deployed_kdu
, _
= get_deployed_kdu(
6602 nsr_deployed
, kdu_name
, vnf_index
6604 if deployed_kdu
is None:
6606 "KDU '{}' for vnf '{}' not deployed".format(
6610 kdu_instance
= deployed_kdu
.get("kdu-instance")
6611 instance_num
= await self
.k8scluster_map
[
6617 cluster_uuid
=deployed_kdu
.get("k8scluster-uuid"),
6618 kdu_model
=deployed_kdu
.get("kdu-model"),
6620 kdu_replica_count
= instance_num
- kdu_delta
.get(
6621 "number-of-instances", 1
6624 if kdu_replica_count
< min_instance_count
< instance_num
:
6625 kdu_replica_count
= min_instance_count
6626 if kdu_replica_count
< min_instance_count
:
6628 "reached the limit of {} (min-instance-count) scaling-in operations for the "
6629 "scaling-group-descriptor '{}'".format(
6630 instance_num
, scaling_group
6634 for x
in range(kdu_delta
.get("number-of-instances", 1)):
6635 vca_scaling_info
.append(
6637 "osm_kdu_id": kdu_name
,
6638 "member-vnf-index": vnf_index
,
6640 "kdu_index": instance_num
- x
- 1,
6643 scaling_info
["kdu-delete"][kdu_name
].append(
6645 "member-vnf-index": vnf_index
,
6647 "k8s-cluster-type": k8s_cluster_type
,
6648 "resource-name": resource_name
,
6649 "scale": kdu_replica_count
,
6653 # update VDU_SCALING_INFO with the VDUs to delete ip_addresses
6654 vdu_delete
= copy(scaling_info
.get("vdu-delete"))
6655 if scaling_info
["scaling_direction"] == "IN":
6656 for vdur
in reversed(db_vnfr
["vdur"]):
6657 if vdu_delete
.get(vdur
["vdu-id-ref"]):
6658 vdu_delete
[vdur
["vdu-id-ref"]] -= 1
6659 scaling_info
["vdu"].append(
6661 "name": vdur
.get("name") or vdur
.get("vdu-name"),
6662 "vdu_id": vdur
["vdu-id-ref"],
6666 for interface
in vdur
["interfaces"]:
6667 scaling_info
["vdu"][-1]["interface"].append(
6669 "name": interface
["name"],
6670 "ip_address": interface
["ip-address"],
6671 "mac_address": interface
.get("mac-address"),
6674 # vdu_delete = vdu_scaling_info.pop("vdu-delete")
6677 step
= "Executing pre-scale vnf-config-primitive"
6678 if scaling_descriptor
.get("scaling-config-action"):
6679 for scaling_config_action
in scaling_descriptor
[
6680 "scaling-config-action"
6683 scaling_config_action
.get("trigger") == "pre-scale-in"
6684 and scaling_type
== "SCALE_IN"
6686 scaling_config_action
.get("trigger") == "pre-scale-out"
6687 and scaling_type
== "SCALE_OUT"
6689 vnf_config_primitive
= scaling_config_action
[
6690 "vnf-config-primitive-name-ref"
6692 step
= db_nslcmop_update
[
6694 ] = "executing pre-scale scaling-config-action '{}'".format(
6695 vnf_config_primitive
6698 # look for primitive
6699 for config_primitive
in (
6700 get_configuration(db_vnfd
, db_vnfd
["id"]) or {}
6701 ).get("config-primitive", ()):
6702 if config_primitive
["name"] == vnf_config_primitive
:
6706 "Invalid vnfd descriptor at scaling-group-descriptor[name='{}']:scaling-config-action"
6707 "[vnf-config-primitive-name-ref='{}'] does not match any vnf-configuration:config-"
6708 "primitive".format(scaling_group
, vnf_config_primitive
)
6711 vnfr_params
= {"VDU_SCALE_INFO": scaling_info
}
6712 if db_vnfr
.get("additionalParamsForVnf"):
6713 vnfr_params
.update(db_vnfr
["additionalParamsForVnf"])
6715 scale_process
= "VCA"
6716 db_nsr_update
["config-status"] = "configuring pre-scaling"
6717 primitive_params
= self
._map
_primitive
_params
(
6718 config_primitive
, {}, vnfr_params
6721 # Pre-scale retry check: Check if this sub-operation has been executed before
6722 op_index
= self
._check
_or
_add
_scale
_suboperation
(
6725 vnf_config_primitive
,
6729 if op_index
== self
.SUBOPERATION_STATUS_SKIP
:
6730 # Skip sub-operation
6731 result
= "COMPLETED"
6732 result_detail
= "Done"
6735 + "vnf_config_primitive={} Skipped sub-operation, result {} {}".format(
6736 vnf_config_primitive
, result
, result_detail
6740 if op_index
== self
.SUBOPERATION_STATUS_NEW
:
6741 # New sub-operation: Get index of this sub-operation
6743 len(db_nslcmop
.get("_admin", {}).get("operations"))
6748 + "vnf_config_primitive={} New sub-operation".format(
6749 vnf_config_primitive
6753 # retry: Get registered params for this existing sub-operation
6754 op
= db_nslcmop
.get("_admin", {}).get("operations", [])[
6757 vnf_index
= op
.get("member_vnf_index")
6758 vnf_config_primitive
= op
.get("primitive")
6759 primitive_params
= op
.get("primitive_params")
6762 + "vnf_config_primitive={} Sub-operation retry".format(
6763 vnf_config_primitive
6766 # Execute the primitive, either with new (first-time) or registered (reintent) args
6767 ee_descriptor_id
= config_primitive
.get(
6768 "execution-environment-ref"
6770 primitive_name
= config_primitive
.get(
6771 "execution-environment-primitive", vnf_config_primitive
6773 ee_id
, vca_type
= self
._look
_for
_deployed
_vca
(
6774 nsr_deployed
["VCA"],
6775 member_vnf_index
=vnf_index
,
6777 vdu_count_index
=None,
6778 ee_descriptor_id
=ee_descriptor_id
,
6780 result
, result_detail
= await self
._ns
_execute
_primitive
(
6789 + "vnf_config_primitive={} Done with result {} {}".format(
6790 vnf_config_primitive
, result
, result_detail
6793 # Update operationState = COMPLETED | FAILED
6794 self
._update
_suboperation
_status
(
6795 db_nslcmop
, op_index
, result
, result_detail
6798 if result
== "FAILED":
6799 raise LcmException(result_detail
)
6800 db_nsr_update
["config-status"] = old_config_status
6801 scale_process
= None
6805 "_admin.scaling-group.{}.nb-scale-op".format(admin_scale_index
)
6808 "_admin.scaling-group.{}.time".format(admin_scale_index
)
6811 # SCALE-IN VCA - BEGIN
6812 if vca_scaling_info
:
6813 step
= db_nslcmop_update
[
6815 ] = "Deleting the execution environments"
6816 scale_process
= "VCA"
6817 for vca_info
in vca_scaling_info
:
6818 if vca_info
["type"] == "delete" and not vca_info
.get("osm_kdu_id"):
6819 member_vnf_index
= str(vca_info
["member-vnf-index"])
6821 logging_text
+ "vdu info: {}".format(vca_info
)
6823 if vca_info
.get("osm_vdu_id"):
6824 vdu_id
= vca_info
["osm_vdu_id"]
6825 vdu_index
= int(vca_info
["vdu_index"])
6828 ] = "Scaling member_vnf_index={}, vdu_id={}, vdu_index={} ".format(
6829 member_vnf_index
, vdu_id
, vdu_index
6831 stage
[2] = step
= "Scaling in VCA"
6832 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
)
6833 vca_update
= db_nsr
["_admin"]["deployed"]["VCA"]
6834 config_update
= db_nsr
["configurationStatus"]
6835 for vca_index
, vca
in enumerate(vca_update
):
6837 (vca
or vca
.get("ee_id"))
6838 and vca
["member-vnf-index"] == member_vnf_index
6839 and vca
["vdu_count_index"] == vdu_index
6841 if vca
.get("vdu_id"):
6842 config_descriptor
= get_configuration(
6843 db_vnfd
, vca
.get("vdu_id")
6845 elif vca
.get("kdu_name"):
6846 config_descriptor
= get_configuration(
6847 db_vnfd
, vca
.get("kdu_name")
6850 config_descriptor
= get_configuration(
6851 db_vnfd
, db_vnfd
["id"]
6853 operation_params
= (
6854 db_nslcmop
.get("operationParams") or {}
6856 exec_terminate_primitives
= not operation_params
.get(
6857 "skip_terminate_primitives"
6858 ) and vca
.get("needed_terminate")
6859 task
= asyncio
.ensure_future(
6868 exec_primitives
=exec_terminate_primitives
,
6872 timeout
=self
.timeout
.charm_delete
,
6875 tasks_dict_info
[task
] = "Terminating VCA {}".format(
6878 del vca_update
[vca_index
]
6879 del config_update
[vca_index
]
6880 # wait for pending tasks of terminate primitives
6884 + "Waiting for tasks {}".format(
6885 list(tasks_dict_info
.keys())
6888 error_list
= await self
._wait
_for
_tasks
(
6892 self
.timeout
.charm_delete
, self
.timeout
.ns_terminate
6897 tasks_dict_info
.clear()
6899 raise LcmException("; ".join(error_list
))
6901 db_vca_and_config_update
= {
6902 "_admin.deployed.VCA": vca_update
,
6903 "configurationStatus": config_update
,
6906 "nsrs", db_nsr
["_id"], db_vca_and_config_update
6908 scale_process
= None
6909 # SCALE-IN VCA - END
6912 if scaling_info
.get("vdu-create") or scaling_info
.get("vdu-delete"):
6913 scale_process
= "RO"
6914 if self
.ro_config
.ng
:
6915 await self
._scale
_ng
_ro
(
6916 logging_text
, db_nsr
, db_nslcmop
, db_vnfr
, scaling_info
, stage
6918 scaling_info
.pop("vdu-create", None)
6919 scaling_info
.pop("vdu-delete", None)
6921 scale_process
= None
6925 if scaling_info
.get("kdu-create") or scaling_info
.get("kdu-delete"):
6926 scale_process
= "KDU"
6927 await self
._scale
_kdu
(
6928 logging_text
, nsr_id
, nsr_deployed
, db_vnfd
, vca_id
, scaling_info
6930 scaling_info
.pop("kdu-create", None)
6931 scaling_info
.pop("kdu-delete", None)
6933 scale_process
= None
6937 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
6939 # SCALE-UP VCA - BEGIN
6940 if vca_scaling_info
:
6941 step
= db_nslcmop_update
[
6943 ] = "Creating new execution environments"
6944 scale_process
= "VCA"
6945 for vca_info
in vca_scaling_info
:
6946 if vca_info
["type"] == "create" and not vca_info
.get("osm_kdu_id"):
6947 member_vnf_index
= str(vca_info
["member-vnf-index"])
6949 logging_text
+ "vdu info: {}".format(vca_info
)
6951 vnfd_id
= db_vnfr
["vnfd-ref"]
6952 if vca_info
.get("osm_vdu_id"):
6953 vdu_index
= int(vca_info
["vdu_index"])
6954 deploy_params
= {"OSM": get_osm_params(db_vnfr
)}
6955 if db_vnfr
.get("additionalParamsForVnf"):
6956 deploy_params
.update(
6958 db_vnfr
["additionalParamsForVnf"].copy()
6961 descriptor_config
= get_configuration(
6962 db_vnfd
, db_vnfd
["id"]
6964 if descriptor_config
:
6970 logging_text
=logging_text
6971 + "member_vnf_index={} ".format(member_vnf_index
),
6974 nslcmop_id
=nslcmop_id
,
6980 kdu_index
=kdu_index
,
6981 member_vnf_index
=member_vnf_index
,
6982 vdu_index
=vdu_index
,
6984 deploy_params
=deploy_params
,
6985 descriptor_config
=descriptor_config
,
6986 base_folder
=base_folder
,
6987 task_instantiation_info
=tasks_dict_info
,
6990 vdu_id
= vca_info
["osm_vdu_id"]
6991 vdur
= find_in_list(
6992 db_vnfr
["vdur"], lambda vdu
: vdu
["vdu-id-ref"] == vdu_id
6994 descriptor_config
= get_configuration(db_vnfd
, vdu_id
)
6995 if vdur
.get("additionalParams"):
6996 deploy_params_vdu
= parse_yaml_strings(
6997 vdur
["additionalParams"]
7000 deploy_params_vdu
= deploy_params
7001 deploy_params_vdu
["OSM"] = get_osm_params(
7002 db_vnfr
, vdu_id
, vdu_count_index
=vdu_index
7004 if descriptor_config
:
7010 ] = "Scaling member_vnf_index={}, vdu_id={}, vdu_index={} ".format(
7011 member_vnf_index
, vdu_id
, vdu_index
7013 stage
[2] = step
= "Scaling out VCA"
7014 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
)
7016 logging_text
=logging_text
7017 + "member_vnf_index={}, vdu_id={}, vdu_index={} ".format(
7018 member_vnf_index
, vdu_id
, vdu_index
7022 nslcmop_id
=nslcmop_id
,
7028 member_vnf_index
=member_vnf_index
,
7029 vdu_index
=vdu_index
,
7030 kdu_index
=kdu_index
,
7032 deploy_params
=deploy_params_vdu
,
7033 descriptor_config
=descriptor_config
,
7034 base_folder
=base_folder
,
7035 task_instantiation_info
=tasks_dict_info
,
7038 # SCALE-UP VCA - END
7039 scale_process
= None
7042 # execute primitive service POST-SCALING
7043 step
= "Executing post-scale vnf-config-primitive"
7044 if scaling_descriptor
.get("scaling-config-action"):
7045 for scaling_config_action
in scaling_descriptor
[
7046 "scaling-config-action"
7049 scaling_config_action
.get("trigger") == "post-scale-in"
7050 and scaling_type
== "SCALE_IN"
7052 scaling_config_action
.get("trigger") == "post-scale-out"
7053 and scaling_type
== "SCALE_OUT"
7055 vnf_config_primitive
= scaling_config_action
[
7056 "vnf-config-primitive-name-ref"
7058 step
= db_nslcmop_update
[
7060 ] = "executing post-scale scaling-config-action '{}'".format(
7061 vnf_config_primitive
7064 vnfr_params
= {"VDU_SCALE_INFO": scaling_info
}
7065 if db_vnfr
.get("additionalParamsForVnf"):
7066 vnfr_params
.update(db_vnfr
["additionalParamsForVnf"])
7068 # look for primitive
7069 for config_primitive
in (
7070 get_configuration(db_vnfd
, db_vnfd
["id"]) or {}
7071 ).get("config-primitive", ()):
7072 if config_primitive
["name"] == vnf_config_primitive
:
7076 "Invalid vnfd descriptor at scaling-group-descriptor[name='{}']:scaling-config-"
7077 "action[vnf-config-primitive-name-ref='{}'] does not match any vnf-configuration:"
7078 "config-primitive".format(
7079 scaling_group
, vnf_config_primitive
7082 scale_process
= "VCA"
7083 db_nsr_update
["config-status"] = "configuring post-scaling"
7084 primitive_params
= self
._map
_primitive
_params
(
7085 config_primitive
, {}, vnfr_params
7088 # Post-scale retry check: Check if this sub-operation has been executed before
7089 op_index
= self
._check
_or
_add
_scale
_suboperation
(
7092 vnf_config_primitive
,
7096 if op_index
== self
.SUBOPERATION_STATUS_SKIP
:
7097 # Skip sub-operation
7098 result
= "COMPLETED"
7099 result_detail
= "Done"
7102 + "vnf_config_primitive={} Skipped sub-operation, result {} {}".format(
7103 vnf_config_primitive
, result
, result_detail
7107 if op_index
== self
.SUBOPERATION_STATUS_NEW
:
7108 # New sub-operation: Get index of this sub-operation
7110 len(db_nslcmop
.get("_admin", {}).get("operations"))
7115 + "vnf_config_primitive={} New sub-operation".format(
7116 vnf_config_primitive
7120 # retry: Get registered params for this existing sub-operation
7121 op
= db_nslcmop
.get("_admin", {}).get("operations", [])[
7124 vnf_index
= op
.get("member_vnf_index")
7125 vnf_config_primitive
= op
.get("primitive")
7126 primitive_params
= op
.get("primitive_params")
7129 + "vnf_config_primitive={} Sub-operation retry".format(
7130 vnf_config_primitive
7133 # Execute the primitive, either with new (first-time) or registered (reintent) args
7134 ee_descriptor_id
= config_primitive
.get(
7135 "execution-environment-ref"
7137 primitive_name
= config_primitive
.get(
7138 "execution-environment-primitive", vnf_config_primitive
7140 ee_id
, vca_type
= self
._look
_for
_deployed
_vca
(
7141 nsr_deployed
["VCA"],
7142 member_vnf_index
=vnf_index
,
7144 vdu_count_index
=None,
7145 ee_descriptor_id
=ee_descriptor_id
,
7147 result
, result_detail
= await self
._ns
_execute
_primitive
(
7156 + "vnf_config_primitive={} Done with result {} {}".format(
7157 vnf_config_primitive
, result
, result_detail
7160 # Update operationState = COMPLETED | FAILED
7161 self
._update
_suboperation
_status
(
7162 db_nslcmop
, op_index
, result
, result_detail
7165 if result
== "FAILED":
7166 raise LcmException(result_detail
)
7167 db_nsr_update
["config-status"] = old_config_status
7168 scale_process
= None
7170 # Check if each vnf has exporter for metric collection if so update prometheus job records
7171 if scaling_type
== "SCALE_OUT":
7172 if "exporters-endpoints" in db_vnfd
.get("df")[0]:
7173 vnfr_id
= db_vnfr
["id"]
7174 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnfr_id
})
7175 exporter_config
= db_vnfd
.get("df")[0].get("exporters-endpoints")
7176 self
.logger
.debug("exporter config :{}".format(exporter_config
))
7177 artifact_path
= "{}/{}/{}".format(
7178 base_folder
["folder"],
7179 base_folder
["pkg-dir"],
7180 "exporter-endpoint",
7183 ee_config_descriptor
= exporter_config
7184 rw_mgmt_ip
= await self
.wait_vm_up_insert_key_ro(
7188 vdu_id
=db_vnfr
["vdur"][-1]["vdu-id-ref"],
7189 vdu_index
=db_vnfr
["vdur"][-1]["count-index"],
7193 self
.logger
.debug("rw_mgmt_ip:{}".format(rw_mgmt_ip
))
7194 self
.logger
.debug("Artifact_path:{}".format(artifact_path
))
7195 vdu_id_for_prom
= None
7196 vdu_index_for_prom
= None
7197 for x
in get_iterable(db_vnfr
, "vdur"):
7198 vdu_id_for_prom
= x
.get("vdu-id-ref")
7199 vdu_index_for_prom
= x
.get("count-index")
7200 vnfr_id
= vnfr_id
+ vdu_id
+ str(vdu_index
)
7201 vnfr_id
= vnfr_id
.replace("_", "")
7202 prometheus_jobs
= await self
.extract_prometheus_scrape_jobs(
7204 artifact_path
=artifact_path
,
7205 ee_config_descriptor
=ee_config_descriptor
,
7208 target_ip
=rw_mgmt_ip
,
7210 vdu_id
=vdu_id_for_prom
,
7211 vdu_index
=vdu_index_for_prom
,
7214 self
.logger
.debug("Prometheus job:{}".format(prometheus_jobs
))
7217 "_admin.deployed.prometheus_jobs"
7225 for job
in prometheus_jobs
:
7231 fail_on_empty
=False,
7235 ] = "" # "scaled {} {}".format(scaling_group, scaling_type)
7236 db_nsr_update
["operational-status"] = (
7238 if old_operational_status
== "failed"
7239 else old_operational_status
7241 db_nsr_update
["config-status"] = old_config_status
7244 ROclient
.ROClientException
,
7249 self
.logger
.error(logging_text
+ "Exit Exception {}".format(e
))
7251 except asyncio
.CancelledError
:
7253 logging_text
+ "Cancelled Exception while '{}'".format(step
)
7255 exc
= "Operation was cancelled"
7256 except Exception as e
:
7257 exc
= traceback
.format_exc()
7258 self
.logger
.critical(
7259 logging_text
+ "Exit Exception {} {}".format(type(e
).__name
__, e
),
7265 error_list
.append(str(exc
))
7266 self
._write
_ns
_status
(
7269 current_operation
="IDLE",
7270 current_operation_id
=None,
7274 stage
[1] = "Waiting for instantiate pending tasks."
7275 self
.logger
.debug(logging_text
+ stage
[1])
7276 exc
= await self
._wait
_for
_tasks
(
7279 self
.timeout
.ns_deploy
,
7284 except asyncio
.CancelledError
:
7285 error_list
.append("Cancelled")
7286 await self
._cancel
_pending
_tasks
(logging_text
, tasks_dict_info
)
7287 await self
._wait
_for
_tasks
(
7290 self
.timeout
.ns_deploy
,
7296 error_detail
= "; ".join(error_list
)
7299 ] = error_description_nslcmop
= "FAILED {}: {}".format(
7302 nslcmop_operation_state
= "FAILED"
7304 db_nsr_update
["operational-status"] = old_operational_status
7305 db_nsr_update
["config-status"] = old_config_status
7306 db_nsr_update
["detailed-status"] = ""
7308 if "VCA" in scale_process
:
7309 db_nsr_update
["config-status"] = "failed"
7310 if "RO" in scale_process
:
7311 db_nsr_update
["operational-status"] = "failed"
7314 ] = "FAILED scaling nslcmop={} {}: {}".format(
7315 nslcmop_id
, step
, error_detail
7318 error_description_nslcmop
= None
7319 nslcmop_operation_state
= "COMPLETED"
7320 db_nslcmop_update
["detailed-status"] = "Done"
7321 if scaling_type
== "SCALE_IN" and prom_job_name
is not None:
7324 {"job_name": prom_job_name
},
7325 fail_on_empty
=False,
7328 self
._write
_op
_status
(
7331 error_message
=error_description_nslcmop
,
7332 operation_state
=nslcmop_operation_state
,
7333 other_update
=db_nslcmop_update
,
7336 self
._write
_ns
_status
(
7339 current_operation
="IDLE",
7340 current_operation_id
=None,
7341 other_update
=db_nsr_update
,
7344 if nslcmop_operation_state
:
7348 "nslcmop_id": nslcmop_id
,
7349 "operationState": nslcmop_operation_state
,
7351 await self
.msg
.aiowrite("ns", "scaled", msg
)
7352 except Exception as e
:
7354 logging_text
+ "kafka_write notification Exception {}".format(e
)
7356 self
.logger
.debug(logging_text
+ "Exit")
7357 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_scale")
7359 async def _scale_kdu(
7360 self
, logging_text
, nsr_id
, nsr_deployed
, db_vnfd
, vca_id
, scaling_info
7362 _scaling_info
= scaling_info
.get("kdu-create") or scaling_info
.get("kdu-delete")
7363 for kdu_name
in _scaling_info
:
7364 for kdu_scaling_info
in _scaling_info
[kdu_name
]:
7365 deployed_kdu
, index
= get_deployed_kdu(
7366 nsr_deployed
, kdu_name
, kdu_scaling_info
["member-vnf-index"]
7368 cluster_uuid
= deployed_kdu
["k8scluster-uuid"]
7369 kdu_instance
= deployed_kdu
["kdu-instance"]
7370 kdu_model
= deployed_kdu
.get("kdu-model")
7371 scale
= int(kdu_scaling_info
["scale"])
7372 k8s_cluster_type
= kdu_scaling_info
["k8s-cluster-type"]
7375 "collection": "nsrs",
7376 "filter": {"_id": nsr_id
},
7377 "path": "_admin.deployed.K8s.{}".format(index
),
7380 step
= "scaling application {}".format(
7381 kdu_scaling_info
["resource-name"]
7383 self
.logger
.debug(logging_text
+ step
)
7385 if kdu_scaling_info
["type"] == "delete":
7386 kdu_config
= get_configuration(db_vnfd
, kdu_name
)
7389 and kdu_config
.get("terminate-config-primitive")
7390 and get_juju_ee_ref(db_vnfd
, kdu_name
) is None
7392 terminate_config_primitive_list
= kdu_config
.get(
7393 "terminate-config-primitive"
7395 terminate_config_primitive_list
.sort(
7396 key
=lambda val
: int(val
["seq"])
7400 terminate_config_primitive
7401 ) in terminate_config_primitive_list
:
7402 primitive_params_
= self
._map
_primitive
_params
(
7403 terminate_config_primitive
, {}, {}
7405 step
= "execute terminate config primitive"
7406 self
.logger
.debug(logging_text
+ step
)
7407 await asyncio
.wait_for(
7408 self
.k8scluster_map
[k8s_cluster_type
].exec_primitive(
7409 cluster_uuid
=cluster_uuid
,
7410 kdu_instance
=kdu_instance
,
7411 primitive_name
=terminate_config_primitive
["name"],
7412 params
=primitive_params_
,
7414 total_timeout
=self
.timeout
.primitive
,
7417 timeout
=self
.timeout
.primitive
7418 * self
.timeout
.primitive_outer_factor
,
7421 await asyncio
.wait_for(
7422 self
.k8scluster_map
[k8s_cluster_type
].scale(
7423 kdu_instance
=kdu_instance
,
7425 resource_name
=kdu_scaling_info
["resource-name"],
7426 total_timeout
=self
.timeout
.scale_on_error
,
7428 cluster_uuid
=cluster_uuid
,
7429 kdu_model
=kdu_model
,
7433 timeout
=self
.timeout
.scale_on_error
7434 * self
.timeout
.scale_on_error_outer_factor
,
7437 if kdu_scaling_info
["type"] == "create":
7438 kdu_config
= get_configuration(db_vnfd
, kdu_name
)
7441 and kdu_config
.get("initial-config-primitive")
7442 and get_juju_ee_ref(db_vnfd
, kdu_name
) is None
7444 initial_config_primitive_list
= kdu_config
.get(
7445 "initial-config-primitive"
7447 initial_config_primitive_list
.sort(
7448 key
=lambda val
: int(val
["seq"])
7451 for initial_config_primitive
in initial_config_primitive_list
:
7452 primitive_params_
= self
._map
_primitive
_params
(
7453 initial_config_primitive
, {}, {}
7455 step
= "execute initial config primitive"
7456 self
.logger
.debug(logging_text
+ step
)
7457 await asyncio
.wait_for(
7458 self
.k8scluster_map
[k8s_cluster_type
].exec_primitive(
7459 cluster_uuid
=cluster_uuid
,
7460 kdu_instance
=kdu_instance
,
7461 primitive_name
=initial_config_primitive
["name"],
7462 params
=primitive_params_
,
7469 async def _scale_ng_ro(
7470 self
, logging_text
, db_nsr
, db_nslcmop
, db_vnfr
, vdu_scaling_info
, stage
7472 nsr_id
= db_nslcmop
["nsInstanceId"]
7473 db_nsd
= self
.db
.get_one("nsds", {"_id": db_nsr
["nsd-id"]})
7476 # read from db: vnfd's for every vnf
7479 # for each vnf in ns, read vnfd
7480 for vnfr
in self
.db
.get_list("vnfrs", {"nsr-id-ref": nsr_id
}):
7481 db_vnfrs
[vnfr
["member-vnf-index-ref"]] = vnfr
7482 vnfd_id
= vnfr
["vnfd-id"] # vnfd uuid for this vnf
7483 # if we haven't this vnfd, read it from db
7484 if not find_in_list(db_vnfds
, lambda a_vnfd
: a_vnfd
["id"] == vnfd_id
):
7486 vnfd
= self
.db
.get_one("vnfds", {"_id": vnfd_id
})
7487 db_vnfds
.append(vnfd
)
7488 n2vc_key
= self
.n2vc
.get_public_key()
7489 n2vc_key_list
= [n2vc_key
]
7492 vdu_scaling_info
.get("vdu-create"),
7493 vdu_scaling_info
.get("vdu-delete"),
7496 # db_vnfr has been updated, update db_vnfrs to use it
7497 db_vnfrs
[db_vnfr
["member-vnf-index-ref"]] = db_vnfr
7498 await self
._instantiate
_ng
_ro
(
7508 start_deploy
=time(),
7509 timeout_ns_deploy
=self
.timeout
.ns_deploy
,
7511 if vdu_scaling_info
.get("vdu-delete"):
7513 db_vnfr
, None, vdu_scaling_info
["vdu-delete"], mark_delete
=False
7516 async def extract_prometheus_scrape_jobs(
7520 ee_config_descriptor
: dict,
7525 vnf_member_index
: str = "",
7527 vdu_index
: int = None,
7529 kdu_index
: int = None,
7531 """Method to extract prometheus scrape jobs from EE's Prometheus template job file
7532 This method will wait until the corresponding VDU or KDU is fully instantiated
7535 ee_id (str): Execution Environment ID
7536 artifact_path (str): Path where the EE's content is (including the Prometheus template file)
7537 ee_config_descriptor (dict): Execution Environment's configuration descriptor
7538 vnfr_id (str): VNFR ID where this EE applies
7539 nsr_id (str): NSR ID where this EE applies
7540 target_ip (str): VDU/KDU instance IP address
7541 element_type (str): NS or VNF or VDU or KDU
7542 vnf_member_index (str, optional): VNF index where this EE applies. Defaults to "".
7543 vdu_id (str, optional): VDU ID where this EE applies. Defaults to "".
7544 vdu_index (int, optional): VDU index where this EE applies. Defaults to None.
7545 kdu_name (str, optional): KDU name where this EE applies. Defaults to "".
7546 kdu_index (int, optional): KDU index where this EE applies. Defaults to None.
7549 LcmException: When the VDU or KDU instance was not found in an hour
7552 _type_: Prometheus jobs
7554 # default the vdur and kdur names to an empty string, to avoid any later
7555 # problem with Prometheus when the element type is not VDU or KDU
7559 # look if exist a file called 'prometheus*.j2' and
7560 artifact_content
= self
.fs
.dir_ls(artifact_path
)
7564 for f
in artifact_content
7565 if f
.startswith("prometheus") and f
.endswith(".j2")
7571 self
.logger
.debug("Artifact path{}".format(artifact_path
))
7572 self
.logger
.debug("job file{}".format(job_file
))
7573 with self
.fs
.file_open((artifact_path
, job_file
), "r") as f
:
7576 # obtain the VDUR or KDUR, if the element type is VDU or KDU
7577 if element_type
in ("VDU", "KDU"):
7578 for _
in range(360):
7579 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnfr_id
})
7580 if vdu_id
and vdu_index
is not None:
7584 for x
in get_iterable(db_vnfr
, "vdur")
7586 x
.get("vdu-id-ref") == vdu_id
7587 and x
.get("count-index") == vdu_index
7592 if vdur
.get("name"):
7593 vdur_name
= vdur
.get("name")
7595 if kdu_name
and kdu_index
is not None:
7599 for x
in get_iterable(db_vnfr
, "kdur")
7601 x
.get("kdu-name") == kdu_name
7602 and x
.get("count-index") == kdu_index
7607 if kdur
.get("name"):
7608 kdur_name
= kdur
.get("name")
7611 await asyncio
.sleep(10)
7613 if vdu_id
and vdu_index
is not None:
7615 f
"Timeout waiting VDU with name={vdu_id} and index={vdu_index} to be intantiated"
7617 if kdu_name
and kdu_index
is not None:
7619 f
"Timeout waiting KDU with name={kdu_name} and index={kdu_index} to be intantiated"
7622 if ee_id
is not None:
7623 _
, namespace
, helm_id
= get_ee_id_parts(
7625 ) # get namespace and EE gRPC service name
7626 host_name
= f
'{helm_id}-{ee_config_descriptor["metric-service"]}.{namespace}.svc' # svc_name.namespace.svc
7628 vnfr_id
= vnfr_id
.replace("-", "")
7630 "JOB_NAME": vnfr_id
,
7631 "TARGET_IP": target_ip
,
7632 "EXPORTER_POD_IP": host_name
,
7633 "EXPORTER_POD_PORT": host_port
,
7635 "VNF_MEMBER_INDEX": vnf_member_index
,
7636 "VDUR_NAME": vdur_name
,
7637 "KDUR_NAME": kdur_name
,
7638 "ELEMENT_TYPE": element_type
,
7641 metric_path
= ee_config_descriptor
["metric-path"]
7642 target_port
= ee_config_descriptor
["metric-port"]
7643 vnfr_id
= vnfr_id
.replace("-", "")
7645 "JOB_NAME": vnfr_id
,
7646 "TARGET_IP": target_ip
,
7647 "TARGET_PORT": target_port
,
7648 "METRIC_PATH": metric_path
,
7651 job_list
= parse_job(job_data
, variables
)
7652 # ensure job_name is using the vnfr_id. Adding the metadata nsr_id
7653 for job
in job_list
:
7655 not isinstance(job
.get("job_name"), str)
7656 or vnfr_id
not in job
["job_name"]
7658 job
["job_name"] = vnfr_id
+ "_" + str(SystemRandom().randint(1, 10000))
7659 job
["nsr_id"] = nsr_id
7660 job
["vnfr_id"] = vnfr_id
7663 async def rebuild_start_stop(
7664 self
, nsr_id
, nslcmop_id
, vnf_id
, additional_param
, operation_type
7666 logging_text
= "Task ns={} {}={} ".format(nsr_id
, operation_type
, nslcmop_id
)
7667 self
.logger
.info(logging_text
+ "Enter")
7668 stage
= ["Preparing the environment", ""]
7669 # database nsrs record
7673 # in case of error, indicates what part of scale was failed to put nsr at error status
7674 start_deploy
= time()
7676 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnf_id
})
7677 vim_account_id
= db_vnfr
.get("vim-account-id")
7678 vim_info_key
= "vim:" + vim_account_id
7679 vdu_id
= additional_param
["vdu_id"]
7680 vdurs
= [item
for item
in db_vnfr
["vdur"] if item
["vdu-id-ref"] == vdu_id
]
7681 vdur
= find_in_list(
7682 vdurs
, lambda vdu
: vdu
["count-index"] == additional_param
["count-index"]
7685 vdu_vim_name
= vdur
["name"]
7686 vim_vm_id
= vdur
["vim_info"][vim_info_key
]["vim_id"]
7687 target_vim
, _
= next(k_v
for k_v
in vdur
["vim_info"].items())
7689 raise LcmException("Target vdu is not found")
7690 self
.logger
.info("vdu_vim_name >> {} ".format(vdu_vim_name
))
7691 # wait for any previous tasks in process
7692 stage
[1] = "Waiting for previous operations to terminate"
7693 self
.logger
.info(stage
[1])
7694 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
7696 stage
[1] = "Reading from database."
7697 self
.logger
.info(stage
[1])
7698 self
._write
_ns
_status
(
7701 current_operation
=operation_type
.upper(),
7702 current_operation_id
=nslcmop_id
,
7704 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
, queuePosition
=0)
7707 stage
[1] = "Getting nsr={} from db.".format(nsr_id
)
7708 db_nsr_update
["operational-status"] = operation_type
7709 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
7713 "vim_vm_id": vim_vm_id
,
7715 "vdu_index": additional_param
["count-index"],
7716 "vdu_id": vdur
["id"],
7717 "target_vim": target_vim
,
7718 "vim_account_id": vim_account_id
,
7721 stage
[1] = "Sending rebuild request to RO... {}".format(desc
)
7722 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
, queuePosition
=0)
7723 self
.logger
.info("ro nsr id: {}".format(nsr_id
))
7724 result_dict
= await self
.RO
.operate(nsr_id
, desc
, operation_type
)
7725 self
.logger
.info("response from RO: {}".format(result_dict
))
7726 action_id
= result_dict
["action_id"]
7727 await self
._wait
_ng
_ro
(
7732 self
.timeout
.operate
,
7734 "start_stop_rebuild",
7736 return "COMPLETED", "Done"
7737 except (ROclient
.ROClientException
, DbException
, LcmException
) as e
:
7738 self
.logger
.error("Exit Exception {}".format(e
))
7740 except asyncio
.CancelledError
:
7741 self
.logger
.error("Cancelled Exception while '{}'".format(stage
))
7742 exc
= "Operation was cancelled"
7743 except Exception as e
:
7744 exc
= traceback
.format_exc()
7745 self
.logger
.critical(
7746 "Exit Exception {} {}".format(type(e
).__name
__, e
), exc_info
=True
7748 return "FAILED", "Error in operate VNF {}".format(exc
)
7750 async def migrate(self
, nsr_id
, nslcmop_id
):
7752 Migrate VNFs and VDUs instances in a NS
7754 :param: nsr_id: NS Instance ID
7755 :param: nslcmop_id: nslcmop ID of migrate
7758 # Try to lock HA task here
7759 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
7760 if not task_is_locked_by_me
:
7762 logging_text
= "Task ns={} migrate ".format(nsr_id
)
7763 self
.logger
.debug(logging_text
+ "Enter")
7764 # get all needed from database
7766 db_nslcmop_update
= {}
7767 nslcmop_operation_state
= None
7771 # in case of error, indicates what part of scale was failed to put nsr at error status
7772 start_deploy
= time()
7775 # wait for any previous tasks in process
7776 step
= "Waiting for previous operations to terminate"
7777 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
7779 self
._write
_ns
_status
(
7782 current_operation
="MIGRATING",
7783 current_operation_id
=nslcmop_id
,
7785 step
= "Getting nslcmop from database"
7787 step
+ " after having waited for previous tasks to be completed"
7789 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
7790 migrate_params
= db_nslcmop
.get("operationParams")
7793 target
.update(migrate_params
)
7794 desc
= await self
.RO
.migrate(nsr_id
, target
)
7795 self
.logger
.debug("RO return > {}".format(desc
))
7796 action_id
= desc
["action_id"]
7797 await self
._wait
_ng
_ro
(
7802 self
.timeout
.migrate
,
7803 operation
="migrate",
7805 except (ROclient
.ROClientException
, DbException
, LcmException
) as e
:
7806 self
.logger
.error("Exit Exception {}".format(e
))
7808 except asyncio
.CancelledError
:
7809 self
.logger
.error("Cancelled Exception while '{}'".format(step
))
7810 exc
= "Operation was cancelled"
7811 except Exception as e
:
7812 exc
= traceback
.format_exc()
7813 self
.logger
.critical(
7814 "Exit Exception {} {}".format(type(e
).__name
__, e
), exc_info
=True
7817 self
._write
_ns
_status
(
7820 current_operation
="IDLE",
7821 current_operation_id
=None,
7824 db_nslcmop_update
["detailed-status"] = "FAILED {}: {}".format(step
, exc
)
7825 nslcmop_operation_state
= "FAILED"
7827 nslcmop_operation_state
= "COMPLETED"
7828 db_nslcmop_update
["detailed-status"] = "Done"
7829 db_nsr_update
["detailed-status"] = "Done"
7831 self
._write
_op
_status
(
7835 operation_state
=nslcmop_operation_state
,
7836 other_update
=db_nslcmop_update
,
7838 if nslcmop_operation_state
:
7842 "nslcmop_id": nslcmop_id
,
7843 "operationState": nslcmop_operation_state
,
7845 await self
.msg
.aiowrite("ns", "migrated", msg
)
7846 except Exception as e
:
7848 logging_text
+ "kafka_write notification Exception {}".format(e
)
7850 self
.logger
.debug(logging_text
+ "Exit")
7851 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_migrate")
7853 async def heal(self
, nsr_id
, nslcmop_id
):
7857 :param nsr_id: ns instance to heal
7858 :param nslcmop_id: operation to run
7862 # Try to lock HA task here
7863 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
7864 if not task_is_locked_by_me
:
7867 logging_text
= "Task ns={} heal={} ".format(nsr_id
, nslcmop_id
)
7868 stage
= ["", "", ""]
7869 tasks_dict_info
= {}
7870 # ^ stage, step, VIM progress
7871 self
.logger
.debug(logging_text
+ "Enter")
7872 # get all needed from database
7874 db_nslcmop_update
= {}
7876 db_vnfrs
= {} # vnf's info indexed by _id
7878 old_operational_status
= ""
7879 old_config_status
= ""
7882 # wait for any previous tasks in process
7883 step
= "Waiting for previous operations to terminate"
7884 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
7885 self
._write
_ns
_status
(
7888 current_operation
="HEALING",
7889 current_operation_id
=nslcmop_id
,
7892 step
= "Getting nslcmop from database"
7894 step
+ " after having waited for previous tasks to be completed"
7896 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
7898 step
= "Getting nsr from database"
7899 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
7900 old_operational_status
= db_nsr
["operational-status"]
7901 old_config_status
= db_nsr
["config-status"]
7904 "_admin.deployed.RO.operational-status": "healing",
7906 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
7908 step
= "Sending heal order to VIM"
7910 logging_text
=logging_text
,
7912 db_nslcmop
=db_nslcmop
,
7917 stage
[1] = "Getting nsd={} from db.".format(db_nsr
["nsd-id"])
7918 self
.logger
.debug(logging_text
+ stage
[1])
7919 nsd
= self
.db
.get_one("nsds", {"_id": db_nsr
["nsd-id"]})
7920 self
.fs
.sync(db_nsr
["nsd-id"])
7922 # read from db: vnfr's of this ns
7923 step
= "Getting vnfrs from db"
7924 db_vnfrs_list
= self
.db
.get_list("vnfrs", {"nsr-id-ref": nsr_id
})
7925 for vnfr
in db_vnfrs_list
:
7926 db_vnfrs
[vnfr
["_id"]] = vnfr
7927 self
.logger
.debug("ns.heal db_vnfrs={}".format(db_vnfrs
))
7929 # Check for each target VNF
7930 target_list
= db_nslcmop
.get("operationParams", {}).get("healVnfData", {})
7931 for target_vnf
in target_list
:
7932 # Find this VNF in the list from DB
7933 vnfr_id
= target_vnf
.get("vnfInstanceId", None)
7935 db_vnfr
= db_vnfrs
[vnfr_id
]
7936 vnfd_id
= db_vnfr
.get("vnfd-id")
7937 vnfd_ref
= db_vnfr
.get("vnfd-ref")
7938 vnfd
= self
.db
.get_one("vnfds", {"_id": vnfd_id
})
7939 base_folder
= vnfd
["_admin"]["storage"]
7944 nsi_id
= None # TODO put nsi_id when this nsr belongs to a NSI
7945 member_vnf_index
= db_vnfr
.get("member-vnf-index-ref")
7947 # Check each target VDU and deploy N2VC
7948 target_vdu_list
= target_vnf
.get("additionalParams", {}).get(
7951 if not target_vdu_list
:
7952 # Codigo nuevo para crear diccionario
7953 target_vdu_list
= []
7954 for existing_vdu
in db_vnfr
.get("vdur"):
7955 vdu_name
= existing_vdu
.get("vdu-name", None)
7956 vdu_index
= existing_vdu
.get("count-index", 0)
7957 vdu_run_day1
= target_vnf
.get("additionalParams", {}).get(
7960 vdu_to_be_healed
= {
7962 "count-index": vdu_index
,
7963 "run-day1": vdu_run_day1
,
7965 target_vdu_list
.append(vdu_to_be_healed
)
7966 for target_vdu
in target_vdu_list
:
7967 deploy_params_vdu
= target_vdu
7968 # Set run-day1 vnf level value if not vdu level value exists
7969 if not deploy_params_vdu
.get("run-day1") and target_vnf
.get(
7970 "additionalParams", {}
7972 deploy_params_vdu
["run-day1"] = target_vnf
[
7975 vdu_name
= target_vdu
.get("vdu-id", None)
7976 # TODO: Get vdu_id from vdud.
7978 # For multi instance VDU count-index is mandatory
7979 # For single session VDU count-indes is 0
7980 vdu_index
= target_vdu
.get("count-index", 0)
7982 # n2vc_redesign STEP 3 to 6 Deploy N2VC
7983 stage
[1] = "Deploying Execution Environments."
7984 self
.logger
.debug(logging_text
+ stage
[1])
7986 # VNF Level charm. Normal case when proxy charms.
7987 # If target instance is management machine continue with actions: recreate EE for native charms or reinject juju key for proxy charms.
7988 descriptor_config
= get_configuration(vnfd
, vnfd_ref
)
7989 if descriptor_config
:
7990 # Continue if healed machine is management machine
7991 vnf_ip_address
= db_vnfr
.get("ip-address")
7992 target_instance
= None
7993 for instance
in db_vnfr
.get("vdur", None):
7995 instance
["vdu-name"] == vdu_name
7996 and instance
["count-index"] == vdu_index
7998 target_instance
= instance
8000 if vnf_ip_address
== target_instance
.get("ip-address"):
8002 logging_text
=logging_text
8003 + "member_vnf_index={}, vdu_name={}, vdu_index={} ".format(
8004 member_vnf_index
, vdu_name
, vdu_index
8008 nslcmop_id
=nslcmop_id
,
8014 member_vnf_index
=member_vnf_index
,
8017 deploy_params
=deploy_params_vdu
,
8018 descriptor_config
=descriptor_config
,
8019 base_folder
=base_folder
,
8020 task_instantiation_info
=tasks_dict_info
,
8024 # VDU Level charm. Normal case with native charms.
8025 descriptor_config
= get_configuration(vnfd
, vdu_name
)
8026 if descriptor_config
:
8028 logging_text
=logging_text
8029 + "member_vnf_index={}, vdu_name={}, vdu_index={} ".format(
8030 member_vnf_index
, vdu_name
, vdu_index
8034 nslcmop_id
=nslcmop_id
,
8040 member_vnf_index
=member_vnf_index
,
8041 vdu_index
=vdu_index
,
8043 deploy_params
=deploy_params_vdu
,
8044 descriptor_config
=descriptor_config
,
8045 base_folder
=base_folder
,
8046 task_instantiation_info
=tasks_dict_info
,
8051 ROclient
.ROClientException
,
8056 self
.logger
.error(logging_text
+ "Exit Exception {}".format(e
))
8058 except asyncio
.CancelledError
:
8060 logging_text
+ "Cancelled Exception while '{}'".format(step
)
8062 exc
= "Operation was cancelled"
8063 except Exception as e
:
8064 exc
= traceback
.format_exc()
8065 self
.logger
.critical(
8066 logging_text
+ "Exit Exception {} {}".format(type(e
).__name
__, e
),
8072 error_list
.append(str(exc
))
8075 stage
[1] = "Waiting for healing pending tasks."
8076 self
.logger
.debug(logging_text
+ stage
[1])
8077 exc
= await self
._wait
_for
_tasks
(
8080 self
.timeout
.ns_deploy
,
8085 except asyncio
.CancelledError
:
8086 error_list
.append("Cancelled")
8087 await self
._cancel
_pending
_tasks
(logging_text
, tasks_dict_info
)
8088 await self
._wait
_for
_tasks
(
8091 self
.timeout
.ns_deploy
,
8097 error_detail
= "; ".join(error_list
)
8100 ] = error_description_nslcmop
= "FAILED {}: {}".format(
8103 nslcmop_operation_state
= "FAILED"
8105 db_nsr_update
["operational-status"] = old_operational_status
8106 db_nsr_update
["config-status"] = old_config_status
8109 ] = "FAILED healing nslcmop={} {}: {}".format(
8110 nslcmop_id
, step
, error_detail
8112 for task
, task_name
in tasks_dict_info
.items():
8113 if not task
.done() or task
.cancelled() or task
.exception():
8114 if task_name
.startswith(self
.task_name_deploy_vca
):
8115 # A N2VC task is pending
8116 db_nsr_update
["config-status"] = "failed"
8118 # RO task is pending
8119 db_nsr_update
["operational-status"] = "failed"
8121 error_description_nslcmop
= None
8122 nslcmop_operation_state
= "COMPLETED"
8123 db_nslcmop_update
["detailed-status"] = "Done"
8124 db_nsr_update
["detailed-status"] = "Done"
8125 db_nsr_update
["operational-status"] = "running"
8126 db_nsr_update
["config-status"] = "configured"
8128 self
._write
_op
_status
(
8131 error_message
=error_description_nslcmop
,
8132 operation_state
=nslcmop_operation_state
,
8133 other_update
=db_nslcmop_update
,
8136 self
._write
_ns
_status
(
8139 current_operation
="IDLE",
8140 current_operation_id
=None,
8141 other_update
=db_nsr_update
,
8144 if nslcmop_operation_state
:
8148 "nslcmop_id": nslcmop_id
,
8149 "operationState": nslcmop_operation_state
,
8151 await self
.msg
.aiowrite("ns", "healed", msg
)
8152 except Exception as e
:
8154 logging_text
+ "kafka_write notification Exception {}".format(e
)
8156 self
.logger
.debug(logging_text
+ "Exit")
8157 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_heal")
8168 :param logging_text: preffix text to use at logging
8169 :param nsr_id: nsr identity
8170 :param db_nslcmop: database content of ns operation, in this case, 'instantiate'
8171 :param stage: list with 3 items: [general stage, tasks, vim_specific]. This task will write over vim_specific
8172 :return: None or exception
8175 def get_vim_account(vim_account_id
):
8177 if vim_account_id
in db_vims
:
8178 return db_vims
[vim_account_id
]
8179 db_vim
= self
.db
.get_one("vim_accounts", {"_id": vim_account_id
})
8180 db_vims
[vim_account_id
] = db_vim
8185 ns_params
= db_nslcmop
.get("operationParams")
8186 if ns_params
and ns_params
.get("timeout_ns_heal"):
8187 timeout_ns_heal
= ns_params
["timeout_ns_heal"]
8189 timeout_ns_heal
= self
.timeout
.ns_heal
8193 nslcmop_id
= db_nslcmop
["_id"]
8195 "action_id": nslcmop_id
,
8197 self
.logger
.warning(
8198 "db_nslcmop={} and timeout_ns_heal={}".format(
8199 db_nslcmop
, timeout_ns_heal
8202 target
.update(db_nslcmop
.get("operationParams", {}))
8204 self
.logger
.debug("Send to RO > nsr_id={} target={}".format(nsr_id
, target
))
8205 desc
= await self
.RO
.recreate(nsr_id
, target
)
8206 self
.logger
.debug("RO return > {}".format(desc
))
8207 action_id
= desc
["action_id"]
8208 # waits for RO to complete because Reinjecting juju key at ro can find VM in state Deleted
8209 await self
._wait
_ng
_ro
(
8216 operation
="healing",
8221 "_admin.deployed.RO.operational-status": "running",
8222 "detailed-status": " ".join(stage
),
8224 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
8225 self
._write
_op
_status
(nslcmop_id
, stage
)
8227 logging_text
+ "ns healed at RO. RO_id={}".format(action_id
)
8230 except Exception as e
:
8231 stage
[2] = "ERROR healing at VIM"
8232 # self.set_vnfr_at_error(db_vnfrs, str(e))
8234 "Error healing at VIM {}".format(e
),
8235 exc_info
=not isinstance(
8238 ROclient
.ROClientException
,
8264 task_instantiation_info
,
8267 # launch instantiate_N2VC in a asyncio task and register task object
8268 # Look where information of this charm is at database <nsrs>._admin.deployed.VCA
8269 # if not found, create one entry and update database
8270 # fill db_nsr._admin.deployed.VCA.<index>
8273 logging_text
+ "_deploy_n2vc vnfd_id={}, vdu_id={}".format(vnfd_id
, vdu_id
)
8277 get_charm_name
= False
8278 if "execution-environment-list" in descriptor_config
:
8279 ee_list
= descriptor_config
.get("execution-environment-list", [])
8280 elif "juju" in descriptor_config
:
8281 ee_list
= [descriptor_config
] # ns charms
8282 if "execution-environment-list" not in descriptor_config
:
8283 # charm name is only required for ns charms
8284 get_charm_name
= True
8285 else: # other types as script are not supported
8288 for ee_item
in ee_list
:
8291 + "_deploy_n2vc ee_item juju={}, helm={}".format(
8292 ee_item
.get("juju"), ee_item
.get("helm-chart")
8295 ee_descriptor_id
= ee_item
.get("id")
8296 vca_name
, charm_name
, vca_type
= self
.get_vca_info(
8297 ee_item
, db_nsr
, get_charm_name
8301 logging_text
+ "skipping, non juju/charm/helm configuration"
8306 for vca_index
, vca_deployed
in enumerate(
8307 db_nsr
["_admin"]["deployed"]["VCA"]
8309 if not vca_deployed
:
8312 vca_deployed
.get("member-vnf-index") == member_vnf_index
8313 and vca_deployed
.get("vdu_id") == vdu_id
8314 and vca_deployed
.get("kdu_name") == kdu_name
8315 and vca_deployed
.get("vdu_count_index", 0) == vdu_index
8316 and vca_deployed
.get("ee_descriptor_id") == ee_descriptor_id
8320 # not found, create one.
8322 "ns" if not member_vnf_index
else "vnf/{}".format(member_vnf_index
)
8325 target
+= "/vdu/{}/{}".format(vdu_id
, vdu_index
or 0)
8327 target
+= "/kdu/{}".format(kdu_name
)
8329 "target_element": target
,
8330 # ^ target_element will replace member-vnf-index, kdu_name, vdu_id ... in a single string
8331 "member-vnf-index": member_vnf_index
,
8333 "kdu_name": kdu_name
,
8334 "vdu_count_index": vdu_index
,
8335 "operational-status": "init", # TODO revise
8336 "detailed-status": "", # TODO revise
8337 "step": "initial-deploy", # TODO revise
8339 "vdu_name": vdu_name
,
8341 "ee_descriptor_id": ee_descriptor_id
,
8342 "charm_name": charm_name
,
8346 # create VCA and configurationStatus in db
8348 "_admin.deployed.VCA.{}".format(vca_index
): vca_deployed
,
8349 "configurationStatus.{}".format(vca_index
): dict(),
8351 self
.update_db_2("nsrs", nsr_id
, db_dict
)
8353 db_nsr
["_admin"]["deployed"]["VCA"].append(vca_deployed
)
8355 self
.logger
.debug("N2VC > NSR_ID > {}".format(nsr_id
))
8356 self
.logger
.debug("N2VC > DB_NSR > {}".format(db_nsr
))
8357 self
.logger
.debug("N2VC > VCA_DEPLOYED > {}".format(vca_deployed
))
8360 task_n2vc
= asyncio
.ensure_future(
8362 logging_text
=logging_text
,
8363 vca_index
=vca_index
,
8369 vdu_index
=vdu_index
,
8370 deploy_params
=deploy_params
,
8371 config_descriptor
=descriptor_config
,
8372 base_folder
=base_folder
,
8373 nslcmop_id
=nslcmop_id
,
8377 ee_config_descriptor
=ee_item
,
8380 self
.lcm_tasks
.register(
8384 "instantiate_N2VC-{}".format(vca_index
),
8387 task_instantiation_info
[
8389 ] = self
.task_name_deploy_vca
+ " {}.{}".format(
8390 member_vnf_index
or "", vdu_id
or ""
8393 async def heal_N2VC(
8410 ee_config_descriptor
,
8412 nsr_id
= db_nsr
["_id"]
8413 db_update_entry
= "_admin.deployed.VCA.{}.".format(vca_index
)
8414 vca_deployed_list
= db_nsr
["_admin"]["deployed"]["VCA"]
8415 vca_deployed
= db_nsr
["_admin"]["deployed"]["VCA"][vca_index
]
8416 osm_config
= {"osm": {"ns_id": db_nsr
["_id"]}}
8418 "collection": "nsrs",
8419 "filter": {"_id": nsr_id
},
8420 "path": db_update_entry
,
8425 element_under_configuration
= nsr_id
8429 vnfr_id
= db_vnfr
["_id"]
8430 osm_config
["osm"]["vnf_id"] = vnfr_id
8432 namespace
= "{nsi}.{ns}".format(nsi
=nsi_id
if nsi_id
else "", ns
=nsr_id
)
8434 if vca_type
== "native_charm":
8437 index_number
= vdu_index
or 0
8440 element_type
= "VNF"
8441 element_under_configuration
= vnfr_id
8442 namespace
+= ".{}-{}".format(vnfr_id
, index_number
)
8444 namespace
+= ".{}-{}".format(vdu_id
, index_number
)
8445 element_type
= "VDU"
8446 element_under_configuration
= "{}-{}".format(vdu_id
, index_number
)
8447 osm_config
["osm"]["vdu_id"] = vdu_id
8449 namespace
+= ".{}".format(kdu_name
)
8450 element_type
= "KDU"
8451 element_under_configuration
= kdu_name
8452 osm_config
["osm"]["kdu_name"] = kdu_name
8455 if base_folder
["pkg-dir"]:
8456 artifact_path
= "{}/{}/{}/{}".format(
8457 base_folder
["folder"],
8458 base_folder
["pkg-dir"],
8461 in ("native_charm", "lxc_proxy_charm", "k8s_proxy_charm")
8466 artifact_path
= "{}/Scripts/{}/{}/".format(
8467 base_folder
["folder"],
8470 in ("native_charm", "lxc_proxy_charm", "k8s_proxy_charm")
8475 self
.logger
.debug("Artifact path > {}".format(artifact_path
))
8477 # get initial_config_primitive_list that applies to this element
8478 initial_config_primitive_list
= config_descriptor
.get(
8479 "initial-config-primitive"
8483 "Initial config primitive list > {}".format(
8484 initial_config_primitive_list
8488 # add config if not present for NS charm
8489 ee_descriptor_id
= ee_config_descriptor
.get("id")
8490 self
.logger
.debug("EE Descriptor > {}".format(ee_descriptor_id
))
8491 initial_config_primitive_list
= get_ee_sorted_initial_config_primitive_list(
8492 initial_config_primitive_list
, vca_deployed
, ee_descriptor_id
8496 "Initial config primitive list #2 > {}".format(
8497 initial_config_primitive_list
8500 # n2vc_redesign STEP 3.1
8501 # find old ee_id if exists
8502 ee_id
= vca_deployed
.get("ee_id")
8504 vca_id
= self
.get_vca_id(db_vnfr
, db_nsr
)
8505 # create or register execution environment in VCA. Only for native charms when healing
8506 if vca_type
== "native_charm":
8507 step
= "Waiting to VM being up and getting IP address"
8508 self
.logger
.debug(logging_text
+ step
)
8509 rw_mgmt_ip
= await self
.wait_vm_up_insert_key_ro(
8518 credentials
= {"hostname": rw_mgmt_ip
}
8520 username
= deep_get(
8521 config_descriptor
, ("config-access", "ssh-access", "default-user")
8523 # TODO remove this when changes on IM regarding config-access:ssh-access:default-user were
8524 # merged. Meanwhile let's get username from initial-config-primitive
8525 if not username
and initial_config_primitive_list
:
8526 for config_primitive
in initial_config_primitive_list
:
8527 for param
in config_primitive
.get("parameter", ()):
8528 if param
["name"] == "ssh-username":
8529 username
= param
["value"]
8533 "Cannot determine the username neither with 'initial-config-primitive' nor with "
8534 "'config-access.ssh-access.default-user'"
8536 credentials
["username"] = username
8538 # n2vc_redesign STEP 3.2
8539 # TODO: Before healing at RO it is needed to destroy native charm units to be deleted.
8540 self
._write
_configuration
_status
(
8542 vca_index
=vca_index
,
8543 status
="REGISTERING",
8544 element_under_configuration
=element_under_configuration
,
8545 element_type
=element_type
,
8548 step
= "register execution environment {}".format(credentials
)
8549 self
.logger
.debug(logging_text
+ step
)
8550 ee_id
= await self
.vca_map
[vca_type
].register_execution_environment(
8551 credentials
=credentials
,
8552 namespace
=namespace
,
8557 # update ee_id en db
8559 "_admin.deployed.VCA.{}.ee_id".format(vca_index
): ee_id
,
8561 self
.update_db_2("nsrs", nsr_id
, db_dict_ee_id
)
8563 # for compatibility with MON/POL modules, the need model and application name at database
8564 # TODO ask MON/POL if needed to not assuming anymore the format "model_name.application_name"
8565 # Not sure if this need to be done when healing
8567 ee_id_parts = ee_id.split(".")
8568 db_nsr_update = {db_update_entry + "ee_id": ee_id}
8569 if len(ee_id_parts) >= 2:
8570 model_name = ee_id_parts[0]
8571 application_name = ee_id_parts[1]
8572 db_nsr_update[db_update_entry + "model"] = model_name
8573 db_nsr_update[db_update_entry + "application"] = application_name
8576 # n2vc_redesign STEP 3.3
8577 # Install configuration software. Only for native charms.
8578 step
= "Install configuration Software"
8580 self
._write
_configuration
_status
(
8582 vca_index
=vca_index
,
8583 status
="INSTALLING SW",
8584 element_under_configuration
=element_under_configuration
,
8585 element_type
=element_type
,
8586 # other_update=db_nsr_update,
8590 # TODO check if already done
8591 self
.logger
.debug(logging_text
+ step
)
8593 if vca_type
== "native_charm":
8594 config_primitive
= next(
8595 (p
for p
in initial_config_primitive_list
if p
["name"] == "config"),
8598 if config_primitive
:
8599 config
= self
._map
_primitive
_params
(
8600 config_primitive
, {}, deploy_params
8602 await self
.vca_map
[vca_type
].install_configuration_sw(
8604 artifact_path
=artifact_path
,
8612 # write in db flag of configuration_sw already installed
8614 "nsrs", nsr_id
, {db_update_entry
+ "config_sw_installed": True}
8617 # Not sure if this need to be done when healing
8619 # add relations for this VCA (wait for other peers related with this VCA)
8620 await self._add_vca_relations(
8621 logging_text=logging_text,
8624 vca_index=vca_index,
8628 # if SSH access is required, then get execution environment SSH public
8629 # if native charm we have waited already to VM be UP
8630 if vca_type
in ("k8s_proxy_charm", "lxc_proxy_charm", "helm-v3"):
8633 # self.logger.debug("get ssh key block")
8635 config_descriptor
, ("config-access", "ssh-access", "required")
8637 # self.logger.debug("ssh key needed")
8638 # Needed to inject a ssh key
8641 ("config-access", "ssh-access", "default-user"),
8643 step
= "Install configuration Software, getting public ssh key"
8644 pub_key
= await self
.vca_map
[vca_type
].get_ee_ssh_public__key(
8645 ee_id
=ee_id
, db_dict
=db_dict
, vca_id
=vca_id
8648 step
= "Insert public key into VM user={} ssh_key={}".format(
8652 # self.logger.debug("no need to get ssh key")
8653 step
= "Waiting to VM being up and getting IP address"
8654 self
.logger
.debug(logging_text
+ step
)
8656 # n2vc_redesign STEP 5.1
8657 # wait for RO (ip-address) Insert pub_key into VM
8658 # IMPORTANT: We need do wait for RO to complete healing operation.
8659 await self
._wait
_heal
_ro
(nsr_id
, self
.timeout
.ns_heal
)
8662 rw_mgmt_ip
= await self
.wait_kdu_up(
8663 logging_text
, nsr_id
, vnfr_id
, kdu_name
8666 rw_mgmt_ip
= await self
.wait_vm_up_insert_key_ro(
8676 rw_mgmt_ip
= None # This is for a NS configuration
8678 self
.logger
.debug(logging_text
+ " VM_ip_address={}".format(rw_mgmt_ip
))
8680 # store rw_mgmt_ip in deploy params for later replacement
8681 deploy_params
["rw_mgmt_ip"] = rw_mgmt_ip
8684 # get run-day1 operation parameter
8685 runDay1
= deploy_params
.get("run-day1", False)
8687 "Healing vnf={}, vdu={}, runDay1 ={}".format(vnfr_id
, vdu_id
, runDay1
)
8690 # n2vc_redesign STEP 6 Execute initial config primitive
8691 step
= "execute initial config primitive"
8693 # wait for dependent primitives execution (NS -> VNF -> VDU)
8694 if initial_config_primitive_list
:
8695 await self
._wait
_dependent
_n
2vc
(
8696 nsr_id
, vca_deployed_list
, vca_index
8699 # stage, in function of element type: vdu, kdu, vnf or ns
8700 my_vca
= vca_deployed_list
[vca_index
]
8701 if my_vca
.get("vdu_id") or my_vca
.get("kdu_name"):
8703 stage
[0] = "Stage 3/5: running Day-1 primitives for VDU."
8704 elif my_vca
.get("member-vnf-index"):
8706 stage
[0] = "Stage 4/5: running Day-1 primitives for VNF."
8709 stage
[0] = "Stage 5/5: running Day-1 primitives for NS."
8711 self
._write
_configuration
_status
(
8712 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="EXECUTING PRIMITIVE"
8715 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
)
8717 check_if_terminated_needed
= True
8718 for initial_config_primitive
in initial_config_primitive_list
:
8719 # adding information on the vca_deployed if it is a NS execution environment
8720 if not vca_deployed
["member-vnf-index"]:
8721 deploy_params
["ns_config_info"] = json
.dumps(
8722 self
._get
_ns
_config
_info
(nsr_id
)
8724 # TODO check if already done
8725 primitive_params_
= self
._map
_primitive
_params
(
8726 initial_config_primitive
, {}, deploy_params
8729 step
= "execute primitive '{}' params '{}'".format(
8730 initial_config_primitive
["name"], primitive_params_
8732 self
.logger
.debug(logging_text
+ step
)
8733 await self
.vca_map
[vca_type
].exec_primitive(
8735 primitive_name
=initial_config_primitive
["name"],
8736 params_dict
=primitive_params_
,
8741 # Once some primitive has been exec, check and write at db if it needs to exec terminated primitives
8742 if check_if_terminated_needed
:
8743 if config_descriptor
.get("terminate-config-primitive"):
8747 {db_update_entry
+ "needed_terminate": True},
8749 check_if_terminated_needed
= False
8751 # TODO register in database that primitive is done
8753 # STEP 7 Configure metrics
8754 # Not sure if this need to be done when healing
8756 if vca_type == "helm" or vca_type == "helm-v3":
8757 prometheus_jobs = await self.extract_prometheus_scrape_jobs(
8759 artifact_path=artifact_path,
8760 ee_config_descriptor=ee_config_descriptor,
8763 target_ip=rw_mgmt_ip,
8769 {db_update_entry + "prometheus_jobs": prometheus_jobs},
8772 for job in prometheus_jobs:
8775 {"job_name": job["job_name"]},
8778 fail_on_empty=False,
8782 step
= "instantiated at VCA"
8783 self
.logger
.debug(logging_text
+ step
)
8785 self
._write
_configuration
_status
(
8786 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="READY"
8789 except Exception as e
: # TODO not use Exception but N2VC exception
8790 # self.update_db_2("nsrs", nsr_id, {db_update_entry + "instantiation": "FAILED"})
8792 e
, (DbException
, N2VCException
, LcmException
, asyncio
.CancelledError
)
8795 "Exception while {} : {}".format(step
, e
), exc_info
=True
8797 self
._write
_configuration
_status
(
8798 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="BROKEN"
8800 raise LcmException("{} {}".format(step
, e
)) from e
8802 async def _wait_heal_ro(
8808 while time() <= start_time
+ timeout
:
8809 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
8810 operational_status_ro
= db_nsr
["_admin"]["deployed"]["RO"][
8811 "operational-status"
8813 self
.logger
.debug("Wait Heal RO > {}".format(operational_status_ro
))
8814 if operational_status_ro
!= "healing":
8816 await asyncio
.sleep(15)
8817 else: # timeout_ns_deploy
8818 raise NgRoException("Timeout waiting ns to deploy")
8820 async def vertical_scale(self
, nsr_id
, nslcmop_id
):
8822 Vertical Scale the VDUs in a NS
8824 :param: nsr_id: NS Instance ID
8825 :param: nslcmop_id: nslcmop ID of migrate
8828 # Try to lock HA task here
8829 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
8830 if not task_is_locked_by_me
:
8832 logging_text
= "Task ns={} vertical scale ".format(nsr_id
)
8833 self
.logger
.debug(logging_text
+ "Enter")
8834 # get all needed from database
8836 db_nslcmop_update
= {}
8837 nslcmop_operation_state
= None
8840 old_vdu_index
= None
8841 old_flavor_id
= None
8845 # in case of error, indicates what part of scale was failed to put nsr at error status
8846 start_deploy
= time()
8849 # wait for any previous tasks in process
8850 step
= "Waiting for previous operations to terminate"
8851 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
8853 self
._write
_ns
_status
(
8856 current_operation
="VerticalScale",
8857 current_operation_id
=nslcmop_id
,
8859 step
= "Getting nslcmop from database"
8861 step
+ " after having waited for previous tasks to be completed"
8863 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
8864 operationParams
= db_nslcmop
.get("operationParams")
8865 # Update the VNFRS and NSRS with the requested flavour detail, So that ro tasks can function properly
8866 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
8867 db_flavor
= db_nsr
.get("flavor")
8868 db_flavor_index
= str(len(db_flavor
))
8869 change_vnf_flavor_data
= operationParams
["changeVnfFlavorData"]
8870 flavor_dict
= change_vnf_flavor_data
["additionalParams"]
8871 count_index
= flavor_dict
["vduCountIndex"]
8872 vdu_id_ref
= flavor_dict
["vduid"]
8873 flavor_dict_update
= {
8874 "id": db_flavor_index
,
8875 "memory-mb": flavor_dict
["virtualMemory"],
8876 "name": f
"{vdu_id_ref}-{count_index}-flv",
8877 "storage-gb": flavor_dict
["sizeOfStorage"],
8878 "vcpu-count": flavor_dict
["numVirtualCpu"],
8880 db_flavor
.append(flavor_dict_update
)
8882 db_update
["flavor"] = db_flavor
8888 q_filter
=ns_q_filter
,
8889 update_dict
=db_update
,
8892 db_vnfr
= self
.db
.get_one(
8893 "vnfrs", {"_id": change_vnf_flavor_data
["vnfInstanceId"]}
8895 for vdu_index
, vdur
in enumerate(db_vnfr
.get("vdur", ())):
8897 vdur
.get("count-index") == count_index
8898 and vdur
.get("vdu-id-ref") == vdu_id_ref
8900 old_flavor_id
= vdur
.get("ns-flavor-id", 0)
8901 old_vdu_index
= vdu_index
8903 "_id": change_vnf_flavor_data
["vnfInstanceId"],
8904 "vdur.count-index": count_index
,
8905 "vdur.vdu-id-ref": vdu_id_ref
,
8907 q_filter
.update(filter_text
)
8910 "vdur.{}.ns-flavor-id".format(vdu_index
)
8915 update_dict
=db_update
,
8919 target
.update(operationParams
)
8920 desc
= await self
.RO
.vertical_scale(nsr_id
, target
)
8921 self
.logger
.debug("RO return > {}".format(desc
))
8922 action_id
= desc
["action_id"]
8923 await self
._wait
_ng
_ro
(
8928 self
.timeout
.verticalscale
,
8929 operation
="verticalscale",
8933 ROclient
.ROClientException
,
8937 self
.logger
.error("Exit Exception {}".format(e
))
8939 except asyncio
.CancelledError
:
8940 self
.logger
.error("Cancelled Exception while '{}'".format(step
))
8941 exc
= "Operation was cancelled"
8942 except Exception as e
:
8943 exc
= traceback
.format_exc()
8944 self
.logger
.critical(
8945 "Exit Exception {} {}".format(type(e
).__name
__, e
), exc_info
=True
8948 self
._write
_ns
_status
(
8951 current_operation
="IDLE",
8952 current_operation_id
=None,
8955 db_nslcmop_update
["detailed-status"] = "FAILED {}: {}".format(step
, exc
)
8956 nslcmop_operation_state
= "FAILED"
8958 "vdur.{}.ns-flavor-id".format(old_vdu_index
)
8961 nslcmop_operation_state
= "COMPLETED"
8962 db_nslcmop_update
["detailed-status"] = "Done"
8963 db_nsr_update
["detailed-status"] = "Done"
8965 self
._write
_op
_status
(
8969 operation_state
=nslcmop_operation_state
,
8970 other_update
=db_nslcmop_update
,
8972 if old_vdu_index
and old_db_update
!= {}:
8973 self
.logger
.critical(
8974 "Reverting Old Flavor -- : {}".format(old_db_update
)
8979 update_dict
=old_db_update
,
8982 if nslcmop_operation_state
:
8986 "nslcmop_id": nslcmop_id
,
8987 "operationState": nslcmop_operation_state
,
8989 await self
.msg
.aiowrite("ns", "verticalscaled", msg
)
8990 except Exception as e
:
8992 logging_text
+ "kafka_write notification Exception {}".format(e
)
8994 self
.logger
.debug(logging_text
+ "Exit")
8995 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_verticalscale")