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
35 from osm_lcm
import ROclient
36 from osm_lcm
.data_utils
.nsr
import (
39 get_deployed_vca_list
,
42 from osm_lcm
.data_utils
.vca
import (
51 from osm_lcm
.ng_ro
import NgRoClient
, NgRoException
52 from osm_lcm
.lcm_utils
import (
59 check_juju_bundle_existence
,
60 get_charm_artifact_path
,
62 from osm_lcm
.data_utils
.nsd
import (
63 get_ns_configuration_relation_list
,
67 from osm_lcm
.data_utils
.vnfd
import (
73 get_ee_sorted_initial_config_primitive_list
,
74 get_ee_sorted_terminate_config_primitive_list
,
76 get_virtual_link_profiles
,
81 get_number_of_instances
,
83 get_kdu_resource_profile
,
84 find_software_version
,
86 from osm_lcm
.data_utils
.list_utils
import find_in_list
87 from osm_lcm
.data_utils
.vnfr
import (
91 get_volumes_from_instantiation_params
,
93 from osm_lcm
.data_utils
.dict_utils
import parse_yaml_strings
94 from osm_lcm
.data_utils
.database
.vim_account
import VimAccountDB
95 from n2vc
.definitions
import RelationEndpoint
96 from n2vc
.k8s_helm_conn
import K8sHelmConnector
97 from n2vc
.k8s_helm3_conn
import K8sHelm3Connector
98 from n2vc
.k8s_juju_conn
import K8sJujuConnector
100 from osm_common
.dbbase
import DbException
101 from osm_common
.fsbase
import FsException
103 from osm_lcm
.data_utils
.database
.database
import Database
104 from osm_lcm
.data_utils
.filesystem
.filesystem
import Filesystem
106 from n2vc
.n2vc_juju_conn
import N2VCJujuConnector
107 from n2vc
.exceptions
import N2VCException
, N2VCNotFound
, K8sException
109 from osm_lcm
.lcm_helm_conn
import LCMHelmConn
110 from osm_lcm
.osm_config
import OsmConfigBuilder
111 from osm_lcm
.prometheus
import parse_job
113 from copy
import copy
, deepcopy
114 from time
import time
115 from uuid
import uuid4
117 from random
import randint
119 __author__
= "Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>"
122 class NsLcm(LcmBase
):
123 timeout_vca_on_error
= (
125 ) # Time for charm from first time at blocked,error status to mark as failed
126 timeout_ns_deploy
= 2 * 3600 # default global timeout for deployment a ns
127 timeout_ns_terminate
= 1800 # default global timeout for un deployment a ns
128 timeout_ns_heal
= 1800 # default global timeout for un deployment a ns
129 timeout_charm_delete
= 10 * 60
130 timeout_primitive
= 30 * 60 # timeout for primitive execution
131 timeout_ns_update
= 30 * 60 # timeout for ns update
132 timeout_progress_primitive
= (
134 ) # timeout for some progress in a primitive execution
135 timeout_migrate
= 1800 # default global timeout for migrating vnfs
136 timeout_operate
= 1800 # default global timeout for migrating vnfs
137 timeout_verticalscale
= 1800 # default global timeout for Vertical Sclaing
138 SUBOPERATION_STATUS_NOT_FOUND
= -1
139 SUBOPERATION_STATUS_NEW
= -2
140 SUBOPERATION_STATUS_SKIP
= -3
141 task_name_deploy_vca
= "Deploying VCA"
143 def __init__(self
, msg
, lcm_tasks
, config
, loop
):
145 Init, Connect to database, filesystem storage, and messaging
146 :param config: two level dictionary with configuration. Top level should contain 'database', 'storage',
149 super().__init
__(msg
=msg
, logger
=logging
.getLogger("lcm.ns"))
151 self
.db
= Database().instance
.db
152 self
.fs
= Filesystem().instance
.fs
154 self
.lcm_tasks
= lcm_tasks
155 self
.timeout
= config
["timeout"]
156 self
.ro_config
= config
["ro_config"]
157 self
.ng_ro
= config
["ro_config"].get("ng")
158 self
.vca_config
= config
["VCA"].copy()
160 # create N2VC connector
161 self
.n2vc
= N2VCJujuConnector(
164 on_update_db
=self
._on
_update
_n
2vc
_db
,
169 self
.conn_helm_ee
= LCMHelmConn(
172 vca_config
=self
.vca_config
,
173 on_update_db
=self
._on
_update
_n
2vc
_db
,
176 self
.k8sclusterhelm2
= K8sHelmConnector(
177 kubectl_command
=self
.vca_config
.get("kubectlpath"),
178 helm_command
=self
.vca_config
.get("helmpath"),
185 self
.k8sclusterhelm3
= K8sHelm3Connector(
186 kubectl_command
=self
.vca_config
.get("kubectlpath"),
187 helm_command
=self
.vca_config
.get("helm3path"),
194 self
.k8sclusterjuju
= K8sJujuConnector(
195 kubectl_command
=self
.vca_config
.get("kubectlpath"),
196 juju_command
=self
.vca_config
.get("jujupath"),
199 on_update_db
=self
._on
_update
_k
8s
_db
,
204 self
.k8scluster_map
= {
205 "helm-chart": self
.k8sclusterhelm2
,
206 "helm-chart-v3": self
.k8sclusterhelm3
,
207 "chart": self
.k8sclusterhelm3
,
208 "juju-bundle": self
.k8sclusterjuju
,
209 "juju": self
.k8sclusterjuju
,
213 "lxc_proxy_charm": self
.n2vc
,
214 "native_charm": self
.n2vc
,
215 "k8s_proxy_charm": self
.n2vc
,
216 "helm": self
.conn_helm_ee
,
217 "helm-v3": self
.conn_helm_ee
,
221 self
.RO
= NgRoClient(self
.loop
, **self
.ro_config
)
223 self
.op_status_map
= {
224 "instantiation": self
.RO
.status
,
225 "termination": self
.RO
.status
,
226 "migrate": self
.RO
.status
,
227 "healing": self
.RO
.recreate_status
,
228 "verticalscale": self
.RO
.status
,
229 "start_stop_rebuild": self
.RO
.status
,
233 def increment_ip_mac(ip_mac
, vm_index
=1):
234 if not isinstance(ip_mac
, str):
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 def _on_update_ro_db(self
, nsrs_id
, ro_descriptor
):
256 # self.logger.debug('_on_update_ro_db(nsrs_id={}'.format(nsrs_id))
259 # TODO filter RO descriptor fields...
263 # db_dict['deploymentStatus'] = yaml.dump(ro_descriptor, default_flow_style=False, indent=2)
264 db_dict
["deploymentStatus"] = ro_descriptor
265 self
.update_db_2("nsrs", nsrs_id
, db_dict
)
267 except Exception as e
:
269 "Cannot write database RO deployment for ns={} -> {}".format(nsrs_id
, e
)
272 async def _on_update_n2vc_db(self
, table
, filter, path
, updated_data
, vca_id
=None):
274 # remove last dot from path (if exists)
275 if path
.endswith("."):
278 # self.logger.debug('_on_update_n2vc_db(table={}, filter={}, path={}, updated_data={}'
279 # .format(table, filter, path, updated_data))
282 nsr_id
= filter.get("_id")
284 # read ns record from database
285 nsr
= self
.db
.get_one(table
="nsrs", q_filter
=filter)
286 current_ns_status
= nsr
.get("nsState")
288 # get vca status for NS
289 status_dict
= await self
.n2vc
.get_status(
290 namespace
="." + nsr_id
, yaml_format
=False, vca_id
=vca_id
295 db_dict
["vcaStatus"] = status_dict
296 await self
.n2vc
.update_vca_status(db_dict
["vcaStatus"], vca_id
=vca_id
)
298 # update configurationStatus for this VCA
300 vca_index
= int(path
[path
.rfind(".") + 1 :])
303 target_dict
=nsr
, key_list
=("_admin", "deployed", "VCA")
305 vca_status
= vca_list
[vca_index
].get("status")
307 configuration_status_list
= nsr
.get("configurationStatus")
308 config_status
= configuration_status_list
[vca_index
].get("status")
310 if config_status
== "BROKEN" and vca_status
!= "failed":
311 db_dict
["configurationStatus"][vca_index
] = "READY"
312 elif config_status
!= "BROKEN" and vca_status
== "failed":
313 db_dict
["configurationStatus"][vca_index
] = "BROKEN"
314 except Exception as e
:
315 # not update configurationStatus
316 self
.logger
.debug("Error updating vca_index (ignore): {}".format(e
))
318 # if nsState = 'READY' check if juju is reporting some error => nsState = 'DEGRADED'
319 # if nsState = 'DEGRADED' check if all is OK
321 if current_ns_status
in ("READY", "DEGRADED"):
322 error_description
= ""
324 if status_dict
.get("machines"):
325 for machine_id
in status_dict
.get("machines"):
326 machine
= status_dict
.get("machines").get(machine_id
)
327 # check machine agent-status
328 if machine
.get("agent-status"):
329 s
= machine
.get("agent-status").get("status")
332 error_description
+= (
333 "machine {} agent-status={} ; ".format(
337 # check machine instance status
338 if machine
.get("instance-status"):
339 s
= machine
.get("instance-status").get("status")
342 error_description
+= (
343 "machine {} instance-status={} ; ".format(
348 if status_dict
.get("applications"):
349 for app_id
in status_dict
.get("applications"):
350 app
= status_dict
.get("applications").get(app_id
)
351 # check application status
352 if app
.get("status"):
353 s
= app
.get("status").get("status")
356 error_description
+= (
357 "application {} status={} ; ".format(app_id
, s
)
360 if error_description
:
361 db_dict
["errorDescription"] = error_description
362 if current_ns_status
== "READY" and is_degraded
:
363 db_dict
["nsState"] = "DEGRADED"
364 if current_ns_status
== "DEGRADED" and not is_degraded
:
365 db_dict
["nsState"] = "READY"
368 self
.update_db_2("nsrs", nsr_id
, db_dict
)
370 except (asyncio
.CancelledError
, asyncio
.TimeoutError
):
372 except Exception as e
:
373 self
.logger
.warn("Error updating NS state for ns={}: {}".format(nsr_id
, e
))
375 async def _on_update_k8s_db(
376 self
, cluster_uuid
, kdu_instance
, filter=None, vca_id
=None, cluster_type
="juju"
379 Updating vca status in NSR record
380 :param cluster_uuid: UUID of a k8s cluster
381 :param kdu_instance: The unique name of the KDU instance
382 :param filter: To get nsr_id
383 :cluster_type: The cluster type (juju, k8s)
387 # self.logger.debug("_on_update_k8s_db(cluster_uuid={}, kdu_instance={}, filter={}"
388 # .format(cluster_uuid, kdu_instance, filter))
390 nsr_id
= filter.get("_id")
392 vca_status
= await self
.k8scluster_map
[cluster_type
].status_kdu(
393 cluster_uuid
=cluster_uuid
,
394 kdu_instance
=kdu_instance
,
396 complete_status
=True,
402 db_dict
["vcaStatus"] = {nsr_id
: vca_status
}
404 if cluster_type
in ("juju-bundle", "juju"):
405 # TODO -> this should be done in a more uniform way, I think in N2VC, in order to update the K8s VCA
406 # status in a similar way between Juju Bundles and Helm Charts on this side
407 await self
.k8sclusterjuju
.update_vca_status(
408 db_dict
["vcaStatus"],
414 f
"Obtained VCA status for cluster type '{cluster_type}': {vca_status}"
418 self
.update_db_2("nsrs", nsr_id
, db_dict
)
419 except (asyncio
.CancelledError
, asyncio
.TimeoutError
):
421 except Exception as e
:
422 self
.logger
.warn("Error updating NS state for ns={}: {}".format(nsr_id
, e
))
425 def _parse_cloud_init(cloud_init_text
, additional_params
, vnfd_id
, vdu_id
):
427 env
= Environment(undefined
=StrictUndefined
, autoescape
=True)
428 template
= env
.from_string(cloud_init_text
)
429 return template
.render(additional_params
or {})
430 except UndefinedError
as e
:
432 "Variable {} at vnfd[id={}]:vdu[id={}]:cloud-init/cloud-init-"
433 "file, must be provided in the instantiation parameters inside the "
434 "'additionalParamsForVnf/Vdu' block".format(e
, vnfd_id
, vdu_id
)
436 except (TemplateError
, TemplateNotFound
) as e
:
438 "Error parsing Jinja2 to cloud-init content at vnfd[id={}]:vdu[id={}]: {}".format(
443 def _get_vdu_cloud_init_content(self
, vdu
, vnfd
):
444 cloud_init_content
= cloud_init_file
= None
446 if vdu
.get("cloud-init-file"):
447 base_folder
= vnfd
["_admin"]["storage"]
448 if base_folder
["pkg-dir"]:
449 cloud_init_file
= "{}/{}/cloud_init/{}".format(
450 base_folder
["folder"],
451 base_folder
["pkg-dir"],
452 vdu
["cloud-init-file"],
455 cloud_init_file
= "{}/Scripts/cloud_init/{}".format(
456 base_folder
["folder"],
457 vdu
["cloud-init-file"],
459 with self
.fs
.file_open(cloud_init_file
, "r") as ci_file
:
460 cloud_init_content
= ci_file
.read()
461 elif vdu
.get("cloud-init"):
462 cloud_init_content
= vdu
["cloud-init"]
464 return cloud_init_content
465 except FsException
as e
:
467 "Error reading vnfd[id={}]:vdu[id={}]:cloud-init-file={}: {}".format(
468 vnfd
["id"], vdu
["id"], cloud_init_file
, e
472 def _get_vdu_additional_params(self
, db_vnfr
, vdu_id
):
474 (vdur
for vdur
in db_vnfr
.get("vdur") if vdu_id
== vdur
["vdu-id-ref"]), {}
476 additional_params
= vdur
.get("additionalParams")
477 return parse_yaml_strings(additional_params
)
479 def vnfd2RO(self
, vnfd
, new_id
=None, additionalParams
=None, nsrId
=None):
481 Converts creates a new vnfd descriptor for RO base on input OSM IM vnfd
482 :param vnfd: input vnfd
483 :param new_id: overrides vnf id if provided
484 :param additionalParams: Instantiation params for VNFs provided
485 :param nsrId: Id of the NSR
486 :return: copy of vnfd
488 vnfd_RO
= deepcopy(vnfd
)
489 # remove unused by RO configuration, monitoring, scaling and internal keys
490 vnfd_RO
.pop("_id", None)
491 vnfd_RO
.pop("_admin", None)
492 vnfd_RO
.pop("monitoring-param", None)
493 vnfd_RO
.pop("scaling-group-descriptor", None)
494 vnfd_RO
.pop("kdu", None)
495 vnfd_RO
.pop("k8s-cluster", None)
497 vnfd_RO
["id"] = new_id
499 # parse cloud-init or cloud-init-file with the provided variables using Jinja2
500 for vdu
in get_iterable(vnfd_RO
, "vdu"):
501 vdu
.pop("cloud-init-file", None)
502 vdu
.pop("cloud-init", None)
506 def ip_profile_2_RO(ip_profile
):
507 RO_ip_profile
= deepcopy(ip_profile
)
508 if "dns-server" in RO_ip_profile
:
509 if isinstance(RO_ip_profile
["dns-server"], list):
510 RO_ip_profile
["dns-address"] = []
511 for ds
in RO_ip_profile
.pop("dns-server"):
512 RO_ip_profile
["dns-address"].append(ds
["address"])
514 RO_ip_profile
["dns-address"] = RO_ip_profile
.pop("dns-server")
515 if RO_ip_profile
.get("ip-version") == "ipv4":
516 RO_ip_profile
["ip-version"] = "IPv4"
517 if RO_ip_profile
.get("ip-version") == "ipv6":
518 RO_ip_profile
["ip-version"] = "IPv6"
519 if "dhcp-params" in RO_ip_profile
:
520 RO_ip_profile
["dhcp"] = RO_ip_profile
.pop("dhcp-params")
523 def _get_ro_vim_id_for_vim_account(self
, vim_account
):
524 db_vim
= self
.db
.get_one("vim_accounts", {"_id": vim_account
})
525 if db_vim
["_admin"]["operationalState"] != "ENABLED":
527 "VIM={} is not available. operationalState={}".format(
528 vim_account
, db_vim
["_admin"]["operationalState"]
531 RO_vim_id
= db_vim
["_admin"]["deployed"]["RO"]
534 def get_ro_wim_id_for_wim_account(self
, wim_account
):
535 if isinstance(wim_account
, str):
536 db_wim
= self
.db
.get_one("wim_accounts", {"_id": wim_account
})
537 if db_wim
["_admin"]["operationalState"] != "ENABLED":
539 "WIM={} is not available. operationalState={}".format(
540 wim_account
, db_wim
["_admin"]["operationalState"]
543 RO_wim_id
= db_wim
["_admin"]["deployed"]["RO-account"]
548 def scale_vnfr(self
, db_vnfr
, vdu_create
=None, vdu_delete
=None, mark_delete
=False):
550 db_vdu_push_list
= []
552 db_update
= {"_admin.modified": time()}
554 for vdu_id
, vdu_count
in vdu_create
.items():
558 for vdur
in reversed(db_vnfr
["vdur"])
559 if vdur
["vdu-id-ref"] == vdu_id
564 # Read the template saved in the db:
566 "No vdur in the database. Using the vdur-template to scale"
568 vdur_template
= db_vnfr
.get("vdur-template")
569 if not vdur_template
:
571 "Error scaling OUT VNFR for {}. No vnfr or template exists".format(
575 vdur
= vdur_template
[0]
576 # Delete a template from the database after using it
579 {"_id": db_vnfr
["_id"]},
581 pull
={"vdur-template": {"_id": vdur
["_id"]}},
583 for count
in range(vdu_count
):
584 vdur_copy
= deepcopy(vdur
)
585 vdur_copy
["status"] = "BUILD"
586 vdur_copy
["status-detailed"] = None
587 vdur_copy
["ip-address"] = None
588 vdur_copy
["_id"] = str(uuid4())
589 vdur_copy
["count-index"] += count
+ 1
590 vdur_copy
["id"] = "{}-{}".format(
591 vdur_copy
["vdu-id-ref"], vdur_copy
["count-index"]
593 vdur_copy
.pop("vim_info", None)
594 for iface
in vdur_copy
["interfaces"]:
595 if iface
.get("fixed-ip"):
596 iface
["ip-address"] = self
.increment_ip_mac(
597 iface
["ip-address"], count
+ 1
600 iface
.pop("ip-address", None)
601 if iface
.get("fixed-mac"):
602 iface
["mac-address"] = self
.increment_ip_mac(
603 iface
["mac-address"], count
+ 1
606 iface
.pop("mac-address", None)
610 ) # only first vdu can be managment of vnf
611 db_vdu_push_list
.append(vdur_copy
)
612 # self.logger.debug("scale out, adding vdu={}".format(vdur_copy))
614 if len(db_vnfr
["vdur"]) == 1:
615 # The scale will move to 0 instances
617 "Scaling to 0 !, creating the template with the last vdur"
619 template_vdur
= [db_vnfr
["vdur"][0]]
620 for vdu_id
, vdu_count
in vdu_delete
.items():
622 indexes_to_delete
= [
624 for iv
in enumerate(db_vnfr
["vdur"])
625 if iv
[1]["vdu-id-ref"] == vdu_id
629 "vdur.{}.status".format(i
): "DELETING"
630 for i
in indexes_to_delete
[-vdu_count
:]
634 # it must be deleted one by one because common.db does not allow otherwise
637 for v
in reversed(db_vnfr
["vdur"])
638 if v
["vdu-id-ref"] == vdu_id
640 for vdu
in vdus_to_delete
[:vdu_count
]:
643 {"_id": db_vnfr
["_id"]},
645 pull
={"vdur": {"_id": vdu
["_id"]}},
649 db_push
["vdur"] = db_vdu_push_list
651 db_push
["vdur-template"] = template_vdur
654 db_vnfr
["vdur-template"] = template_vdur
655 self
.db
.set_one("vnfrs", {"_id": db_vnfr
["_id"]}, db_update
, push_list
=db_push
)
656 # modify passed dictionary db_vnfr
657 db_vnfr_
= self
.db
.get_one("vnfrs", {"_id": db_vnfr
["_id"]})
658 db_vnfr
["vdur"] = db_vnfr_
["vdur"]
660 def ns_update_nsr(self
, ns_update_nsr
, db_nsr
, nsr_desc_RO
):
662 Updates database nsr with the RO info for the created vld
663 :param ns_update_nsr: dictionary to be filled with the updated info
664 :param db_nsr: content of db_nsr. This is also modified
665 :param nsr_desc_RO: nsr descriptor from RO
666 :return: Nothing, LcmException is raised on errors
669 for vld_index
, vld
in enumerate(get_iterable(db_nsr
, "vld")):
670 for net_RO
in get_iterable(nsr_desc_RO
, "nets"):
671 if vld
["id"] != net_RO
.get("ns_net_osm_id"):
673 vld
["vim-id"] = net_RO
.get("vim_net_id")
674 vld
["name"] = net_RO
.get("vim_name")
675 vld
["status"] = net_RO
.get("status")
676 vld
["status-detailed"] = net_RO
.get("error_msg")
677 ns_update_nsr
["vld.{}".format(vld_index
)] = vld
681 "ns_update_nsr: Not found vld={} at RO info".format(vld
["id"])
684 def set_vnfr_at_error(self
, db_vnfrs
, error_text
):
686 for db_vnfr
in db_vnfrs
.values():
687 vnfr_update
= {"status": "ERROR"}
688 for vdu_index
, vdur
in enumerate(get_iterable(db_vnfr
, "vdur")):
689 if "status" not in vdur
:
690 vdur
["status"] = "ERROR"
691 vnfr_update
["vdur.{}.status".format(vdu_index
)] = "ERROR"
693 vdur
["status-detailed"] = str(error_text
)
695 "vdur.{}.status-detailed".format(vdu_index
)
697 self
.update_db_2("vnfrs", db_vnfr
["_id"], vnfr_update
)
698 except DbException
as e
:
699 self
.logger
.error("Cannot update vnf. {}".format(e
))
701 def ns_update_vnfr(self
, db_vnfrs
, nsr_desc_RO
):
703 Updates database vnfr with the RO info, e.g. ip_address, vim_id... Descriptor db_vnfrs is also updated
704 :param db_vnfrs: dictionary with member-vnf-index: vnfr-content
705 :param nsr_desc_RO: nsr descriptor from RO
706 :return: Nothing, LcmException is raised on errors
708 for vnf_index
, db_vnfr
in db_vnfrs
.items():
709 for vnf_RO
in nsr_desc_RO
["vnfs"]:
710 if vnf_RO
["member_vnf_index"] != vnf_index
:
713 if vnf_RO
.get("ip_address"):
714 db_vnfr
["ip-address"] = vnfr_update
["ip-address"] = vnf_RO
[
717 elif not db_vnfr
.get("ip-address"):
718 if db_vnfr
.get("vdur"): # if not VDUs, there is not ip_address
719 raise LcmExceptionNoMgmtIP(
720 "ns member_vnf_index '{}' has no IP address".format(
725 for vdu_index
, vdur
in enumerate(get_iterable(db_vnfr
, "vdur")):
726 vdur_RO_count_index
= 0
727 if vdur
.get("pdu-type"):
729 for vdur_RO
in get_iterable(vnf_RO
, "vms"):
730 if vdur
["vdu-id-ref"] != vdur_RO
["vdu_osm_id"]:
732 if vdur
["count-index"] != vdur_RO_count_index
:
733 vdur_RO_count_index
+= 1
735 vdur
["vim-id"] = vdur_RO
.get("vim_vm_id")
736 if vdur_RO
.get("ip_address"):
737 vdur
["ip-address"] = vdur_RO
["ip_address"].split(";")[0]
739 vdur
["ip-address"] = None
740 vdur
["vdu-id-ref"] = vdur_RO
.get("vdu_osm_id")
741 vdur
["name"] = vdur_RO
.get("vim_name")
742 vdur
["status"] = vdur_RO
.get("status")
743 vdur
["status-detailed"] = vdur_RO
.get("error_msg")
744 for ifacer
in get_iterable(vdur
, "interfaces"):
745 for interface_RO
in get_iterable(vdur_RO
, "interfaces"):
746 if ifacer
["name"] == interface_RO
.get("internal_name"):
747 ifacer
["ip-address"] = interface_RO
.get(
750 ifacer
["mac-address"] = interface_RO
.get(
756 "ns_update_vnfr: Not found member_vnf_index={} vdur={} interface={} "
757 "from VIM info".format(
758 vnf_index
, vdur
["vdu-id-ref"], ifacer
["name"]
761 vnfr_update
["vdur.{}".format(vdu_index
)] = vdur
765 "ns_update_vnfr: Not found member_vnf_index={} vdur={} count_index={} from "
767 vnf_index
, vdur
["vdu-id-ref"], vdur
["count-index"]
771 for vld_index
, vld
in enumerate(get_iterable(db_vnfr
, "vld")):
772 for net_RO
in get_iterable(nsr_desc_RO
, "nets"):
773 if vld
["id"] != net_RO
.get("vnf_net_osm_id"):
775 vld
["vim-id"] = net_RO
.get("vim_net_id")
776 vld
["name"] = net_RO
.get("vim_name")
777 vld
["status"] = net_RO
.get("status")
778 vld
["status-detailed"] = net_RO
.get("error_msg")
779 vnfr_update
["vld.{}".format(vld_index
)] = vld
783 "ns_update_vnfr: Not found member_vnf_index={} vld={} from VIM info".format(
788 self
.update_db_2("vnfrs", db_vnfr
["_id"], vnfr_update
)
793 "ns_update_vnfr: Not found member_vnf_index={} from VIM info".format(
798 def _get_ns_config_info(self
, nsr_id
):
800 Generates a mapping between vnf,vdu elements and the N2VC id
801 :param nsr_id: id of nsr to get last database _admin.deployed.VCA that contains this list
802 :return: a dictionary with {osm-config-mapping: {}} where its element contains:
803 "<member-vnf-index>": <N2VC-id> for a vnf configuration, or
804 "<member-vnf-index>.<vdu.id>.<vdu replica(0, 1,..)>": <N2VC-id> for a vdu configuration
806 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
807 vca_deployed_list
= db_nsr
["_admin"]["deployed"]["VCA"]
809 ns_config_info
= {"osm-config-mapping": mapping
}
810 for vca
in vca_deployed_list
:
811 if not vca
["member-vnf-index"]:
813 if not vca
["vdu_id"]:
814 mapping
[vca
["member-vnf-index"]] = vca
["application"]
818 vca
["member-vnf-index"], vca
["vdu_id"], vca
["vdu_count_index"]
820 ] = vca
["application"]
821 return ns_config_info
823 async def _instantiate_ng_ro(
840 def get_vim_account(vim_account_id
):
842 if vim_account_id
in db_vims
:
843 return db_vims
[vim_account_id
]
844 db_vim
= self
.db
.get_one("vim_accounts", {"_id": vim_account_id
})
845 db_vims
[vim_account_id
] = db_vim
848 # modify target_vld info with instantiation parameters
849 def parse_vld_instantiation_params(
850 target_vim
, target_vld
, vld_params
, target_sdn
852 if vld_params
.get("ip-profile"):
853 target_vld
["vim_info"][target_vim
]["ip_profile"] = vld_params
[
856 if vld_params
.get("provider-network"):
857 target_vld
["vim_info"][target_vim
]["provider_network"] = vld_params
[
860 if "sdn-ports" in vld_params
["provider-network"] and target_sdn
:
861 target_vld
["vim_info"][target_sdn
]["sdn-ports"] = vld_params
[
864 if vld_params
.get("wimAccountId"):
865 target_wim
= "wim:{}".format(vld_params
["wimAccountId"])
866 target_vld
["vim_info"][target_wim
] = {}
867 for param
in ("vim-network-name", "vim-network-id"):
868 if vld_params
.get(param
):
869 if isinstance(vld_params
[param
], dict):
870 for vim
, vim_net
in vld_params
[param
].items():
871 other_target_vim
= "vim:" + vim
873 target_vld
["vim_info"],
874 (other_target_vim
, param
.replace("-", "_")),
877 else: # isinstance str
878 target_vld
["vim_info"][target_vim
][
879 param
.replace("-", "_")
880 ] = vld_params
[param
]
881 if vld_params
.get("common_id"):
882 target_vld
["common_id"] = vld_params
.get("common_id")
884 # modify target["ns"]["vld"] with instantiation parameters to override vnf vim-account
885 def update_ns_vld_target(target
, ns_params
):
886 for vnf_params
in ns_params
.get("vnf", ()):
887 if vnf_params
.get("vimAccountId"):
891 for vnfr
in db_vnfrs
.values()
892 if vnf_params
["member-vnf-index"]
893 == vnfr
["member-vnf-index-ref"]
897 vdur
= next((vdur
for vdur
in target_vnf
.get("vdur", ())), None)
898 for a_index
, a_vld
in enumerate(target
["ns"]["vld"]):
899 target_vld
= find_in_list(
900 get_iterable(vdur
, "interfaces"),
901 lambda iface
: iface
.get("ns-vld-id") == a_vld
["name"],
904 vld_params
= find_in_list(
905 get_iterable(ns_params
, "vld"),
906 lambda v_vld
: v_vld
["name"] in (a_vld
["name"], a_vld
["id"]),
910 if vnf_params
.get("vimAccountId") not in a_vld
.get(
913 target_vim_network_list
= [
914 v
for _
, v
in a_vld
.get("vim_info").items()
916 target_vim_network_name
= next(
918 item
.get("vim_network_name", "")
919 for item
in target_vim_network_list
924 target
["ns"]["vld"][a_index
].get("vim_info").update(
926 "vim:{}".format(vnf_params
["vimAccountId"]): {
927 "vim_network_name": target_vim_network_name
,
933 for param
in ("vim-network-name", "vim-network-id"):
934 if vld_params
.get(param
) and isinstance(
935 vld_params
[param
], dict
937 for vim
, vim_net
in vld_params
[
940 other_target_vim
= "vim:" + vim
942 target
["ns"]["vld"][a_index
].get(
947 param
.replace("-", "_"),
952 nslcmop_id
= db_nslcmop
["_id"]
954 "name": db_nsr
["name"],
957 "image": deepcopy(db_nsr
["image"]),
958 "flavor": deepcopy(db_nsr
["flavor"]),
959 "action_id": nslcmop_id
,
960 "cloud_init_content": {},
962 for image
in target
["image"]:
963 image
["vim_info"] = {}
964 for flavor
in target
["flavor"]:
965 flavor
["vim_info"] = {}
966 if db_nsr
.get("affinity-or-anti-affinity-group"):
967 target
["affinity-or-anti-affinity-group"] = deepcopy(
968 db_nsr
["affinity-or-anti-affinity-group"]
970 for affinity_or_anti_affinity_group
in target
[
971 "affinity-or-anti-affinity-group"
973 affinity_or_anti_affinity_group
["vim_info"] = {}
975 if db_nslcmop
.get("lcmOperationType") != "instantiate":
976 # get parameters of instantiation:
977 db_nslcmop_instantiate
= self
.db
.get_list(
980 "nsInstanceId": db_nslcmop
["nsInstanceId"],
981 "lcmOperationType": "instantiate",
984 ns_params
= db_nslcmop_instantiate
.get("operationParams")
986 ns_params
= db_nslcmop
.get("operationParams")
987 ssh_keys_instantiation
= ns_params
.get("ssh_keys") or []
988 ssh_keys_all
= ssh_keys_instantiation
+ (n2vc_key_list
or [])
991 for vld_index
, vld
in enumerate(db_nsr
.get("vld")):
992 target_vim
= "vim:{}".format(ns_params
["vimAccountId"])
996 "mgmt-network": vld
.get("mgmt-network", False),
997 "type": vld
.get("type"),
1000 "vim_network_name": vld
.get("vim-network-name"),
1001 "vim_account_id": ns_params
["vimAccountId"],
1005 # check if this network needs SDN assist
1006 if vld
.get("pci-interfaces"):
1007 db_vim
= get_vim_account(ns_params
["vimAccountId"])
1008 sdnc_id
= db_vim
["config"].get("sdn-controller")
1010 sdn_vld
= "nsrs:{}:vld.{}".format(nsr_id
, vld
["id"])
1011 target_sdn
= "sdn:{}".format(sdnc_id
)
1012 target_vld
["vim_info"][target_sdn
] = {
1014 "target_vim": target_vim
,
1016 "type": vld
.get("type"),
1019 nsd_vnf_profiles
= get_vnf_profiles(nsd
)
1020 for nsd_vnf_profile
in nsd_vnf_profiles
:
1021 for cp
in nsd_vnf_profile
["virtual-link-connectivity"]:
1022 if cp
["virtual-link-profile-id"] == vld
["id"]:
1024 "member_vnf:{}.{}".format(
1025 cp
["constituent-cpd-id"][0][
1026 "constituent-base-element-id"
1028 cp
["constituent-cpd-id"][0]["constituent-cpd-id"],
1030 ] = "nsrs:{}:vld.{}".format(nsr_id
, vld_index
)
1032 # check at nsd descriptor, if there is an ip-profile
1034 nsd_vlp
= find_in_list(
1035 get_virtual_link_profiles(nsd
),
1036 lambda a_link_profile
: a_link_profile
["virtual-link-desc-id"]
1041 and nsd_vlp
.get("virtual-link-protocol-data")
1042 and nsd_vlp
["virtual-link-protocol-data"].get("l3-protocol-data")
1044 ip_profile_source_data
= nsd_vlp
["virtual-link-protocol-data"][
1047 ip_profile_dest_data
= {}
1048 if "ip-version" in ip_profile_source_data
:
1049 ip_profile_dest_data
["ip-version"] = ip_profile_source_data
[
1052 if "cidr" in ip_profile_source_data
:
1053 ip_profile_dest_data
["subnet-address"] = ip_profile_source_data
[
1056 if "gateway-ip" in ip_profile_source_data
:
1057 ip_profile_dest_data
["gateway-address"] = ip_profile_source_data
[
1060 if "dhcp-enabled" in ip_profile_source_data
:
1061 ip_profile_dest_data
["dhcp-params"] = {
1062 "enabled": ip_profile_source_data
["dhcp-enabled"]
1064 vld_params
["ip-profile"] = ip_profile_dest_data
1066 # update vld_params with instantiation params
1067 vld_instantiation_params
= find_in_list(
1068 get_iterable(ns_params
, "vld"),
1069 lambda a_vld
: a_vld
["name"] in (vld
["name"], vld
["id"]),
1071 if vld_instantiation_params
:
1072 vld_params
.update(vld_instantiation_params
)
1073 parse_vld_instantiation_params(target_vim
, target_vld
, vld_params
, None)
1074 target
["ns"]["vld"].append(target_vld
)
1075 # Update the target ns_vld if vnf vim_account is overriden by instantiation params
1076 update_ns_vld_target(target
, ns_params
)
1078 for vnfr
in db_vnfrs
.values():
1079 vnfd
= find_in_list(
1080 db_vnfds
, lambda db_vnf
: db_vnf
["id"] == vnfr
["vnfd-ref"]
1082 vnf_params
= find_in_list(
1083 get_iterable(ns_params
, "vnf"),
1084 lambda a_vnf
: a_vnf
["member-vnf-index"] == vnfr
["member-vnf-index-ref"],
1086 target_vnf
= deepcopy(vnfr
)
1087 target_vim
= "vim:{}".format(vnfr
["vim-account-id"])
1088 for vld
in target_vnf
.get("vld", ()):
1089 # check if connected to a ns.vld, to fill target'
1090 vnf_cp
= find_in_list(
1091 vnfd
.get("int-virtual-link-desc", ()),
1092 lambda cpd
: cpd
.get("id") == vld
["id"],
1095 ns_cp
= "member_vnf:{}.{}".format(
1096 vnfr
["member-vnf-index-ref"], vnf_cp
["id"]
1098 if cp2target
.get(ns_cp
):
1099 vld
["target"] = cp2target
[ns_cp
]
1102 target_vim
: {"vim_network_name": vld
.get("vim-network-name")}
1104 # check if this network needs SDN assist
1106 if vld
.get("pci-interfaces"):
1107 db_vim
= get_vim_account(vnfr
["vim-account-id"])
1108 sdnc_id
= db_vim
["config"].get("sdn-controller")
1110 sdn_vld
= "vnfrs:{}:vld.{}".format(target_vnf
["_id"], vld
["id"])
1111 target_sdn
= "sdn:{}".format(sdnc_id
)
1112 vld
["vim_info"][target_sdn
] = {
1114 "target_vim": target_vim
,
1116 "type": vld
.get("type"),
1119 # check at vnfd descriptor, if there is an ip-profile
1121 vnfd_vlp
= find_in_list(
1122 get_virtual_link_profiles(vnfd
),
1123 lambda a_link_profile
: a_link_profile
["id"] == vld
["id"],
1127 and vnfd_vlp
.get("virtual-link-protocol-data")
1128 and vnfd_vlp
["virtual-link-protocol-data"].get("l3-protocol-data")
1130 ip_profile_source_data
= vnfd_vlp
["virtual-link-protocol-data"][
1133 ip_profile_dest_data
= {}
1134 if "ip-version" in ip_profile_source_data
:
1135 ip_profile_dest_data
["ip-version"] = ip_profile_source_data
[
1138 if "cidr" in ip_profile_source_data
:
1139 ip_profile_dest_data
["subnet-address"] = ip_profile_source_data
[
1142 if "gateway-ip" in ip_profile_source_data
:
1143 ip_profile_dest_data
[
1145 ] = ip_profile_source_data
["gateway-ip"]
1146 if "dhcp-enabled" in ip_profile_source_data
:
1147 ip_profile_dest_data
["dhcp-params"] = {
1148 "enabled": ip_profile_source_data
["dhcp-enabled"]
1151 vld_params
["ip-profile"] = ip_profile_dest_data
1152 # update vld_params with instantiation params
1154 vld_instantiation_params
= find_in_list(
1155 get_iterable(vnf_params
, "internal-vld"),
1156 lambda i_vld
: i_vld
["name"] == vld
["id"],
1158 if vld_instantiation_params
:
1159 vld_params
.update(vld_instantiation_params
)
1160 parse_vld_instantiation_params(target_vim
, vld
, vld_params
, target_sdn
)
1163 for vdur
in target_vnf
.get("vdur", ()):
1164 if vdur
.get("status") == "DELETING" or vdur
.get("pdu-type"):
1165 continue # This vdu must not be created
1166 vdur
["vim_info"] = {"vim_account_id": vnfr
["vim-account-id"]}
1168 self
.logger
.debug("NS > ssh_keys > {}".format(ssh_keys_all
))
1171 vdu_configuration
= get_configuration(vnfd
, vdur
["vdu-id-ref"])
1172 vnf_configuration
= get_configuration(vnfd
, vnfd
["id"])
1175 and vdu_configuration
.get("config-access")
1176 and vdu_configuration
.get("config-access").get("ssh-access")
1178 vdur
["ssh-keys"] = ssh_keys_all
1179 vdur
["ssh-access-required"] = vdu_configuration
[
1181 ]["ssh-access"]["required"]
1184 and vnf_configuration
.get("config-access")
1185 and vnf_configuration
.get("config-access").get("ssh-access")
1186 and any(iface
.get("mgmt-vnf") for iface
in vdur
["interfaces"])
1188 vdur
["ssh-keys"] = ssh_keys_all
1189 vdur
["ssh-access-required"] = vnf_configuration
[
1191 ]["ssh-access"]["required"]
1192 elif ssh_keys_instantiation
and find_in_list(
1193 vdur
["interfaces"], lambda iface
: iface
.get("mgmt-vnf")
1195 vdur
["ssh-keys"] = ssh_keys_instantiation
1197 self
.logger
.debug("NS > vdur > {}".format(vdur
))
1199 vdud
= get_vdu(vnfd
, vdur
["vdu-id-ref"])
1201 if vdud
.get("cloud-init-file"):
1202 vdur
["cloud-init"] = "{}:file:{}".format(
1203 vnfd
["_id"], vdud
.get("cloud-init-file")
1205 # read file and put content at target.cloul_init_content. Avoid ng_ro to use shared package system
1206 if vdur
["cloud-init"] not in target
["cloud_init_content"]:
1207 base_folder
= vnfd
["_admin"]["storage"]
1208 if base_folder
["pkg-dir"]:
1209 cloud_init_file
= "{}/{}/cloud_init/{}".format(
1210 base_folder
["folder"],
1211 base_folder
["pkg-dir"],
1212 vdud
.get("cloud-init-file"),
1215 cloud_init_file
= "{}/Scripts/cloud_init/{}".format(
1216 base_folder
["folder"],
1217 vdud
.get("cloud-init-file"),
1219 with self
.fs
.file_open(cloud_init_file
, "r") as ci_file
:
1220 target
["cloud_init_content"][
1223 elif vdud
.get("cloud-init"):
1224 vdur
["cloud-init"] = "{}:vdu:{}".format(
1225 vnfd
["_id"], get_vdu_index(vnfd
, vdur
["vdu-id-ref"])
1227 # put content at target.cloul_init_content. Avoid ng_ro read vnfd descriptor
1228 target
["cloud_init_content"][vdur
["cloud-init"]] = vdud
[
1231 vdur
["additionalParams"] = vdur
.get("additionalParams") or {}
1232 deploy_params_vdu
= self
._format
_additional
_params
(
1233 vdur
.get("additionalParams") or {}
1235 deploy_params_vdu
["OSM"] = get_osm_params(
1236 vnfr
, vdur
["vdu-id-ref"], vdur
["count-index"]
1238 vdur
["additionalParams"] = deploy_params_vdu
1241 ns_flavor
= target
["flavor"][int(vdur
["ns-flavor-id"])]
1242 if target_vim
not in ns_flavor
["vim_info"]:
1243 ns_flavor
["vim_info"][target_vim
] = {}
1246 # in case alternative images are provided we must check if they should be applied
1247 # for the vim_type, modify the vim_type taking into account
1248 ns_image_id
= int(vdur
["ns-image-id"])
1249 if vdur
.get("alt-image-ids"):
1250 db_vim
= get_vim_account(vnfr
["vim-account-id"])
1251 vim_type
= db_vim
["vim_type"]
1252 for alt_image_id
in vdur
.get("alt-image-ids"):
1253 ns_alt_image
= target
["image"][int(alt_image_id
)]
1254 if vim_type
== ns_alt_image
.get("vim-type"):
1255 # must use alternative image
1257 "use alternative image id: {}".format(alt_image_id
)
1259 ns_image_id
= alt_image_id
1260 vdur
["ns-image-id"] = ns_image_id
1262 ns_image
= target
["image"][int(ns_image_id
)]
1263 if target_vim
not in ns_image
["vim_info"]:
1264 ns_image
["vim_info"][target_vim
] = {}
1267 if vdur
.get("affinity-or-anti-affinity-group-id"):
1268 for ags_id
in vdur
["affinity-or-anti-affinity-group-id"]:
1269 ns_ags
= target
["affinity-or-anti-affinity-group"][int(ags_id
)]
1270 if target_vim
not in ns_ags
["vim_info"]:
1271 ns_ags
["vim_info"][target_vim
] = {}
1273 vdur
["vim_info"] = {target_vim
: {}}
1274 # instantiation parameters
1276 vdu_instantiation_params
= find_in_list(
1277 get_iterable(vnf_params
, "vdu"),
1278 lambda i_vdu
: i_vdu
["id"] == vdud
["id"],
1280 if vdu_instantiation_params
:
1281 # Parse the vdu_volumes from the instantiation params
1282 vdu_volumes
= get_volumes_from_instantiation_params(
1283 vdu_instantiation_params
, vdud
1285 vdur
["additionalParams"]["OSM"]["vdu_volumes"] = vdu_volumes
1286 vdur_list
.append(vdur
)
1287 target_vnf
["vdur"] = vdur_list
1288 target
["vnf"].append(target_vnf
)
1290 self
.logger
.debug("Send to RO > nsr_id={} target={}".format(nsr_id
, target
))
1291 desc
= await self
.RO
.deploy(nsr_id
, target
)
1292 self
.logger
.debug("RO return > {}".format(desc
))
1293 action_id
= desc
["action_id"]
1294 await self
._wait
_ng
_ro
(
1295 nsr_id
, action_id
, nslcmop_id
, start_deploy
, timeout_ns_deploy
, stage
,
1296 operation
="instantiation"
1301 "_admin.deployed.RO.operational-status": "running",
1302 "detailed-status": " ".join(stage
),
1304 # db_nsr["_admin.deployed.RO.detailed-status"] = "Deployed at VIM"
1305 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
1306 self
._write
_op
_status
(nslcmop_id
, stage
)
1308 logging_text
+ "ns deployed at RO. RO_id={}".format(action_id
)
1312 async def _wait_ng_ro(
1322 detailed_status_old
= None
1324 start_time
= start_time
or time()
1325 while time() <= start_time
+ timeout
:
1326 desc_status
= await self
.op_status_map
[operation
](nsr_id
, action_id
)
1327 self
.logger
.debug("Wait NG RO > {}".format(desc_status
))
1328 if desc_status
["status"] == "FAILED":
1329 raise NgRoException(desc_status
["details"])
1330 elif desc_status
["status"] == "BUILD":
1332 stage
[2] = "VIM: ({})".format(desc_status
["details"])
1333 elif desc_status
["status"] == "DONE":
1335 stage
[2] = "Deployed at VIM"
1338 assert False, "ROclient.check_ns_status returns unknown {}".format(
1339 desc_status
["status"]
1341 if stage
and nslcmop_id
and stage
[2] != detailed_status_old
:
1342 detailed_status_old
= stage
[2]
1343 db_nsr_update
["detailed-status"] = " ".join(stage
)
1344 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
1345 self
._write
_op
_status
(nslcmop_id
, stage
)
1346 await asyncio
.sleep(15, loop
=self
.loop
)
1347 else: # timeout_ns_deploy
1348 raise NgRoException("Timeout waiting ns to deploy")
1350 async def _terminate_ng_ro(
1351 self
, logging_text
, nsr_deployed
, nsr_id
, nslcmop_id
, stage
1356 start_deploy
= time()
1363 "action_id": nslcmop_id
,
1365 desc
= await self
.RO
.deploy(nsr_id
, target
)
1366 action_id
= desc
["action_id"]
1367 db_nsr_update
["_admin.deployed.RO.nsr_delete_action_id"] = action_id
1368 db_nsr_update
["_admin.deployed.RO.nsr_status"] = "DELETING"
1371 + "ns terminate action at RO. action_id={}".format(action_id
)
1375 delete_timeout
= 20 * 60 # 20 minutes
1376 await self
._wait
_ng
_ro
(
1377 nsr_id
, action_id
, nslcmop_id
, start_deploy
, delete_timeout
, stage
,
1378 operation
="termination"
1381 db_nsr_update
["_admin.deployed.RO.nsr_delete_action_id"] = None
1382 db_nsr_update
["_admin.deployed.RO.nsr_status"] = "DELETED"
1384 await self
.RO
.delete(nsr_id
)
1385 except Exception as e
:
1386 if isinstance(e
, NgRoException
) and e
.http_code
== 404: # not found
1387 db_nsr_update
["_admin.deployed.RO.nsr_id"] = None
1388 db_nsr_update
["_admin.deployed.RO.nsr_status"] = "DELETED"
1389 db_nsr_update
["_admin.deployed.RO.nsr_delete_action_id"] = None
1391 logging_text
+ "RO_action_id={} already deleted".format(action_id
)
1393 elif isinstance(e
, NgRoException
) and e
.http_code
== 409: # conflict
1394 failed_detail
.append("delete conflict: {}".format(e
))
1397 + "RO_action_id={} delete conflict: {}".format(action_id
, e
)
1400 failed_detail
.append("delete error: {}".format(e
))
1403 + "RO_action_id={} delete error: {}".format(action_id
, e
)
1407 stage
[2] = "Error deleting from VIM"
1409 stage
[2] = "Deleted from VIM"
1410 db_nsr_update
["detailed-status"] = " ".join(stage
)
1411 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
1412 self
._write
_op
_status
(nslcmop_id
, stage
)
1415 raise LcmException("; ".join(failed_detail
))
1418 async def instantiate_RO(
1432 :param logging_text: preffix text to use at logging
1433 :param nsr_id: nsr identity
1434 :param nsd: database content of ns descriptor
1435 :param db_nsr: database content of ns record
1436 :param db_nslcmop: database content of ns operation, in this case, 'instantiate'
1438 :param db_vnfds: database content of vnfds, indexed by id (not _id). {id: {vnfd_object}, ...}
1439 :param n2vc_key_list: ssh-public-key list to be inserted to management vdus via cloud-init
1440 :param stage: list with 3 items: [general stage, tasks, vim_specific]. This task will write over vim_specific
1441 :return: None or exception
1444 start_deploy
= time()
1445 ns_params
= db_nslcmop
.get("operationParams")
1446 if ns_params
and ns_params
.get("timeout_ns_deploy"):
1447 timeout_ns_deploy
= ns_params
["timeout_ns_deploy"]
1449 timeout_ns_deploy
= self
.timeout
.get(
1450 "ns_deploy", self
.timeout_ns_deploy
1453 # Check for and optionally request placement optimization. Database will be updated if placement activated
1454 stage
[2] = "Waiting for Placement."
1455 if await self
._do
_placement
(logging_text
, db_nslcmop
, db_vnfrs
):
1456 # in case of placement change ns_params[vimAcountId) if not present at any vnfrs
1457 for vnfr
in db_vnfrs
.values():
1458 if ns_params
["vimAccountId"] == vnfr
["vim-account-id"]:
1461 ns_params
["vimAccountId"] == vnfr
["vim-account-id"]
1463 return await self
._instantiate
_ng
_ro
(
1476 except Exception as e
:
1477 stage
[2] = "ERROR deploying at VIM"
1478 self
.set_vnfr_at_error(db_vnfrs
, str(e
))
1480 "Error deploying at VIM {}".format(e
),
1481 exc_info
=not isinstance(
1484 ROclient
.ROClientException
,
1493 async def wait_kdu_up(self
, logging_text
, nsr_id
, vnfr_id
, kdu_name
):
1495 Wait for kdu to be up, get ip address
1496 :param logging_text: prefix use for logging
1500 :return: IP address, K8s services
1503 # self.logger.debug(logging_text + "Starting wait_kdu_up")
1506 while nb_tries
< 360:
1507 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnfr_id
})
1511 for x
in get_iterable(db_vnfr
, "kdur")
1512 if x
.get("kdu-name") == kdu_name
1518 "Not found vnfr_id={}, kdu_name={}".format(vnfr_id
, kdu_name
)
1520 if kdur
.get("status"):
1521 if kdur
["status"] in ("READY", "ENABLED"):
1522 return kdur
.get("ip-address"), kdur
.get("services")
1525 "target KDU={} is in error state".format(kdu_name
)
1528 await asyncio
.sleep(10, loop
=self
.loop
)
1530 raise LcmException("Timeout waiting KDU={} instantiated".format(kdu_name
))
1532 async def wait_vm_up_insert_key_ro(
1533 self
, logging_text
, nsr_id
, vnfr_id
, vdu_id
, vdu_index
, pub_key
=None, user
=None
1536 Wait for ip addres at RO, and optionally, insert public key in virtual machine
1537 :param logging_text: prefix use for logging
1542 :param pub_key: public ssh key to inject, None to skip
1543 :param user: user to apply the public ssh key
1547 self
.logger
.debug(logging_text
+ "Starting wait_vm_up_insert_key_ro")
1551 target_vdu_id
= None
1557 if ro_retries
>= 360: # 1 hour
1559 "Not found _admin.deployed.RO.nsr_id for nsr_id: {}".format(nsr_id
)
1562 await asyncio
.sleep(10, loop
=self
.loop
)
1565 if not target_vdu_id
:
1566 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnfr_id
})
1568 if not vdu_id
: # for the VNF case
1569 if db_vnfr
.get("status") == "ERROR":
1571 "Cannot inject ssh-key because target VNF is in error state"
1573 ip_address
= db_vnfr
.get("ip-address")
1579 for x
in get_iterable(db_vnfr
, "vdur")
1580 if x
.get("ip-address") == ip_address
1588 for x
in get_iterable(db_vnfr
, "vdur")
1589 if x
.get("vdu-id-ref") == vdu_id
1590 and x
.get("count-index") == vdu_index
1596 not vdur
and len(db_vnfr
.get("vdur", ())) == 1
1597 ): # If only one, this should be the target vdu
1598 vdur
= db_vnfr
["vdur"][0]
1601 "Not found vnfr_id={}, vdu_id={}, vdu_index={}".format(
1602 vnfr_id
, vdu_id
, vdu_index
1605 # New generation RO stores information at "vim_info"
1608 if vdur
.get("vim_info"):
1610 t
for t
in vdur
["vim_info"]
1611 ) # there should be only one key
1612 ng_ro_status
= vdur
["vim_info"][target_vim
].get("vim_status")
1614 vdur
.get("pdu-type")
1615 or vdur
.get("status") == "ACTIVE"
1616 or ng_ro_status
== "ACTIVE"
1618 ip_address
= vdur
.get("ip-address")
1621 target_vdu_id
= vdur
["vdu-id-ref"]
1622 elif vdur
.get("status") == "ERROR" or ng_ro_status
== "ERROR":
1624 "Cannot inject ssh-key because target VM is in error state"
1627 if not target_vdu_id
:
1630 # inject public key into machine
1631 if pub_key
and user
:
1632 self
.logger
.debug(logging_text
+ "Inserting RO key")
1633 self
.logger
.debug("SSH > PubKey > {}".format(pub_key
))
1634 if vdur
.get("pdu-type"):
1635 self
.logger
.error(logging_text
+ "Cannot inject ssh-ky to a PDU")
1638 ro_vm_id
= "{}-{}".format(
1639 db_vnfr
["member-vnf-index-ref"], target_vdu_id
1640 ) # TODO add vdu_index
1644 "action": "inject_ssh_key",
1648 "vnf": [{"_id": vnfr_id
, "vdur": [{"id": vdur
["id"]}]}],
1650 desc
= await self
.RO
.deploy(nsr_id
, target
)
1651 action_id
= desc
["action_id"]
1652 await self
._wait
_ng
_ro
(nsr_id
, action_id
, timeout
=600, operation
="instantiation")
1655 # wait until NS is deployed at RO
1657 db_nsrs
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
1658 ro_nsr_id
= deep_get(
1659 db_nsrs
, ("_admin", "deployed", "RO", "nsr_id")
1663 result_dict
= await self
.RO
.create_action(
1665 item_id_name
=ro_nsr_id
,
1667 "add_public_key": pub_key
,
1672 # result_dict contains the format {VM-id: {vim_result: 200, description: text}}
1673 if not result_dict
or not isinstance(result_dict
, dict):
1675 "Unknown response from RO when injecting key"
1677 for result
in result_dict
.values():
1678 if result
.get("vim_result") == 200:
1681 raise ROclient
.ROClientException(
1682 "error injecting key: {}".format(
1683 result
.get("description")
1687 except NgRoException
as e
:
1689 "Reaching max tries injecting key. Error: {}".format(e
)
1691 except ROclient
.ROClientException
as e
:
1695 + "error injecting key: {}. Retrying until {} seconds".format(
1702 "Reaching max tries injecting key. Error: {}".format(e
)
1709 async def _wait_dependent_n2vc(self
, nsr_id
, vca_deployed_list
, vca_index
):
1711 Wait until dependent VCA deployments have been finished. NS wait for VNFs and VDUs. VNFs for VDUs
1713 my_vca
= vca_deployed_list
[vca_index
]
1714 if my_vca
.get("vdu_id") or my_vca
.get("kdu_name"):
1715 # vdu or kdu: no dependencies
1719 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
1720 vca_deployed_list
= db_nsr
["_admin"]["deployed"]["VCA"]
1721 configuration_status_list
= db_nsr
["configurationStatus"]
1722 for index
, vca_deployed
in enumerate(configuration_status_list
):
1723 if index
== vca_index
:
1726 if not my_vca
.get("member-vnf-index") or (
1727 vca_deployed
.get("member-vnf-index")
1728 == my_vca
.get("member-vnf-index")
1730 internal_status
= configuration_status_list
[index
].get("status")
1731 if internal_status
== "READY":
1733 elif internal_status
== "BROKEN":
1735 "Configuration aborted because dependent charm/s has failed"
1740 # no dependencies, return
1742 await asyncio
.sleep(10)
1745 raise LcmException("Configuration aborted because dependent charm/s timeout")
1747 def get_vca_id(self
, db_vnfr
: dict, db_nsr
: dict):
1750 vca_id
= deep_get(db_vnfr
, ("vca-id",))
1752 vim_account_id
= deep_get(db_nsr
, ("instantiate_params", "vimAccountId"))
1753 vca_id
= VimAccountDB
.get_vim_account_with_id(vim_account_id
).get("vca")
1756 async def instantiate_N2VC(
1773 ee_config_descriptor
,
1775 nsr_id
= db_nsr
["_id"]
1776 db_update_entry
= "_admin.deployed.VCA.{}.".format(vca_index
)
1777 vca_deployed_list
= db_nsr
["_admin"]["deployed"]["VCA"]
1778 vca_deployed
= db_nsr
["_admin"]["deployed"]["VCA"][vca_index
]
1779 osm_config
= {"osm": {"ns_id": db_nsr
["_id"]}}
1781 "collection": "nsrs",
1782 "filter": {"_id": nsr_id
},
1783 "path": db_update_entry
,
1789 element_under_configuration
= nsr_id
1793 vnfr_id
= db_vnfr
["_id"]
1794 osm_config
["osm"]["vnf_id"] = vnfr_id
1796 namespace
= "{nsi}.{ns}".format(nsi
=nsi_id
if nsi_id
else "", ns
=nsr_id
)
1798 if vca_type
== "native_charm":
1801 index_number
= vdu_index
or 0
1804 element_type
= "VNF"
1805 element_under_configuration
= vnfr_id
1806 namespace
+= ".{}-{}".format(vnfr_id
, index_number
)
1808 namespace
+= ".{}-{}".format(vdu_id
, index_number
)
1809 element_type
= "VDU"
1810 element_under_configuration
= "{}-{}".format(vdu_id
, index_number
)
1811 osm_config
["osm"]["vdu_id"] = vdu_id
1813 namespace
+= ".{}".format(kdu_name
)
1814 element_type
= "KDU"
1815 element_under_configuration
= kdu_name
1816 osm_config
["osm"]["kdu_name"] = kdu_name
1819 if base_folder
["pkg-dir"]:
1820 artifact_path
= "{}/{}/{}/{}".format(
1821 base_folder
["folder"],
1822 base_folder
["pkg-dir"],
1825 in ("native_charm", "lxc_proxy_charm", "k8s_proxy_charm")
1830 artifact_path
= "{}/Scripts/{}/{}/".format(
1831 base_folder
["folder"],
1834 in ("native_charm", "lxc_proxy_charm", "k8s_proxy_charm")
1839 self
.logger
.debug("Artifact path > {}".format(artifact_path
))
1841 # get initial_config_primitive_list that applies to this element
1842 initial_config_primitive_list
= config_descriptor
.get(
1843 "initial-config-primitive"
1847 "Initial config primitive list > {}".format(
1848 initial_config_primitive_list
1852 # add config if not present for NS charm
1853 ee_descriptor_id
= ee_config_descriptor
.get("id")
1854 self
.logger
.debug("EE Descriptor > {}".format(ee_descriptor_id
))
1855 initial_config_primitive_list
= get_ee_sorted_initial_config_primitive_list(
1856 initial_config_primitive_list
, vca_deployed
, ee_descriptor_id
1860 "Initial config primitive list #2 > {}".format(
1861 initial_config_primitive_list
1864 # n2vc_redesign STEP 3.1
1865 # find old ee_id if exists
1866 ee_id
= vca_deployed
.get("ee_id")
1868 vca_id
= self
.get_vca_id(db_vnfr
, db_nsr
)
1869 # create or register execution environment in VCA
1870 if vca_type
in ("lxc_proxy_charm", "k8s_proxy_charm", "helm", "helm-v3"):
1872 self
._write
_configuration
_status
(
1874 vca_index
=vca_index
,
1876 element_under_configuration
=element_under_configuration
,
1877 element_type
=element_type
,
1880 step
= "create execution environment"
1881 self
.logger
.debug(logging_text
+ step
)
1885 if vca_type
== "k8s_proxy_charm":
1886 ee_id
= await self
.vca_map
[vca_type
].install_k8s_proxy_charm(
1887 charm_name
=artifact_path
[artifact_path
.rfind("/") + 1 :],
1888 namespace
=namespace
,
1889 artifact_path
=artifact_path
,
1893 elif vca_type
== "helm" or vca_type
== "helm-v3":
1894 ee_id
, credentials
= await self
.vca_map
[
1896 ].create_execution_environment(
1897 namespace
=namespace
,
1901 artifact_path
=artifact_path
,
1905 ee_id
, credentials
= await self
.vca_map
[
1907 ].create_execution_environment(
1908 namespace
=namespace
,
1914 elif vca_type
== "native_charm":
1915 step
= "Waiting to VM being up and getting IP address"
1916 self
.logger
.debug(logging_text
+ step
)
1917 rw_mgmt_ip
= await self
.wait_vm_up_insert_key_ro(
1926 credentials
= {"hostname": rw_mgmt_ip
}
1928 username
= deep_get(
1929 config_descriptor
, ("config-access", "ssh-access", "default-user")
1931 # TODO remove this when changes on IM regarding config-access:ssh-access:default-user were
1932 # merged. Meanwhile let's get username from initial-config-primitive
1933 if not username
and initial_config_primitive_list
:
1934 for config_primitive
in initial_config_primitive_list
:
1935 for param
in config_primitive
.get("parameter", ()):
1936 if param
["name"] == "ssh-username":
1937 username
= param
["value"]
1941 "Cannot determine the username neither with 'initial-config-primitive' nor with "
1942 "'config-access.ssh-access.default-user'"
1944 credentials
["username"] = username
1945 # n2vc_redesign STEP 3.2
1947 self
._write
_configuration
_status
(
1949 vca_index
=vca_index
,
1950 status
="REGISTERING",
1951 element_under_configuration
=element_under_configuration
,
1952 element_type
=element_type
,
1955 step
= "register execution environment {}".format(credentials
)
1956 self
.logger
.debug(logging_text
+ step
)
1957 ee_id
= await self
.vca_map
[vca_type
].register_execution_environment(
1958 credentials
=credentials
,
1959 namespace
=namespace
,
1964 # for compatibility with MON/POL modules, the need model and application name at database
1965 # TODO ask MON/POL if needed to not assuming anymore the format "model_name.application_name"
1966 ee_id_parts
= ee_id
.split(".")
1967 db_nsr_update
= {db_update_entry
+ "ee_id": ee_id
}
1968 if len(ee_id_parts
) >= 2:
1969 model_name
= ee_id_parts
[0]
1970 application_name
= ee_id_parts
[1]
1971 db_nsr_update
[db_update_entry
+ "model"] = model_name
1972 db_nsr_update
[db_update_entry
+ "application"] = application_name
1974 # n2vc_redesign STEP 3.3
1975 step
= "Install configuration Software"
1977 self
._write
_configuration
_status
(
1979 vca_index
=vca_index
,
1980 status
="INSTALLING SW",
1981 element_under_configuration
=element_under_configuration
,
1982 element_type
=element_type
,
1983 other_update
=db_nsr_update
,
1986 # TODO check if already done
1987 self
.logger
.debug(logging_text
+ step
)
1989 if vca_type
== "native_charm":
1990 config_primitive
= next(
1991 (p
for p
in initial_config_primitive_list
if p
["name"] == "config"),
1994 if config_primitive
:
1995 config
= self
._map
_primitive
_params
(
1996 config_primitive
, {}, deploy_params
1999 if vca_type
== "lxc_proxy_charm":
2000 if element_type
== "NS":
2001 num_units
= db_nsr
.get("config-units") or 1
2002 elif element_type
== "VNF":
2003 num_units
= db_vnfr
.get("config-units") or 1
2004 elif element_type
== "VDU":
2005 for v
in db_vnfr
["vdur"]:
2006 if vdu_id
== v
["vdu-id-ref"]:
2007 num_units
= v
.get("config-units") or 1
2009 if vca_type
!= "k8s_proxy_charm":
2010 await self
.vca_map
[vca_type
].install_configuration_sw(
2012 artifact_path
=artifact_path
,
2015 num_units
=num_units
,
2020 # write in db flag of configuration_sw already installed
2022 "nsrs", nsr_id
, {db_update_entry
+ "config_sw_installed": True}
2025 # add relations for this VCA (wait for other peers related with this VCA)
2026 await self
._add
_vca
_relations
(
2027 logging_text
=logging_text
,
2030 vca_index
=vca_index
,
2033 # if SSH access is required, then get execution environment SSH public
2034 # if native charm we have waited already to VM be UP
2035 if vca_type
in ("k8s_proxy_charm", "lxc_proxy_charm", "helm", "helm-v3"):
2038 # self.logger.debug("get ssh key block")
2040 config_descriptor
, ("config-access", "ssh-access", "required")
2042 # self.logger.debug("ssh key needed")
2043 # Needed to inject a ssh key
2046 ("config-access", "ssh-access", "default-user"),
2048 step
= "Install configuration Software, getting public ssh key"
2049 pub_key
= await self
.vca_map
[vca_type
].get_ee_ssh_public__key(
2050 ee_id
=ee_id
, db_dict
=db_dict
, vca_id
=vca_id
2053 step
= "Insert public key into VM user={} ssh_key={}".format(
2057 # self.logger.debug("no need to get ssh key")
2058 step
= "Waiting to VM being up and getting IP address"
2059 self
.logger
.debug(logging_text
+ step
)
2061 # default rw_mgmt_ip to None, avoiding the non definition of the variable
2064 # n2vc_redesign STEP 5.1
2065 # wait for RO (ip-address) Insert pub_key into VM
2068 rw_mgmt_ip
, services
= await self
.wait_kdu_up(
2069 logging_text
, nsr_id
, vnfr_id
, kdu_name
2071 vnfd
= self
.db
.get_one(
2073 {"_id": f
'{db_vnfr["vnfd-id"]}:{db_vnfr["revision"]}'},
2075 kdu
= get_kdu(vnfd
, kdu_name
)
2077 service
["name"] for service
in get_kdu_services(kdu
)
2079 exposed_services
= []
2080 for service
in services
:
2081 if any(s
in service
["name"] for s
in kdu_services
):
2082 exposed_services
.append(service
)
2083 await self
.vca_map
[vca_type
].exec_primitive(
2085 primitive_name
="config",
2087 "osm-config": json
.dumps(
2089 k8s
={"services": exposed_services
}
2096 # This verification is needed in order to avoid trying to add a public key
2097 # to a VM, when the VNF is a KNF (in the edge case where the user creates a VCA
2098 # for a KNF and not for its KDUs, the previous verification gives False, and the code
2099 # jumps to this block, meaning that there is the need to verify if the VNF is actually a VNF
2101 elif db_vnfr
.get('vdur'):
2102 rw_mgmt_ip
= await self
.wait_vm_up_insert_key_ro(
2112 self
.logger
.debug(logging_text
+ " VM_ip_address={}".format(rw_mgmt_ip
))
2114 # store rw_mgmt_ip in deploy params for later replacement
2115 deploy_params
["rw_mgmt_ip"] = rw_mgmt_ip
2117 # n2vc_redesign STEP 6 Execute initial config primitive
2118 step
= "execute initial config primitive"
2120 # wait for dependent primitives execution (NS -> VNF -> VDU)
2121 if initial_config_primitive_list
:
2122 await self
._wait
_dependent
_n
2vc
(nsr_id
, vca_deployed_list
, vca_index
)
2124 # stage, in function of element type: vdu, kdu, vnf or ns
2125 my_vca
= vca_deployed_list
[vca_index
]
2126 if my_vca
.get("vdu_id") or my_vca
.get("kdu_name"):
2128 stage
[0] = "Stage 3/5: running Day-1 primitives for VDU."
2129 elif my_vca
.get("member-vnf-index"):
2131 stage
[0] = "Stage 4/5: running Day-1 primitives for VNF."
2134 stage
[0] = "Stage 5/5: running Day-1 primitives for NS."
2136 self
._write
_configuration
_status
(
2137 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="EXECUTING PRIMITIVE"
2140 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
)
2142 check_if_terminated_needed
= True
2143 for initial_config_primitive
in initial_config_primitive_list
:
2144 # adding information on the vca_deployed if it is a NS execution environment
2145 if not vca_deployed
["member-vnf-index"]:
2146 deploy_params
["ns_config_info"] = json
.dumps(
2147 self
._get
_ns
_config
_info
(nsr_id
)
2149 # TODO check if already done
2150 primitive_params_
= self
._map
_primitive
_params
(
2151 initial_config_primitive
, {}, deploy_params
2154 step
= "execute primitive '{}' params '{}'".format(
2155 initial_config_primitive
["name"], primitive_params_
2157 self
.logger
.debug(logging_text
+ step
)
2158 await self
.vca_map
[vca_type
].exec_primitive(
2160 primitive_name
=initial_config_primitive
["name"],
2161 params_dict
=primitive_params_
,
2166 # Once some primitive has been exec, check and write at db if it needs to exec terminated primitives
2167 if check_if_terminated_needed
:
2168 if config_descriptor
.get("terminate-config-primitive"):
2170 "nsrs", nsr_id
, {db_update_entry
+ "needed_terminate": True}
2172 check_if_terminated_needed
= False
2174 # TODO register in database that primitive is done
2176 # STEP 7 Configure metrics
2177 if vca_type
== "helm" or vca_type
== "helm-v3":
2178 prometheus_jobs
= await self
.extract_prometheus_scrape_jobs(
2180 artifact_path
=artifact_path
,
2181 ee_config_descriptor
=ee_config_descriptor
,
2184 target_ip
=rw_mgmt_ip
,
2190 {db_update_entry
+ "prometheus_jobs": prometheus_jobs
},
2193 for job
in prometheus_jobs
:
2196 {"job_name": job
["job_name"]},
2199 fail_on_empty
=False,
2202 step
= "instantiated at VCA"
2203 self
.logger
.debug(logging_text
+ step
)
2205 self
._write
_configuration
_status
(
2206 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="READY"
2209 except Exception as e
: # TODO not use Exception but N2VC exception
2210 # self.update_db_2("nsrs", nsr_id, {db_update_entry + "instantiation": "FAILED"})
2212 e
, (DbException
, N2VCException
, LcmException
, asyncio
.CancelledError
)
2215 "Exception while {} : {}".format(step
, e
), exc_info
=True
2217 self
._write
_configuration
_status
(
2218 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="BROKEN"
2220 raise LcmException("{} {}".format(step
, e
)) from e
2222 def _write_ns_status(
2226 current_operation
: str,
2227 current_operation_id
: str,
2228 error_description
: str = None,
2229 error_detail
: str = None,
2230 other_update
: dict = None,
2233 Update db_nsr fields.
2236 :param current_operation:
2237 :param current_operation_id:
2238 :param error_description:
2239 :param error_detail:
2240 :param other_update: Other required changes at database if provided, will be cleared
2244 db_dict
= other_update
or {}
2247 ] = current_operation_id
# for backward compatibility
2248 db_dict
["_admin.current-operation"] = current_operation_id
2249 db_dict
["_admin.operation-type"] = (
2250 current_operation
if current_operation
!= "IDLE" else None
2252 db_dict
["currentOperation"] = current_operation
2253 db_dict
["currentOperationID"] = current_operation_id
2254 db_dict
["errorDescription"] = error_description
2255 db_dict
["errorDetail"] = error_detail
2258 db_dict
["nsState"] = ns_state
2259 self
.update_db_2("nsrs", nsr_id
, db_dict
)
2260 except DbException
as e
:
2261 self
.logger
.warn("Error writing NS status, ns={}: {}".format(nsr_id
, e
))
2263 def _write_op_status(
2267 error_message
: str = None,
2268 queuePosition
: int = 0,
2269 operation_state
: str = None,
2270 other_update
: dict = None,
2273 db_dict
= other_update
or {}
2274 db_dict
["queuePosition"] = queuePosition
2275 if isinstance(stage
, list):
2276 db_dict
["stage"] = stage
[0]
2277 db_dict
["detailed-status"] = " ".join(stage
)
2278 elif stage
is not None:
2279 db_dict
["stage"] = str(stage
)
2281 if error_message
is not None:
2282 db_dict
["errorMessage"] = error_message
2283 if operation_state
is not None:
2284 db_dict
["operationState"] = operation_state
2285 db_dict
["statusEnteredTime"] = time()
2286 self
.update_db_2("nslcmops", op_id
, db_dict
)
2287 except DbException
as e
:
2289 "Error writing OPERATION status for op_id: {} -> {}".format(op_id
, e
)
2292 def _write_all_config_status(self
, db_nsr
: dict, status
: str):
2294 nsr_id
= db_nsr
["_id"]
2295 # configurationStatus
2296 config_status
= db_nsr
.get("configurationStatus")
2299 "configurationStatus.{}.status".format(index
): status
2300 for index
, v
in enumerate(config_status
)
2304 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
2306 except DbException
as e
:
2308 "Error writing all configuration status, ns={}: {}".format(nsr_id
, e
)
2311 def _write_configuration_status(
2316 element_under_configuration
: str = None,
2317 element_type
: str = None,
2318 other_update
: dict = None,
2321 # self.logger.debug('_write_configuration_status(): vca_index={}, status={}'
2322 # .format(vca_index, status))
2325 db_path
= "configurationStatus.{}.".format(vca_index
)
2326 db_dict
= other_update
or {}
2328 db_dict
[db_path
+ "status"] = status
2329 if element_under_configuration
:
2331 db_path
+ "elementUnderConfiguration"
2332 ] = element_under_configuration
2334 db_dict
[db_path
+ "elementType"] = element_type
2335 self
.update_db_2("nsrs", nsr_id
, db_dict
)
2336 except DbException
as e
:
2338 "Error writing configuration status={}, ns={}, vca_index={}: {}".format(
2339 status
, nsr_id
, vca_index
, e
2343 async def _do_placement(self
, logging_text
, db_nslcmop
, db_vnfrs
):
2345 Check and computes the placement, (vim account where to deploy). If it is decided by an external tool, it
2346 sends the request via kafka and wait until the result is wrote at database (nslcmops _admin.plca).
2347 Database is used because the result can be obtained from a different LCM worker in case of HA.
2348 :param logging_text: contains the prefix for logging, with the ns and nslcmop identifiers
2349 :param db_nslcmop: database content of nslcmop
2350 :param db_vnfrs: database content of vnfrs, indexed by member-vnf-index.
2351 :return: True if some modification is done. Modifies database vnfrs and parameter db_vnfr with the
2352 computed 'vim-account-id'
2355 nslcmop_id
= db_nslcmop
["_id"]
2356 placement_engine
= deep_get(db_nslcmop
, ("operationParams", "placement-engine"))
2357 if placement_engine
== "PLA":
2359 logging_text
+ "Invoke and wait for placement optimization"
2361 await self
.msg
.aiowrite(
2362 "pla", "get_placement", {"nslcmopId": nslcmop_id
}, loop
=self
.loop
2364 db_poll_interval
= 5
2365 wait
= db_poll_interval
* 10
2367 while not pla_result
and wait
>= 0:
2368 await asyncio
.sleep(db_poll_interval
)
2369 wait
-= db_poll_interval
2370 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
2371 pla_result
= deep_get(db_nslcmop
, ("_admin", "pla"))
2375 "Placement timeout for nslcmopId={}".format(nslcmop_id
)
2378 for pla_vnf
in pla_result
["vnf"]:
2379 vnfr
= db_vnfrs
.get(pla_vnf
["member-vnf-index"])
2380 if not pla_vnf
.get("vimAccountId") or not vnfr
:
2385 {"_id": vnfr
["_id"]},
2386 {"vim-account-id": pla_vnf
["vimAccountId"]},
2389 vnfr
["vim-account-id"] = pla_vnf
["vimAccountId"]
2392 def update_nsrs_with_pla_result(self
, params
):
2394 nslcmop_id
= deep_get(params
, ("placement", "nslcmopId"))
2396 "nslcmops", nslcmop_id
, {"_admin.pla": params
.get("placement")}
2398 except Exception as e
:
2399 self
.logger
.warn("Update failed for nslcmop_id={}:{}".format(nslcmop_id
, e
))
2401 async def instantiate(self
, nsr_id
, nslcmop_id
):
2404 :param nsr_id: ns instance to deploy
2405 :param nslcmop_id: operation to run
2409 # Try to lock HA task here
2410 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
2411 if not task_is_locked_by_me
:
2413 "instantiate() task is not locked by me, ns={}".format(nsr_id
)
2417 logging_text
= "Task ns={} instantiate={} ".format(nsr_id
, nslcmop_id
)
2418 self
.logger
.debug(logging_text
+ "Enter")
2420 # get all needed from database
2422 # database nsrs record
2425 # database nslcmops record
2428 # update operation on nsrs
2430 # update operation on nslcmops
2431 db_nslcmop_update
= {}
2433 nslcmop_operation_state
= None
2434 db_vnfrs
= {} # vnf's info indexed by member-index
2436 tasks_dict_info
= {} # from task to info text
2440 "Stage 1/5: preparation of the environment.",
2441 "Waiting for previous operations to terminate.",
2444 # ^ stage, step, VIM progress
2446 # wait for any previous tasks in process
2447 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
2449 # STEP 0: Reading database (nslcmops, nsrs, nsds, vnfrs, vnfds)
2450 stage
[1] = "Reading from database."
2451 # nsState="BUILDING", currentOperation="INSTANTIATING", currentOperationID=nslcmop_id
2452 db_nsr_update
["detailed-status"] = "creating"
2453 db_nsr_update
["operational-status"] = "init"
2454 self
._write
_ns
_status
(
2456 ns_state
="BUILDING",
2457 current_operation
="INSTANTIATING",
2458 current_operation_id
=nslcmop_id
,
2459 other_update
=db_nsr_update
,
2461 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
, queuePosition
=0)
2463 # read from db: operation
2464 stage
[1] = "Getting nslcmop={} from db.".format(nslcmop_id
)
2465 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
2466 if db_nslcmop
["operationParams"].get("additionalParamsForVnf"):
2467 db_nslcmop
["operationParams"]["additionalParamsForVnf"] = json
.loads(
2468 db_nslcmop
["operationParams"]["additionalParamsForVnf"]
2470 ns_params
= db_nslcmop
.get("operationParams")
2471 if ns_params
and ns_params
.get("timeout_ns_deploy"):
2472 timeout_ns_deploy
= ns_params
["timeout_ns_deploy"]
2474 timeout_ns_deploy
= self
.timeout
.get(
2475 "ns_deploy", self
.timeout_ns_deploy
2479 stage
[1] = "Getting nsr={} from db.".format(nsr_id
)
2480 self
.logger
.debug(logging_text
+ stage
[1])
2481 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
2482 stage
[1] = "Getting nsd={} from db.".format(db_nsr
["nsd-id"])
2483 self
.logger
.debug(logging_text
+ stage
[1])
2484 nsd
= self
.db
.get_one("nsds", {"_id": db_nsr
["nsd-id"]})
2485 self
.fs
.sync(db_nsr
["nsd-id"])
2487 # nsr_name = db_nsr["name"] # TODO short-name??
2489 # read from db: vnf's of this ns
2490 stage
[1] = "Getting vnfrs from db."
2491 self
.logger
.debug(logging_text
+ stage
[1])
2492 db_vnfrs_list
= self
.db
.get_list("vnfrs", {"nsr-id-ref": nsr_id
})
2494 # read from db: vnfd's for every vnf
2495 db_vnfds
= [] # every vnfd data
2497 # for each vnf in ns, read vnfd
2498 for vnfr
in db_vnfrs_list
:
2499 if vnfr
.get("kdur"):
2501 for kdur
in vnfr
["kdur"]:
2502 if kdur
.get("additionalParams"):
2503 kdur
["additionalParams"] = json
.loads(
2504 kdur
["additionalParams"]
2506 kdur_list
.append(kdur
)
2507 vnfr
["kdur"] = kdur_list
2509 db_vnfrs
[vnfr
["member-vnf-index-ref"]] = vnfr
2510 vnfd_id
= vnfr
["vnfd-id"]
2511 vnfd_ref
= vnfr
["vnfd-ref"]
2512 self
.fs
.sync(vnfd_id
)
2514 # if we haven't this vnfd, read it from db
2515 if vnfd_id
not in db_vnfds
:
2517 stage
[1] = "Getting vnfd={} id='{}' from db.".format(
2520 self
.logger
.debug(logging_text
+ stage
[1])
2521 vnfd
= self
.db
.get_one("vnfds", {"_id": vnfd_id
})
2524 db_vnfds
.append(vnfd
)
2526 # Get or generates the _admin.deployed.VCA list
2527 vca_deployed_list
= None
2528 if db_nsr
["_admin"].get("deployed"):
2529 vca_deployed_list
= db_nsr
["_admin"]["deployed"].get("VCA")
2530 if vca_deployed_list
is None:
2531 vca_deployed_list
= []
2532 configuration_status_list
= []
2533 db_nsr_update
["_admin.deployed.VCA"] = vca_deployed_list
2534 db_nsr_update
["configurationStatus"] = configuration_status_list
2535 # add _admin.deployed.VCA to db_nsr dictionary, value=vca_deployed_list
2536 populate_dict(db_nsr
, ("_admin", "deployed", "VCA"), vca_deployed_list
)
2537 elif isinstance(vca_deployed_list
, dict):
2538 # maintain backward compatibility. Change a dict to list at database
2539 vca_deployed_list
= list(vca_deployed_list
.values())
2540 db_nsr_update
["_admin.deployed.VCA"] = vca_deployed_list
2541 populate_dict(db_nsr
, ("_admin", "deployed", "VCA"), vca_deployed_list
)
2544 deep_get(db_nsr
, ("_admin", "deployed", "RO", "vnfd")), list
2546 populate_dict(db_nsr
, ("_admin", "deployed", "RO", "vnfd"), [])
2547 db_nsr_update
["_admin.deployed.RO.vnfd"] = []
2549 # set state to INSTANTIATED. When instantiated NBI will not delete directly
2550 db_nsr_update
["_admin.nsState"] = "INSTANTIATED"
2551 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
2553 "vnfrs", {"nsr-id-ref": nsr_id
}, {"_admin.nsState": "INSTANTIATED"}
2556 # n2vc_redesign STEP 2 Deploy Network Scenario
2557 stage
[0] = "Stage 2/5: deployment of KDUs, VMs and execution environments."
2558 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
)
2560 stage
[1] = "Deploying KDUs."
2561 # self.logger.debug(logging_text + "Before deploy_kdus")
2562 # Call to deploy_kdus in case exists the "vdu:kdu" param
2563 await self
.deploy_kdus(
2564 logging_text
=logging_text
,
2566 nslcmop_id
=nslcmop_id
,
2569 task_instantiation_info
=tasks_dict_info
,
2572 stage
[1] = "Getting VCA public key."
2573 # n2vc_redesign STEP 1 Get VCA public ssh-key
2574 # feature 1429. Add n2vc public key to needed VMs
2575 n2vc_key
= self
.n2vc
.get_public_key()
2576 n2vc_key_list
= [n2vc_key
]
2577 if self
.vca_config
.get("public_key"):
2578 n2vc_key_list
.append(self
.vca_config
["public_key"])
2580 stage
[1] = "Deploying NS at VIM."
2581 task_ro
= asyncio
.ensure_future(
2582 self
.instantiate_RO(
2583 logging_text
=logging_text
,
2587 db_nslcmop
=db_nslcmop
,
2590 n2vc_key_list
=n2vc_key_list
,
2594 self
.lcm_tasks
.register("ns", nsr_id
, nslcmop_id
, "instantiate_RO", task_ro
)
2595 tasks_dict_info
[task_ro
] = "Deploying at VIM"
2597 # n2vc_redesign STEP 3 to 6 Deploy N2VC
2598 stage
[1] = "Deploying Execution Environments."
2599 self
.logger
.debug(logging_text
+ stage
[1])
2601 nsi_id
= None # TODO put nsi_id when this nsr belongs to a NSI
2602 for vnf_profile
in get_vnf_profiles(nsd
):
2603 vnfd_id
= vnf_profile
["vnfd-id"]
2604 vnfd
= find_in_list(db_vnfds
, lambda a_vnf
: a_vnf
["id"] == vnfd_id
)
2605 member_vnf_index
= str(vnf_profile
["id"])
2606 db_vnfr
= db_vnfrs
[member_vnf_index
]
2607 base_folder
= vnfd
["_admin"]["storage"]
2613 # Get additional parameters
2614 deploy_params
= {"OSM": get_osm_params(db_vnfr
)}
2615 if db_vnfr
.get("additionalParamsForVnf"):
2616 deploy_params
.update(
2617 parse_yaml_strings(db_vnfr
["additionalParamsForVnf"].copy())
2620 descriptor_config
= get_configuration(vnfd
, vnfd
["id"])
2621 if descriptor_config
:
2623 logging_text
=logging_text
2624 + "member_vnf_index={} ".format(member_vnf_index
),
2627 nslcmop_id
=nslcmop_id
,
2633 member_vnf_index
=member_vnf_index
,
2634 vdu_index
=vdu_index
,
2636 deploy_params
=deploy_params
,
2637 descriptor_config
=descriptor_config
,
2638 base_folder
=base_folder
,
2639 task_instantiation_info
=tasks_dict_info
,
2643 # Deploy charms for each VDU that supports one.
2644 for vdud
in get_vdu_list(vnfd
):
2646 descriptor_config
= get_configuration(vnfd
, vdu_id
)
2647 vdur
= find_in_list(
2648 db_vnfr
["vdur"], lambda vdu
: vdu
["vdu-id-ref"] == vdu_id
2651 if vdur
.get("additionalParams"):
2652 deploy_params_vdu
= parse_yaml_strings(vdur
["additionalParams"])
2654 deploy_params_vdu
= deploy_params
2655 deploy_params_vdu
["OSM"] = get_osm_params(
2656 db_vnfr
, vdu_id
, vdu_count_index
=0
2658 vdud_count
= get_number_of_instances(vnfd
, vdu_id
)
2660 self
.logger
.debug("VDUD > {}".format(vdud
))
2662 "Descriptor config > {}".format(descriptor_config
)
2664 if descriptor_config
:
2667 for vdu_index
in range(vdud_count
):
2668 # TODO vnfr_params["rw_mgmt_ip"] = vdur["ip-address"]
2670 logging_text
=logging_text
2671 + "member_vnf_index={}, vdu_id={}, vdu_index={} ".format(
2672 member_vnf_index
, vdu_id
, vdu_index
2676 nslcmop_id
=nslcmop_id
,
2682 member_vnf_index
=member_vnf_index
,
2683 vdu_index
=vdu_index
,
2685 deploy_params
=deploy_params_vdu
,
2686 descriptor_config
=descriptor_config
,
2687 base_folder
=base_folder
,
2688 task_instantiation_info
=tasks_dict_info
,
2691 for kdud
in get_kdu_list(vnfd
):
2692 kdu_name
= kdud
["name"]
2693 descriptor_config
= get_configuration(vnfd
, kdu_name
)
2694 if descriptor_config
:
2699 x
for x
in db_vnfr
["kdur"] if x
["kdu-name"] == kdu_name
2701 deploy_params_kdu
= {"OSM": get_osm_params(db_vnfr
)}
2702 if kdur
.get("additionalParams"):
2703 deploy_params_kdu
.update(
2704 parse_yaml_strings(kdur
["additionalParams"].copy())
2708 logging_text
=logging_text
,
2711 nslcmop_id
=nslcmop_id
,
2717 member_vnf_index
=member_vnf_index
,
2718 vdu_index
=vdu_index
,
2720 deploy_params
=deploy_params_kdu
,
2721 descriptor_config
=descriptor_config
,
2722 base_folder
=base_folder
,
2723 task_instantiation_info
=tasks_dict_info
,
2727 # Check if this NS has a charm configuration
2728 descriptor_config
= nsd
.get("ns-configuration")
2729 if descriptor_config
and descriptor_config
.get("juju"):
2732 member_vnf_index
= None
2738 # Get additional parameters
2739 deploy_params
= {"OSM": {"vim_account_id": ns_params
["vimAccountId"]}}
2740 if db_nsr
.get("additionalParamsForNs"):
2741 deploy_params
.update(
2742 parse_yaml_strings(db_nsr
["additionalParamsForNs"].copy())
2744 base_folder
= nsd
["_admin"]["storage"]
2746 logging_text
=logging_text
,
2749 nslcmop_id
=nslcmop_id
,
2755 member_vnf_index
=member_vnf_index
,
2756 vdu_index
=vdu_index
,
2758 deploy_params
=deploy_params
,
2759 descriptor_config
=descriptor_config
,
2760 base_folder
=base_folder
,
2761 task_instantiation_info
=tasks_dict_info
,
2765 # rest of staff will be done at finally
2768 ROclient
.ROClientException
,
2774 logging_text
+ "Exit Exception while '{}': {}".format(stage
[1], e
)
2777 except asyncio
.CancelledError
:
2779 logging_text
+ "Cancelled Exception while '{}'".format(stage
[1])
2781 exc
= "Operation was cancelled"
2782 except Exception as e
:
2783 exc
= traceback
.format_exc()
2784 self
.logger
.critical(
2785 logging_text
+ "Exit Exception while '{}': {}".format(stage
[1], e
),
2790 error_list
.append(str(exc
))
2792 # wait for pending tasks
2794 stage
[1] = "Waiting for instantiate pending tasks."
2795 self
.logger
.debug(logging_text
+ stage
[1])
2796 error_list
+= await self
._wait
_for
_tasks
(
2804 stage
[1] = stage
[2] = ""
2805 except asyncio
.CancelledError
:
2806 error_list
.append("Cancelled")
2807 # TODO cancel all tasks
2808 except Exception as exc
:
2809 error_list
.append(str(exc
))
2811 # update operation-status
2812 db_nsr_update
["operational-status"] = "running"
2813 # let's begin with VCA 'configured' status (later we can change it)
2814 db_nsr_update
["config-status"] = "configured"
2815 for task
, task_name
in tasks_dict_info
.items():
2816 if not task
.done() or task
.cancelled() or task
.exception():
2817 if task_name
.startswith(self
.task_name_deploy_vca
):
2818 # A N2VC task is pending
2819 db_nsr_update
["config-status"] = "failed"
2821 # RO or KDU task is pending
2822 db_nsr_update
["operational-status"] = "failed"
2824 # update status at database
2826 error_detail
= ". ".join(error_list
)
2827 self
.logger
.error(logging_text
+ error_detail
)
2828 error_description_nslcmop
= "{} Detail: {}".format(
2829 stage
[0], error_detail
2831 error_description_nsr
= "Operation: INSTANTIATING.{}, {}".format(
2832 nslcmop_id
, stage
[0]
2835 db_nsr_update
["detailed-status"] = (
2836 error_description_nsr
+ " Detail: " + error_detail
2838 db_nslcmop_update
["detailed-status"] = error_detail
2839 nslcmop_operation_state
= "FAILED"
2843 error_description_nsr
= error_description_nslcmop
= None
2845 db_nsr_update
["detailed-status"] = "Done"
2846 db_nslcmop_update
["detailed-status"] = "Done"
2847 nslcmop_operation_state
= "COMPLETED"
2850 self
._write
_ns
_status
(
2853 current_operation
="IDLE",
2854 current_operation_id
=None,
2855 error_description
=error_description_nsr
,
2856 error_detail
=error_detail
,
2857 other_update
=db_nsr_update
,
2859 self
._write
_op
_status
(
2862 error_message
=error_description_nslcmop
,
2863 operation_state
=nslcmop_operation_state
,
2864 other_update
=db_nslcmop_update
,
2867 if nslcmop_operation_state
:
2869 await self
.msg
.aiowrite(
2874 "nslcmop_id": nslcmop_id
,
2875 "operationState": nslcmop_operation_state
,
2879 except Exception as e
:
2881 logging_text
+ "kafka_write notification Exception {}".format(e
)
2884 self
.logger
.debug(logging_text
+ "Exit")
2885 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_instantiate")
2887 def _get_vnfd(self
, vnfd_id
: str, cached_vnfds
: Dict
[str, Any
]):
2888 if vnfd_id
not in cached_vnfds
:
2889 cached_vnfds
[vnfd_id
] = self
.db
.get_one("vnfds", {"id": vnfd_id
})
2890 return cached_vnfds
[vnfd_id
]
2892 def _get_vnfr(self
, nsr_id
: str, vnf_profile_id
: str, cached_vnfrs
: Dict
[str, Any
]):
2893 if vnf_profile_id
not in cached_vnfrs
:
2894 cached_vnfrs
[vnf_profile_id
] = self
.db
.get_one(
2897 "member-vnf-index-ref": vnf_profile_id
,
2898 "nsr-id-ref": nsr_id
,
2901 return cached_vnfrs
[vnf_profile_id
]
2903 def _is_deployed_vca_in_relation(
2904 self
, vca
: DeployedVCA
, relation
: Relation
2907 for endpoint
in (relation
.provider
, relation
.requirer
):
2908 if endpoint
["kdu-resource-profile-id"]:
2911 vca
.vnf_profile_id
== endpoint
.vnf_profile_id
2912 and vca
.vdu_profile_id
== endpoint
.vdu_profile_id
2913 and vca
.execution_environment_ref
== endpoint
.execution_environment_ref
2919 def _update_ee_relation_data_with_implicit_data(
2920 self
, nsr_id
, nsd
, ee_relation_data
, cached_vnfds
, vnf_profile_id
: str = None
2922 ee_relation_data
= safe_get_ee_relation(
2923 nsr_id
, ee_relation_data
, vnf_profile_id
=vnf_profile_id
2925 ee_relation_level
= EELevel
.get_level(ee_relation_data
)
2926 if (ee_relation_level
in (EELevel
.VNF
, EELevel
.VDU
)) and not ee_relation_data
[
2927 "execution-environment-ref"
2929 vnf_profile
= get_vnf_profile(nsd
, ee_relation_data
["vnf-profile-id"])
2930 vnfd_id
= vnf_profile
["vnfd-id"]
2931 db_vnfd
= self
._get
_vnfd
(vnfd_id
, cached_vnfds
)
2934 if ee_relation_level
== EELevel
.VNF
2935 else ee_relation_data
["vdu-profile-id"]
2937 ee
= get_juju_ee_ref(db_vnfd
, entity_id
)
2940 f
"not execution environments found for ee_relation {ee_relation_data}"
2942 ee_relation_data
["execution-environment-ref"] = ee
["id"]
2943 return ee_relation_data
2945 def _get_ns_relations(
2948 nsd
: Dict
[str, Any
],
2950 cached_vnfds
: Dict
[str, Any
],
2951 ) -> List
[Relation
]:
2953 db_ns_relations
= get_ns_configuration_relation_list(nsd
)
2954 for r
in db_ns_relations
:
2955 provider_dict
= None
2956 requirer_dict
= None
2957 if all(key
in r
for key
in ("provider", "requirer")):
2958 provider_dict
= r
["provider"]
2959 requirer_dict
= r
["requirer"]
2960 elif "entities" in r
:
2961 provider_id
= r
["entities"][0]["id"]
2964 "endpoint": r
["entities"][0]["endpoint"],
2966 if provider_id
!= nsd
["id"]:
2967 provider_dict
["vnf-profile-id"] = provider_id
2968 requirer_id
= r
["entities"][1]["id"]
2971 "endpoint": r
["entities"][1]["endpoint"],
2973 if requirer_id
!= nsd
["id"]:
2974 requirer_dict
["vnf-profile-id"] = requirer_id
2977 "provider/requirer or entities must be included in the relation."
2979 relation_provider
= self
._update
_ee
_relation
_data
_with
_implicit
_data
(
2980 nsr_id
, nsd
, provider_dict
, cached_vnfds
2982 relation_requirer
= self
._update
_ee
_relation
_data
_with
_implicit
_data
(
2983 nsr_id
, nsd
, requirer_dict
, cached_vnfds
2985 provider
= EERelation(relation_provider
)
2986 requirer
= EERelation(relation_requirer
)
2987 relation
= Relation(r
["name"], provider
, requirer
)
2988 vca_in_relation
= self
._is
_deployed
_vca
_in
_relation
(vca
, relation
)
2990 relations
.append(relation
)
2993 def _get_vnf_relations(
2996 nsd
: Dict
[str, Any
],
2998 cached_vnfds
: Dict
[str, Any
],
2999 ) -> List
[Relation
]:
3001 vnf_profile
= get_vnf_profile(nsd
, vca
.vnf_profile_id
)
3002 vnf_profile_id
= vnf_profile
["id"]
3003 vnfd_id
= vnf_profile
["vnfd-id"]
3004 db_vnfd
= self
._get
_vnfd
(vnfd_id
, cached_vnfds
)
3005 db_vnf_relations
= get_relation_list(db_vnfd
, vnfd_id
)
3006 for r
in db_vnf_relations
:
3007 provider_dict
= None
3008 requirer_dict
= None
3009 if all(key
in r
for key
in ("provider", "requirer")):
3010 provider_dict
= r
["provider"]
3011 requirer_dict
= r
["requirer"]
3012 elif "entities" in r
:
3013 provider_id
= r
["entities"][0]["id"]
3016 "vnf-profile-id": vnf_profile_id
,
3017 "endpoint": r
["entities"][0]["endpoint"],
3019 if provider_id
!= vnfd_id
:
3020 provider_dict
["vdu-profile-id"] = provider_id
3021 requirer_id
= r
["entities"][1]["id"]
3024 "vnf-profile-id": vnf_profile_id
,
3025 "endpoint": r
["entities"][1]["endpoint"],
3027 if requirer_id
!= vnfd_id
:
3028 requirer_dict
["vdu-profile-id"] = requirer_id
3031 "provider/requirer or entities must be included in the relation."
3033 relation_provider
= self
._update
_ee
_relation
_data
_with
_implicit
_data
(
3034 nsr_id
, nsd
, provider_dict
, cached_vnfds
, vnf_profile_id
=vnf_profile_id
3036 relation_requirer
= self
._update
_ee
_relation
_data
_with
_implicit
_data
(
3037 nsr_id
, nsd
, requirer_dict
, cached_vnfds
, vnf_profile_id
=vnf_profile_id
3039 provider
= EERelation(relation_provider
)
3040 requirer
= EERelation(relation_requirer
)
3041 relation
= Relation(r
["name"], provider
, requirer
)
3042 vca_in_relation
= self
._is
_deployed
_vca
_in
_relation
(vca
, relation
)
3044 relations
.append(relation
)
3047 def _get_kdu_resource_data(
3049 ee_relation
: EERelation
,
3050 db_nsr
: Dict
[str, Any
],
3051 cached_vnfds
: Dict
[str, Any
],
3052 ) -> DeployedK8sResource
:
3053 nsd
= get_nsd(db_nsr
)
3054 vnf_profiles
= get_vnf_profiles(nsd
)
3055 vnfd_id
= find_in_list(
3057 lambda vnf_profile
: vnf_profile
["id"] == ee_relation
.vnf_profile_id
,
3059 db_vnfd
= self
._get
_vnfd
(vnfd_id
, cached_vnfds
)
3060 kdu_resource_profile
= get_kdu_resource_profile(
3061 db_vnfd
, ee_relation
.kdu_resource_profile_id
3063 kdu_name
= kdu_resource_profile
["kdu-name"]
3064 deployed_kdu
, _
= get_deployed_kdu(
3065 db_nsr
.get("_admin", ()).get("deployed", ()),
3067 ee_relation
.vnf_profile_id
,
3069 deployed_kdu
.update({"resource-name": kdu_resource_profile
["resource-name"]})
3072 def _get_deployed_component(
3074 ee_relation
: EERelation
,
3075 db_nsr
: Dict
[str, Any
],
3076 cached_vnfds
: Dict
[str, Any
],
3077 ) -> DeployedComponent
:
3078 nsr_id
= db_nsr
["_id"]
3079 deployed_component
= None
3080 ee_level
= EELevel
.get_level(ee_relation
)
3081 if ee_level
== EELevel
.NS
:
3082 vca
= get_deployed_vca(db_nsr
, {"vdu_id": None, "member-vnf-index": None})
3084 deployed_component
= DeployedVCA(nsr_id
, vca
)
3085 elif ee_level
== EELevel
.VNF
:
3086 vca
= get_deployed_vca(
3090 "member-vnf-index": ee_relation
.vnf_profile_id
,
3091 "ee_descriptor_id": ee_relation
.execution_environment_ref
,
3095 deployed_component
= DeployedVCA(nsr_id
, vca
)
3096 elif ee_level
== EELevel
.VDU
:
3097 vca
= get_deployed_vca(
3100 "vdu_id": ee_relation
.vdu_profile_id
,
3101 "member-vnf-index": ee_relation
.vnf_profile_id
,
3102 "ee_descriptor_id": ee_relation
.execution_environment_ref
,
3106 deployed_component
= DeployedVCA(nsr_id
, vca
)
3107 elif ee_level
== EELevel
.KDU
:
3108 kdu_resource_data
= self
._get
_kdu
_resource
_data
(
3109 ee_relation
, db_nsr
, cached_vnfds
3111 if kdu_resource_data
:
3112 deployed_component
= DeployedK8sResource(kdu_resource_data
)
3113 return deployed_component
3115 async def _add_relation(
3119 db_nsr
: Dict
[str, Any
],
3120 cached_vnfds
: Dict
[str, Any
],
3121 cached_vnfrs
: Dict
[str, Any
],
3123 deployed_provider
= self
._get
_deployed
_component
(
3124 relation
.provider
, db_nsr
, cached_vnfds
3126 deployed_requirer
= self
._get
_deployed
_component
(
3127 relation
.requirer
, db_nsr
, cached_vnfds
3131 and deployed_requirer
3132 and deployed_provider
.config_sw_installed
3133 and deployed_requirer
.config_sw_installed
3135 provider_db_vnfr
= (
3137 relation
.provider
.nsr_id
,
3138 relation
.provider
.vnf_profile_id
,
3141 if relation
.provider
.vnf_profile_id
3144 requirer_db_vnfr
= (
3146 relation
.requirer
.nsr_id
,
3147 relation
.requirer
.vnf_profile_id
,
3150 if relation
.requirer
.vnf_profile_id
3153 provider_vca_id
= self
.get_vca_id(provider_db_vnfr
, db_nsr
)
3154 requirer_vca_id
= self
.get_vca_id(requirer_db_vnfr
, db_nsr
)
3155 provider_relation_endpoint
= RelationEndpoint(
3156 deployed_provider
.ee_id
,
3158 relation
.provider
.endpoint
,
3160 requirer_relation_endpoint
= RelationEndpoint(
3161 deployed_requirer
.ee_id
,
3163 relation
.requirer
.endpoint
,
3165 await self
.vca_map
[vca_type
].add_relation(
3166 provider
=provider_relation_endpoint
,
3167 requirer
=requirer_relation_endpoint
,
3169 # remove entry from relations list
3173 async def _add_vca_relations(
3179 timeout
: int = 3600,
3183 # 1. find all relations for this VCA
3184 # 2. wait for other peers related
3188 # STEP 1: find all relations for this VCA
3191 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
3192 nsd
= get_nsd(db_nsr
)
3195 deployed_vca_dict
= get_deployed_vca_list(db_nsr
)[vca_index
]
3196 my_vca
= DeployedVCA(nsr_id
, deployed_vca_dict
)
3201 relations
.extend(self
._get
_ns
_relations
(nsr_id
, nsd
, my_vca
, cached_vnfds
))
3202 relations
.extend(self
._get
_vnf
_relations
(nsr_id
, nsd
, my_vca
, cached_vnfds
))
3204 # if no relations, terminate
3206 self
.logger
.debug(logging_text
+ " No relations")
3209 self
.logger
.debug(logging_text
+ " adding relations {}".format(relations
))
3216 if now
- start
>= timeout
:
3217 self
.logger
.error(logging_text
+ " : timeout adding relations")
3220 # reload nsr from database (we need to update record: _admin.deployed.VCA)
3221 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
3223 # for each relation, find the VCA's related
3224 for relation
in relations
.copy():
3225 added
= await self
._add
_relation
(
3233 relations
.remove(relation
)
3236 self
.logger
.debug("Relations added")
3238 await asyncio
.sleep(5.0)
3242 except Exception as e
:
3243 self
.logger
.warn(logging_text
+ " ERROR adding relations: {}".format(e
))
3246 async def _install_kdu(
3254 k8s_instance_info
: dict,
3255 k8params
: dict = None,
3261 k8sclustertype
= k8s_instance_info
["k8scluster-type"]
3264 "collection": "nsrs",
3265 "filter": {"_id": nsr_id
},
3266 "path": nsr_db_path
,
3269 if k8s_instance_info
.get("kdu-deployment-name"):
3270 kdu_instance
= k8s_instance_info
.get("kdu-deployment-name")
3272 kdu_instance
= self
.k8scluster_map
[
3274 ].generate_kdu_instance_name(
3275 db_dict
=db_dict_install
,
3276 kdu_model
=k8s_instance_info
["kdu-model"],
3277 kdu_name
=k8s_instance_info
["kdu-name"],
3280 # Update the nsrs table with the kdu-instance value
3284 _desc
={nsr_db_path
+ ".kdu-instance": kdu_instance
},
3287 # Update the nsrs table with the actual namespace being used, if the k8scluster-type is `juju` or
3288 # `juju-bundle`. This verification is needed because there is not a standard/homogeneous namespace
3289 # between the Helm Charts and Juju Bundles-based KNFs. If we found a way of having an homogeneous
3290 # namespace, this first verification could be removed, and the next step would be done for any kind
3292 # TODO -> find a way to have an homogeneous namespace between the Helm Charts and Juju Bundles-based
3293 # KNFs (Bug 2027: https://osm.etsi.org/bugzilla/show_bug.cgi?id=2027)
3294 if k8sclustertype
in ("juju", "juju-bundle"):
3295 # First, verify if the current namespace is present in the `_admin.projects_read` (if not, it means
3296 # that the user passed a namespace which he wants its KDU to be deployed in)
3302 "_admin.projects_write": k8s_instance_info
["namespace"],
3303 "_admin.projects_read": k8s_instance_info
["namespace"],
3309 f
"Updating namespace/model for Juju Bundle from {k8s_instance_info['namespace']} to {kdu_instance}"
3314 _desc
={f
"{nsr_db_path}.namespace": kdu_instance
},
3316 k8s_instance_info
["namespace"] = kdu_instance
3318 await self
.k8scluster_map
[k8sclustertype
].install(
3319 cluster_uuid
=k8s_instance_info
["k8scluster-uuid"],
3320 kdu_model
=k8s_instance_info
["kdu-model"],
3323 db_dict
=db_dict_install
,
3325 kdu_name
=k8s_instance_info
["kdu-name"],
3326 namespace
=k8s_instance_info
["namespace"],
3327 kdu_instance
=kdu_instance
,
3331 # Obtain services to obtain management service ip
3332 services
= await self
.k8scluster_map
[k8sclustertype
].get_services(
3333 cluster_uuid
=k8s_instance_info
["k8scluster-uuid"],
3334 kdu_instance
=kdu_instance
,
3335 namespace
=k8s_instance_info
["namespace"],
3338 # Obtain management service info (if exists)
3339 vnfr_update_dict
= {}
3340 kdu_config
= get_configuration(vnfd
, kdud
["name"])
3342 target_ee_list
= kdu_config
.get("execution-environment-list", [])
3347 vnfr_update_dict
["kdur.{}.services".format(kdu_index
)] = services
3350 for service
in kdud
.get("service", [])
3351 if service
.get("mgmt-service")
3353 for mgmt_service
in mgmt_services
:
3354 for service
in services
:
3355 if service
["name"].startswith(mgmt_service
["name"]):
3356 # Mgmt service found, Obtain service ip
3357 ip
= service
.get("external_ip", service
.get("cluster_ip"))
3358 if isinstance(ip
, list) and len(ip
) == 1:
3362 "kdur.{}.ip-address".format(kdu_index
)
3365 # Check if must update also mgmt ip at the vnf
3366 service_external_cp
= mgmt_service
.get(
3367 "external-connection-point-ref"
3369 if service_external_cp
:
3371 deep_get(vnfd
, ("mgmt-interface", "cp"))
3372 == service_external_cp
3374 vnfr_update_dict
["ip-address"] = ip
3379 "external-connection-point-ref", ""
3381 == service_external_cp
,
3384 "kdur.{}.ip-address".format(kdu_index
)
3389 "Mgmt service name: {} not found".format(
3390 mgmt_service
["name"]
3394 vnfr_update_dict
["kdur.{}.status".format(kdu_index
)] = "READY"
3395 self
.update_db_2("vnfrs", vnfr_data
.get("_id"), vnfr_update_dict
)
3397 kdu_config
= get_configuration(vnfd
, k8s_instance_info
["kdu-name"])
3400 and kdu_config
.get("initial-config-primitive")
3401 and get_juju_ee_ref(vnfd
, k8s_instance_info
["kdu-name"]) is None
3403 initial_config_primitive_list
= kdu_config
.get(
3404 "initial-config-primitive"
3406 initial_config_primitive_list
.sort(key
=lambda val
: int(val
["seq"]))
3408 for initial_config_primitive
in initial_config_primitive_list
:
3409 primitive_params_
= self
._map
_primitive
_params
(
3410 initial_config_primitive
, {}, {}
3413 await asyncio
.wait_for(
3414 self
.k8scluster_map
[k8sclustertype
].exec_primitive(
3415 cluster_uuid
=k8s_instance_info
["k8scluster-uuid"],
3416 kdu_instance
=kdu_instance
,
3417 primitive_name
=initial_config_primitive
["name"],
3418 params
=primitive_params_
,
3419 db_dict
=db_dict_install
,
3425 except Exception as e
:
3426 # Prepare update db with error and raise exception
3429 "nsrs", nsr_id
, {nsr_db_path
+ ".detailed-status": str(e
)}
3433 vnfr_data
.get("_id"),
3434 {"kdur.{}.status".format(kdu_index
): "ERROR"},
3437 # ignore to keep original exception
3439 # reraise original error
3444 async def deploy_kdus(
3451 task_instantiation_info
,
3453 # Launch kdus if present in the descriptor
3455 k8scluster_id_2_uuic
= {
3456 "helm-chart-v3": {},
3461 async def _get_cluster_id(cluster_id
, cluster_type
):
3462 nonlocal k8scluster_id_2_uuic
3463 if cluster_id
in k8scluster_id_2_uuic
[cluster_type
]:
3464 return k8scluster_id_2_uuic
[cluster_type
][cluster_id
]
3466 # check if K8scluster is creating and wait look if previous tasks in process
3467 task_name
, task_dependency
= self
.lcm_tasks
.lookfor_related(
3468 "k8scluster", cluster_id
3471 text
= "Waiting for related tasks '{}' on k8scluster {} to be completed".format(
3472 task_name
, cluster_id
3474 self
.logger
.debug(logging_text
+ text
)
3475 await asyncio
.wait(task_dependency
, timeout
=3600)
3477 db_k8scluster
= self
.db
.get_one(
3478 "k8sclusters", {"_id": cluster_id
}, fail_on_empty
=False
3480 if not db_k8scluster
:
3481 raise LcmException("K8s cluster {} cannot be found".format(cluster_id
))
3483 k8s_id
= deep_get(db_k8scluster
, ("_admin", cluster_type
, "id"))
3485 if cluster_type
== "helm-chart-v3":
3487 # backward compatibility for existing clusters that have not been initialized for helm v3
3488 k8s_credentials
= yaml
.safe_dump(
3489 db_k8scluster
.get("credentials")
3491 k8s_id
, uninstall_sw
= await self
.k8sclusterhelm3
.init_env(
3492 k8s_credentials
, reuse_cluster_uuid
=cluster_id
3494 db_k8scluster_update
= {}
3495 db_k8scluster_update
["_admin.helm-chart-v3.error_msg"] = None
3496 db_k8scluster_update
["_admin.helm-chart-v3.id"] = k8s_id
3497 db_k8scluster_update
[
3498 "_admin.helm-chart-v3.created"
3500 db_k8scluster_update
[
3501 "_admin.helm-chart-v3.operationalState"
3504 "k8sclusters", cluster_id
, db_k8scluster_update
3506 except Exception as e
:
3509 + "error initializing helm-v3 cluster: {}".format(str(e
))
3512 "K8s cluster '{}' has not been initialized for '{}'".format(
3513 cluster_id
, cluster_type
3518 "K8s cluster '{}' has not been initialized for '{}'".format(
3519 cluster_id
, cluster_type
3522 k8scluster_id_2_uuic
[cluster_type
][cluster_id
] = k8s_id
3525 logging_text
+= "Deploy kdus: "
3528 db_nsr_update
= {"_admin.deployed.K8s": []}
3529 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
3532 updated_cluster_list
= []
3533 updated_v3_cluster_list
= []
3535 for vnfr_data
in db_vnfrs
.values():
3536 vca_id
= self
.get_vca_id(vnfr_data
, {})
3537 for kdu_index
, kdur
in enumerate(get_iterable(vnfr_data
, "kdur")):
3538 # Step 0: Prepare and set parameters
3539 desc_params
= parse_yaml_strings(kdur
.get("additionalParams"))
3540 vnfd_id
= vnfr_data
.get("vnfd-id")
3541 vnfd_with_id
= find_in_list(
3542 db_vnfds
, lambda vnfd
: vnfd
["_id"] == vnfd_id
3546 for kdud
in vnfd_with_id
["kdu"]
3547 if kdud
["name"] == kdur
["kdu-name"]
3549 namespace
= kdur
.get("k8s-namespace")
3550 kdu_deployment_name
= kdur
.get("kdu-deployment-name")
3551 if kdur
.get("helm-chart"):
3552 kdumodel
= kdur
["helm-chart"]
3553 # Default version: helm3, if helm-version is v2 assign v2
3554 k8sclustertype
= "helm-chart-v3"
3555 self
.logger
.debug("kdur: {}".format(kdur
))
3557 kdur
.get("helm-version")
3558 and kdur
.get("helm-version") == "v2"
3560 k8sclustertype
= "helm-chart"
3561 elif kdur
.get("juju-bundle"):
3562 kdumodel
= kdur
["juju-bundle"]
3563 k8sclustertype
= "juju-bundle"
3566 "kdu type for kdu='{}.{}' is neither helm-chart nor "
3567 "juju-bundle. Maybe an old NBI version is running".format(
3568 vnfr_data
["member-vnf-index-ref"], kdur
["kdu-name"]
3571 # check if kdumodel is a file and exists
3573 vnfd_with_id
= find_in_list(
3574 db_vnfds
, lambda vnfd
: vnfd
["_id"] == vnfd_id
3576 storage
= deep_get(vnfd_with_id
, ("_admin", "storage"))
3577 if storage
: # may be not present if vnfd has not artifacts
3578 # path format: /vnfdid/pkkdir/helm-charts|juju-bundles/kdumodel
3579 if storage
["pkg-dir"]:
3580 filename
= "{}/{}/{}s/{}".format(
3587 filename
= "{}/Scripts/{}s/{}".format(
3592 if self
.fs
.file_exists(
3593 filename
, mode
="file"
3594 ) or self
.fs
.file_exists(filename
, mode
="dir"):
3595 kdumodel
= self
.fs
.path
+ filename
3596 except (asyncio
.TimeoutError
, asyncio
.CancelledError
):
3598 except Exception: # it is not a file
3601 k8s_cluster_id
= kdur
["k8s-cluster"]["id"]
3602 step
= "Synchronize repos for k8s cluster '{}'".format(
3605 cluster_uuid
= await _get_cluster_id(k8s_cluster_id
, k8sclustertype
)
3609 k8sclustertype
== "helm-chart"
3610 and cluster_uuid
not in updated_cluster_list
3612 k8sclustertype
== "helm-chart-v3"
3613 and cluster_uuid
not in updated_v3_cluster_list
3615 del_repo_list
, added_repo_dict
= await asyncio
.ensure_future(
3616 self
.k8scluster_map
[k8sclustertype
].synchronize_repos(
3617 cluster_uuid
=cluster_uuid
3620 if del_repo_list
or added_repo_dict
:
3621 if k8sclustertype
== "helm-chart":
3623 "_admin.helm_charts_added." + item
: None
3624 for item
in del_repo_list
3627 "_admin.helm_charts_added." + item
: name
3628 for item
, name
in added_repo_dict
.items()
3630 updated_cluster_list
.append(cluster_uuid
)
3631 elif k8sclustertype
== "helm-chart-v3":
3633 "_admin.helm_charts_v3_added." + item
: None
3634 for item
in del_repo_list
3637 "_admin.helm_charts_v3_added." + item
: name
3638 for item
, name
in added_repo_dict
.items()
3640 updated_v3_cluster_list
.append(cluster_uuid
)
3642 logging_text
+ "repos synchronized on k8s cluster "
3643 "'{}' to_delete: {}, to_add: {}".format(
3644 k8s_cluster_id
, del_repo_list
, added_repo_dict
3649 {"_id": k8s_cluster_id
},
3655 step
= "Instantiating KDU {}.{} in k8s cluster {}".format(
3656 vnfr_data
["member-vnf-index-ref"],
3660 k8s_instance_info
= {
3661 "kdu-instance": None,
3662 "k8scluster-uuid": cluster_uuid
,
3663 "k8scluster-type": k8sclustertype
,
3664 "member-vnf-index": vnfr_data
["member-vnf-index-ref"],
3665 "kdu-name": kdur
["kdu-name"],
3666 "kdu-model": kdumodel
,
3667 "namespace": namespace
,
3668 "kdu-deployment-name": kdu_deployment_name
,
3670 db_path
= "_admin.deployed.K8s.{}".format(index
)
3671 db_nsr_update
[db_path
] = k8s_instance_info
3672 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
3673 vnfd_with_id
= find_in_list(
3674 db_vnfds
, lambda vnf
: vnf
["_id"] == vnfd_id
3676 task
= asyncio
.ensure_future(
3685 k8params
=desc_params
,
3690 self
.lcm_tasks
.register(
3694 "instantiate_KDU-{}".format(index
),
3697 task_instantiation_info
[task
] = "Deploying KDU {}".format(
3703 except (LcmException
, asyncio
.CancelledError
):
3705 except Exception as e
:
3706 msg
= "Exception {} while {}: {}".format(type(e
).__name
__, step
, e
)
3707 if isinstance(e
, (N2VCException
, DbException
)):
3708 self
.logger
.error(logging_text
+ msg
)
3710 self
.logger
.critical(logging_text
+ msg
, exc_info
=True)
3711 raise LcmException(msg
)
3714 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
3733 task_instantiation_info
,
3736 # launch instantiate_N2VC in a asyncio task and register task object
3737 # Look where information of this charm is at database <nsrs>._admin.deployed.VCA
3738 # if not found, create one entry and update database
3739 # fill db_nsr._admin.deployed.VCA.<index>
3742 logging_text
+ "_deploy_n2vc vnfd_id={}, vdu_id={}".format(vnfd_id
, vdu_id
)
3744 if "execution-environment-list" in descriptor_config
:
3745 ee_list
= descriptor_config
.get("execution-environment-list", [])
3746 elif "juju" in descriptor_config
:
3747 ee_list
= [descriptor_config
] # ns charms
3748 else: # other types as script are not supported
3751 for ee_item
in ee_list
:
3754 + "_deploy_n2vc ee_item juju={}, helm={}".format(
3755 ee_item
.get("juju"), ee_item
.get("helm-chart")
3758 ee_descriptor_id
= ee_item
.get("id")
3759 if ee_item
.get("juju"):
3760 vca_name
= ee_item
["juju"].get("charm")
3763 if ee_item
["juju"].get("charm") is not None
3766 if ee_item
["juju"].get("cloud") == "k8s":
3767 vca_type
= "k8s_proxy_charm"
3768 elif ee_item
["juju"].get("proxy") is False:
3769 vca_type
= "native_charm"
3770 elif ee_item
.get("helm-chart"):
3771 vca_name
= ee_item
["helm-chart"]
3772 if ee_item
.get("helm-version") and ee_item
.get("helm-version") == "v2":
3775 vca_type
= "helm-v3"
3778 logging_text
+ "skipping non juju neither charm configuration"
3783 for vca_index
, vca_deployed
in enumerate(
3784 db_nsr
["_admin"]["deployed"]["VCA"]
3786 if not vca_deployed
:
3789 vca_deployed
.get("member-vnf-index") == member_vnf_index
3790 and vca_deployed
.get("vdu_id") == vdu_id
3791 and vca_deployed
.get("kdu_name") == kdu_name
3792 and vca_deployed
.get("vdu_count_index", 0) == vdu_index
3793 and vca_deployed
.get("ee_descriptor_id") == ee_descriptor_id
3797 # not found, create one.
3799 "ns" if not member_vnf_index
else "vnf/{}".format(member_vnf_index
)
3802 target
+= "/vdu/{}/{}".format(vdu_id
, vdu_index
or 0)
3804 target
+= "/kdu/{}".format(kdu_name
)
3806 "target_element": target
,
3807 # ^ target_element will replace member-vnf-index, kdu_name, vdu_id ... in a single string
3808 "member-vnf-index": member_vnf_index
,
3810 "kdu_name": kdu_name
,
3811 "vdu_count_index": vdu_index
,
3812 "operational-status": "init", # TODO revise
3813 "detailed-status": "", # TODO revise
3814 "step": "initial-deploy", # TODO revise
3816 "vdu_name": vdu_name
,
3818 "ee_descriptor_id": ee_descriptor_id
,
3822 # create VCA and configurationStatus in db
3824 "_admin.deployed.VCA.{}".format(vca_index
): vca_deployed
,
3825 "configurationStatus.{}".format(vca_index
): dict(),
3827 self
.update_db_2("nsrs", nsr_id
, db_dict
)
3829 db_nsr
["_admin"]["deployed"]["VCA"].append(vca_deployed
)
3831 self
.logger
.debug("N2VC > NSR_ID > {}".format(nsr_id
))
3832 self
.logger
.debug("N2VC > DB_NSR > {}".format(db_nsr
))
3833 self
.logger
.debug("N2VC > VCA_DEPLOYED > {}".format(vca_deployed
))
3836 task_n2vc
= asyncio
.ensure_future(
3837 self
.instantiate_N2VC(
3838 logging_text
=logging_text
,
3839 vca_index
=vca_index
,
3845 vdu_index
=vdu_index
,
3846 deploy_params
=deploy_params
,
3847 config_descriptor
=descriptor_config
,
3848 base_folder
=base_folder
,
3849 nslcmop_id
=nslcmop_id
,
3853 ee_config_descriptor
=ee_item
,
3856 self
.lcm_tasks
.register(
3860 "instantiate_N2VC-{}".format(vca_index
),
3863 task_instantiation_info
[
3865 ] = self
.task_name_deploy_vca
+ " {}.{}".format(
3866 member_vnf_index
or "", vdu_id
or ""
3870 def _create_nslcmop(nsr_id
, operation
, params
):
3872 Creates a ns-lcm-opp content to be stored at database.
3873 :param nsr_id: internal id of the instance
3874 :param operation: instantiate, terminate, scale, action, ...
3875 :param params: user parameters for the operation
3876 :return: dictionary following SOL005 format
3878 # Raise exception if invalid arguments
3879 if not (nsr_id
and operation
and params
):
3881 "Parameters 'nsr_id', 'operation' and 'params' needed to create primitive not provided"
3888 # COMPLETED,PARTIALLY_COMPLETED,FAILED_TEMP,FAILED,ROLLING_BACK,ROLLED_BACK
3889 "operationState": "PROCESSING",
3890 "statusEnteredTime": now
,
3891 "nsInstanceId": nsr_id
,
3892 "lcmOperationType": operation
,
3894 "isAutomaticInvocation": False,
3895 "operationParams": params
,
3896 "isCancelPending": False,
3898 "self": "/osm/nslcm/v1/ns_lcm_op_occs/" + _id
,
3899 "nsInstance": "/osm/nslcm/v1/ns_instances/" + nsr_id
,
3904 def _format_additional_params(self
, params
):
3905 params
= params
or {}
3906 for key
, value
in params
.items():
3907 if str(value
).startswith("!!yaml "):
3908 params
[key
] = yaml
.safe_load(value
[7:])
3911 def _get_terminate_primitive_params(self
, seq
, vnf_index
):
3912 primitive
= seq
.get("name")
3913 primitive_params
= {}
3915 "member_vnf_index": vnf_index
,
3916 "primitive": primitive
,
3917 "primitive_params": primitive_params
,
3920 return self
._map
_primitive
_params
(seq
, params
, desc_params
)
3924 def _retry_or_skip_suboperation(self
, db_nslcmop
, op_index
):
3925 op
= deep_get(db_nslcmop
, ("_admin", "operations"), [])[op_index
]
3926 if op
.get("operationState") == "COMPLETED":
3927 # b. Skip sub-operation
3928 # _ns_execute_primitive() or RO.create_action() will NOT be executed
3929 return self
.SUBOPERATION_STATUS_SKIP
3931 # c. retry executing sub-operation
3932 # The sub-operation exists, and operationState != 'COMPLETED'
3933 # Update operationState = 'PROCESSING' to indicate a retry.
3934 operationState
= "PROCESSING"
3935 detailed_status
= "In progress"
3936 self
._update
_suboperation
_status
(
3937 db_nslcmop
, op_index
, operationState
, detailed_status
3939 # Return the sub-operation index
3940 # _ns_execute_primitive() or RO.create_action() will be called from scale()
3941 # with arguments extracted from the sub-operation
3944 # Find a sub-operation where all keys in a matching dictionary must match
3945 # Returns the index of the matching sub-operation, or SUBOPERATION_STATUS_NOT_FOUND if no match
3946 def _find_suboperation(self
, db_nslcmop
, match
):
3947 if db_nslcmop
and match
:
3948 op_list
= db_nslcmop
.get("_admin", {}).get("operations", [])
3949 for i
, op
in enumerate(op_list
):
3950 if all(op
.get(k
) == match
[k
] for k
in match
):
3952 return self
.SUBOPERATION_STATUS_NOT_FOUND
3954 # Update status for a sub-operation given its index
3955 def _update_suboperation_status(
3956 self
, db_nslcmop
, op_index
, operationState
, detailed_status
3958 # Update DB for HA tasks
3959 q_filter
= {"_id": db_nslcmop
["_id"]}
3961 "_admin.operations.{}.operationState".format(op_index
): operationState
,
3962 "_admin.operations.{}.detailed-status".format(op_index
): detailed_status
,
3965 "nslcmops", q_filter
=q_filter
, update_dict
=update_dict
, fail_on_empty
=False
3968 # Add sub-operation, return the index of the added sub-operation
3969 # Optionally, set operationState, detailed-status, and operationType
3970 # Status and type are currently set for 'scale' sub-operations:
3971 # 'operationState' : 'PROCESSING' | 'COMPLETED' | 'FAILED'
3972 # 'detailed-status' : status message
3973 # 'operationType': may be any type, in the case of scaling: 'PRE-SCALE' | 'POST-SCALE'
3974 # Status and operation type are currently only used for 'scale', but NOT for 'terminate' sub-operations.
3975 def _add_suboperation(
3983 mapped_primitive_params
,
3984 operationState
=None,
3985 detailed_status
=None,
3988 RO_scaling_info
=None,
3991 return self
.SUBOPERATION_STATUS_NOT_FOUND
3992 # Get the "_admin.operations" list, if it exists
3993 db_nslcmop_admin
= db_nslcmop
.get("_admin", {})
3994 op_list
= db_nslcmop_admin
.get("operations")
3995 # Create or append to the "_admin.operations" list
3997 "member_vnf_index": vnf_index
,
3999 "vdu_count_index": vdu_count_index
,
4000 "primitive": primitive
,
4001 "primitive_params": mapped_primitive_params
,
4004 new_op
["operationState"] = operationState
4006 new_op
["detailed-status"] = detailed_status
4008 new_op
["lcmOperationType"] = operationType
4010 new_op
["RO_nsr_id"] = RO_nsr_id
4012 new_op
["RO_scaling_info"] = RO_scaling_info
4014 # No existing operations, create key 'operations' with current operation as first list element
4015 db_nslcmop_admin
.update({"operations": [new_op
]})
4016 op_list
= db_nslcmop_admin
.get("operations")
4018 # Existing operations, append operation to list
4019 op_list
.append(new_op
)
4021 db_nslcmop_update
= {"_admin.operations": op_list
}
4022 self
.update_db_2("nslcmops", db_nslcmop
["_id"], db_nslcmop_update
)
4023 op_index
= len(op_list
) - 1
4026 # Helper methods for scale() sub-operations
4028 # pre-scale/post-scale:
4029 # Check for 3 different cases:
4030 # a. New: First time execution, return SUBOPERATION_STATUS_NEW
4031 # b. Skip: Existing sub-operation exists, operationState == 'COMPLETED', return SUBOPERATION_STATUS_SKIP
4032 # c. retry: Existing sub-operation exists, operationState != 'COMPLETED', return op_index to re-execute
4033 def _check_or_add_scale_suboperation(
4037 vnf_config_primitive
,
4041 RO_scaling_info
=None,
4043 # Find this sub-operation
4044 if RO_nsr_id
and RO_scaling_info
:
4045 operationType
= "SCALE-RO"
4047 "member_vnf_index": vnf_index
,
4048 "RO_nsr_id": RO_nsr_id
,
4049 "RO_scaling_info": RO_scaling_info
,
4053 "member_vnf_index": vnf_index
,
4054 "primitive": vnf_config_primitive
,
4055 "primitive_params": primitive_params
,
4056 "lcmOperationType": operationType
,
4058 op_index
= self
._find
_suboperation
(db_nslcmop
, match
)
4059 if op_index
== self
.SUBOPERATION_STATUS_NOT_FOUND
:
4060 # a. New sub-operation
4061 # The sub-operation does not exist, add it.
4062 # _ns_execute_primitive() will be called from scale() as usual, with non-modified arguments
4063 # The following parameters are set to None for all kind of scaling:
4065 vdu_count_index
= None
4067 if RO_nsr_id
and RO_scaling_info
:
4068 vnf_config_primitive
= None
4069 primitive_params
= None
4072 RO_scaling_info
= None
4073 # Initial status for sub-operation
4074 operationState
= "PROCESSING"
4075 detailed_status
= "In progress"
4076 # Add sub-operation for pre/post-scaling (zero or more operations)
4077 self
._add
_suboperation
(
4083 vnf_config_primitive
,
4091 return self
.SUBOPERATION_STATUS_NEW
4093 # Return either SUBOPERATION_STATUS_SKIP (operationState == 'COMPLETED'),
4094 # or op_index (operationState != 'COMPLETED')
4095 return self
._retry
_or
_skip
_suboperation
(db_nslcmop
, op_index
)
4097 # Function to return execution_environment id
4099 def _get_ee_id(self
, vnf_index
, vdu_id
, vca_deployed_list
):
4100 # TODO vdu_index_count
4101 for vca
in vca_deployed_list
:
4102 if vca
["member-vnf-index"] == vnf_index
and vca
["vdu_id"] == vdu_id
:
4105 async def destroy_N2VC(
4113 exec_primitives
=True,
4118 Execute the terminate primitives and destroy the execution environment (if destroy_ee=False
4119 :param logging_text:
4121 :param vca_deployed: Dictionary of deployment info at db_nsr._admin.depoloyed.VCA.<INDEX>
4122 :param config_descriptor: Configuration descriptor of the NSD, VNFD, VNFD.vdu or VNFD.kdu
4123 :param vca_index: index in the database _admin.deployed.VCA
4124 :param destroy_ee: False to do not destroy, because it will be destroyed all of then at once
4125 :param exec_primitives: False to do not execute terminate primitives, because the config is not completed or has
4126 not executed properly
4127 :param scaling_in: True destroys the application, False destroys the model
4128 :return: None or exception
4133 + " vca_index: {}, vca_deployed: {}, config_descriptor: {}, destroy_ee: {}".format(
4134 vca_index
, vca_deployed
, config_descriptor
, destroy_ee
4138 vca_type
= vca_deployed
.get("type", "lxc_proxy_charm")
4140 # execute terminate_primitives
4142 terminate_primitives
= get_ee_sorted_terminate_config_primitive_list(
4143 config_descriptor
.get("terminate-config-primitive"),
4144 vca_deployed
.get("ee_descriptor_id"),
4146 vdu_id
= vca_deployed
.get("vdu_id")
4147 vdu_count_index
= vca_deployed
.get("vdu_count_index")
4148 vdu_name
= vca_deployed
.get("vdu_name")
4149 vnf_index
= vca_deployed
.get("member-vnf-index")
4150 if terminate_primitives
and vca_deployed
.get("needed_terminate"):
4151 for seq
in terminate_primitives
:
4152 # For each sequence in list, get primitive and call _ns_execute_primitive()
4153 step
= "Calling terminate action for vnf_member_index={} primitive={}".format(
4154 vnf_index
, seq
.get("name")
4156 self
.logger
.debug(logging_text
+ step
)
4157 # Create the primitive for each sequence, i.e. "primitive": "touch"
4158 primitive
= seq
.get("name")
4159 mapped_primitive_params
= self
._get
_terminate
_primitive
_params
(
4164 self
._add
_suboperation
(
4171 mapped_primitive_params
,
4173 # Sub-operations: Call _ns_execute_primitive() instead of action()
4175 result
, result_detail
= await self
._ns
_execute
_primitive
(
4176 vca_deployed
["ee_id"],
4178 mapped_primitive_params
,
4182 except LcmException
:
4183 # this happens when VCA is not deployed. In this case it is not needed to terminate
4185 result_ok
= ["COMPLETED", "PARTIALLY_COMPLETED"]
4186 if result
not in result_ok
:
4188 "terminate_primitive {} for vnf_member_index={} fails with "
4189 "error {}".format(seq
.get("name"), vnf_index
, result_detail
)
4191 # set that this VCA do not need terminated
4192 db_update_entry
= "_admin.deployed.VCA.{}.needed_terminate".format(
4196 "nsrs", db_nslcmop
["nsInstanceId"], {db_update_entry
: False}
4199 # Delete Prometheus Jobs if any
4200 # This uses NSR_ID, so it will destroy any jobs under this index
4201 self
.db
.del_list("prometheus_jobs", {"nsr_id": db_nslcmop
["nsInstanceId"]})
4204 await self
.vca_map
[vca_type
].delete_execution_environment(
4205 vca_deployed
["ee_id"],
4206 scaling_in
=scaling_in
,
4211 async def _delete_all_N2VC(self
, db_nsr
: dict, vca_id
: str = None):
4212 self
._write
_all
_config
_status
(db_nsr
=db_nsr
, status
="TERMINATING")
4213 namespace
= "." + db_nsr
["_id"]
4215 await self
.n2vc
.delete_namespace(
4216 namespace
=namespace
,
4217 total_timeout
=self
.timeout_charm_delete
,
4220 except N2VCNotFound
: # already deleted. Skip
4222 self
._write
_all
_config
_status
(db_nsr
=db_nsr
, status
="DELETED")
4224 async def _terminate_RO(
4225 self
, logging_text
, nsr_deployed
, nsr_id
, nslcmop_id
, stage
4228 Terminates a deployment from RO
4229 :param logging_text:
4230 :param nsr_deployed: db_nsr._admin.deployed
4233 :param stage: list of string with the content to write on db_nslcmop.detailed-status.
4234 this method will update only the index 2, but it will write on database the concatenated content of the list
4239 ro_nsr_id
= ro_delete_action
= None
4240 if nsr_deployed
and nsr_deployed
.get("RO"):
4241 ro_nsr_id
= nsr_deployed
["RO"].get("nsr_id")
4242 ro_delete_action
= nsr_deployed
["RO"].get("nsr_delete_action_id")
4245 stage
[2] = "Deleting ns from VIM."
4246 db_nsr_update
["detailed-status"] = " ".join(stage
)
4247 self
._write
_op
_status
(nslcmop_id
, stage
)
4248 self
.logger
.debug(logging_text
+ stage
[2])
4249 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
4250 self
._write
_op
_status
(nslcmop_id
, stage
)
4251 desc
= await self
.RO
.delete("ns", ro_nsr_id
)
4252 ro_delete_action
= desc
["action_id"]
4254 "_admin.deployed.RO.nsr_delete_action_id"
4255 ] = ro_delete_action
4256 db_nsr_update
["_admin.deployed.RO.nsr_id"] = None
4257 db_nsr_update
["_admin.deployed.RO.nsr_status"] = "DELETED"
4258 if ro_delete_action
:
4259 # wait until NS is deleted from VIM
4260 stage
[2] = "Waiting ns deleted from VIM."
4261 detailed_status_old
= None
4265 + " RO_id={} ro_delete_action={}".format(
4266 ro_nsr_id
, ro_delete_action
4269 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
4270 self
._write
_op
_status
(nslcmop_id
, stage
)
4272 delete_timeout
= 20 * 60 # 20 minutes
4273 while delete_timeout
> 0:
4274 desc
= await self
.RO
.show(
4276 item_id_name
=ro_nsr_id
,
4277 extra_item
="action",
4278 extra_item_id
=ro_delete_action
,
4282 self
._on
_update
_ro
_db
(nsrs_id
=nsr_id
, ro_descriptor
=desc
)
4284 ns_status
, ns_status_info
= self
.RO
.check_action_status(desc
)
4285 if ns_status
== "ERROR":
4286 raise ROclient
.ROClientException(ns_status_info
)
4287 elif ns_status
== "BUILD":
4288 stage
[2] = "Deleting from VIM {}".format(ns_status_info
)
4289 elif ns_status
== "ACTIVE":
4290 db_nsr_update
["_admin.deployed.RO.nsr_delete_action_id"] = None
4291 db_nsr_update
["_admin.deployed.RO.nsr_status"] = "DELETED"
4296 ), "ROclient.check_action_status returns unknown {}".format(
4299 if stage
[2] != detailed_status_old
:
4300 detailed_status_old
= stage
[2]
4301 db_nsr_update
["detailed-status"] = " ".join(stage
)
4302 self
._write
_op
_status
(nslcmop_id
, stage
)
4303 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
4304 await asyncio
.sleep(5, loop
=self
.loop
)
4306 else: # delete_timeout <= 0:
4307 raise ROclient
.ROClientException(
4308 "Timeout waiting ns deleted from VIM"
4311 except Exception as e
:
4312 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
4314 isinstance(e
, ROclient
.ROClientException
) and e
.http_code
== 404
4316 db_nsr_update
["_admin.deployed.RO.nsr_id"] = None
4317 db_nsr_update
["_admin.deployed.RO.nsr_status"] = "DELETED"
4318 db_nsr_update
["_admin.deployed.RO.nsr_delete_action_id"] = None
4320 logging_text
+ "RO_ns_id={} already deleted".format(ro_nsr_id
)
4323 isinstance(e
, ROclient
.ROClientException
) and e
.http_code
== 409
4325 failed_detail
.append("delete conflict: {}".format(e
))
4328 + "RO_ns_id={} delete conflict: {}".format(ro_nsr_id
, e
)
4331 failed_detail
.append("delete error: {}".format(e
))
4333 logging_text
+ "RO_ns_id={} delete error: {}".format(ro_nsr_id
, e
)
4337 if not failed_detail
and deep_get(nsr_deployed
, ("RO", "nsd_id")):
4338 ro_nsd_id
= nsr_deployed
["RO"]["nsd_id"]
4340 stage
[2] = "Deleting nsd from RO."
4341 db_nsr_update
["detailed-status"] = " ".join(stage
)
4342 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
4343 self
._write
_op
_status
(nslcmop_id
, stage
)
4344 await self
.RO
.delete("nsd", ro_nsd_id
)
4346 logging_text
+ "ro_nsd_id={} deleted".format(ro_nsd_id
)
4348 db_nsr_update
["_admin.deployed.RO.nsd_id"] = None
4349 except Exception as e
:
4351 isinstance(e
, ROclient
.ROClientException
) and e
.http_code
== 404
4353 db_nsr_update
["_admin.deployed.RO.nsd_id"] = None
4355 logging_text
+ "ro_nsd_id={} already deleted".format(ro_nsd_id
)
4358 isinstance(e
, ROclient
.ROClientException
) and e
.http_code
== 409
4360 failed_detail
.append(
4361 "ro_nsd_id={} delete conflict: {}".format(ro_nsd_id
, e
)
4363 self
.logger
.debug(logging_text
+ failed_detail
[-1])
4365 failed_detail
.append(
4366 "ro_nsd_id={} delete error: {}".format(ro_nsd_id
, e
)
4368 self
.logger
.error(logging_text
+ failed_detail
[-1])
4370 if not failed_detail
and deep_get(nsr_deployed
, ("RO", "vnfd")):
4371 for index
, vnf_deployed
in enumerate(nsr_deployed
["RO"]["vnfd"]):
4372 if not vnf_deployed
or not vnf_deployed
["id"]:
4375 ro_vnfd_id
= vnf_deployed
["id"]
4378 ] = "Deleting member_vnf_index={} ro_vnfd_id={} from RO.".format(
4379 vnf_deployed
["member-vnf-index"], ro_vnfd_id
4381 db_nsr_update
["detailed-status"] = " ".join(stage
)
4382 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
4383 self
._write
_op
_status
(nslcmop_id
, stage
)
4384 await self
.RO
.delete("vnfd", ro_vnfd_id
)
4386 logging_text
+ "ro_vnfd_id={} deleted".format(ro_vnfd_id
)
4388 db_nsr_update
["_admin.deployed.RO.vnfd.{}.id".format(index
)] = None
4389 except Exception as e
:
4391 isinstance(e
, ROclient
.ROClientException
) and e
.http_code
== 404
4394 "_admin.deployed.RO.vnfd.{}.id".format(index
)
4398 + "ro_vnfd_id={} already deleted ".format(ro_vnfd_id
)
4401 isinstance(e
, ROclient
.ROClientException
) and e
.http_code
== 409
4403 failed_detail
.append(
4404 "ro_vnfd_id={} delete conflict: {}".format(ro_vnfd_id
, e
)
4406 self
.logger
.debug(logging_text
+ failed_detail
[-1])
4408 failed_detail
.append(
4409 "ro_vnfd_id={} delete error: {}".format(ro_vnfd_id
, e
)
4411 self
.logger
.error(logging_text
+ failed_detail
[-1])
4414 stage
[2] = "Error deleting from VIM"
4416 stage
[2] = "Deleted from VIM"
4417 db_nsr_update
["detailed-status"] = " ".join(stage
)
4418 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
4419 self
._write
_op
_status
(nslcmop_id
, stage
)
4422 raise LcmException("; ".join(failed_detail
))
4424 async def terminate(self
, nsr_id
, nslcmop_id
):
4425 # Try to lock HA task here
4426 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
4427 if not task_is_locked_by_me
:
4430 logging_text
= "Task ns={} terminate={} ".format(nsr_id
, nslcmop_id
)
4431 self
.logger
.debug(logging_text
+ "Enter")
4432 timeout_ns_terminate
= self
.timeout_ns_terminate
4435 operation_params
= None
4437 error_list
= [] # annotates all failed error messages
4438 db_nslcmop_update
= {}
4439 autoremove
= False # autoremove after terminated
4440 tasks_dict_info
= {}
4443 "Stage 1/3: Preparing task.",
4444 "Waiting for previous operations to terminate.",
4447 # ^ contains [stage, step, VIM-status]
4449 # wait for any previous tasks in process
4450 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
4452 stage
[1] = "Getting nslcmop={} from db.".format(nslcmop_id
)
4453 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
4454 operation_params
= db_nslcmop
.get("operationParams") or {}
4455 if operation_params
.get("timeout_ns_terminate"):
4456 timeout_ns_terminate
= operation_params
["timeout_ns_terminate"]
4457 stage
[1] = "Getting nsr={} from db.".format(nsr_id
)
4458 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
4460 db_nsr_update
["operational-status"] = "terminating"
4461 db_nsr_update
["config-status"] = "terminating"
4462 self
._write
_ns
_status
(
4464 ns_state
="TERMINATING",
4465 current_operation
="TERMINATING",
4466 current_operation_id
=nslcmop_id
,
4467 other_update
=db_nsr_update
,
4469 self
._write
_op
_status
(op_id
=nslcmop_id
, queuePosition
=0, stage
=stage
)
4470 nsr_deployed
= deepcopy(db_nsr
["_admin"].get("deployed")) or {}
4471 if db_nsr
["_admin"]["nsState"] == "NOT_INSTANTIATED":
4474 stage
[1] = "Getting vnf descriptors from db."
4475 db_vnfrs_list
= self
.db
.get_list("vnfrs", {"nsr-id-ref": nsr_id
})
4477 db_vnfr
["member-vnf-index-ref"]: db_vnfr
for db_vnfr
in db_vnfrs_list
4479 db_vnfds_from_id
= {}
4480 db_vnfds_from_member_index
= {}
4482 for vnfr
in db_vnfrs_list
:
4483 vnfd_id
= vnfr
["vnfd-id"]
4484 if vnfd_id
not in db_vnfds_from_id
:
4485 vnfd
= self
.db
.get_one("vnfds", {"_id": vnfd_id
})
4486 db_vnfds_from_id
[vnfd_id
] = vnfd
4487 db_vnfds_from_member_index
[
4488 vnfr
["member-vnf-index-ref"]
4489 ] = db_vnfds_from_id
[vnfd_id
]
4491 # Destroy individual execution environments when there are terminating primitives.
4492 # Rest of EE will be deleted at once
4493 # TODO - check before calling _destroy_N2VC
4494 # if not operation_params.get("skip_terminate_primitives"):#
4495 # or not vca.get("needed_terminate"):
4496 stage
[0] = "Stage 2/3 execute terminating primitives."
4497 self
.logger
.debug(logging_text
+ stage
[0])
4498 stage
[1] = "Looking execution environment that needs terminate."
4499 self
.logger
.debug(logging_text
+ stage
[1])
4501 for vca_index
, vca
in enumerate(get_iterable(nsr_deployed
, "VCA")):
4502 config_descriptor
= None
4503 vca_member_vnf_index
= vca
.get("member-vnf-index")
4504 vca_id
= self
.get_vca_id(
4505 db_vnfrs_dict
.get(vca_member_vnf_index
)
4506 if vca_member_vnf_index
4510 if not vca
or not vca
.get("ee_id"):
4512 if not vca
.get("member-vnf-index"):
4514 config_descriptor
= db_nsr
.get("ns-configuration")
4515 elif vca
.get("vdu_id"):
4516 db_vnfd
= db_vnfds_from_member_index
[vca
["member-vnf-index"]]
4517 config_descriptor
= get_configuration(db_vnfd
, vca
.get("vdu_id"))
4518 elif vca
.get("kdu_name"):
4519 db_vnfd
= db_vnfds_from_member_index
[vca
["member-vnf-index"]]
4520 config_descriptor
= get_configuration(db_vnfd
, vca
.get("kdu_name"))
4522 db_vnfd
= db_vnfds_from_member_index
[vca
["member-vnf-index"]]
4523 config_descriptor
= get_configuration(db_vnfd
, db_vnfd
["id"])
4524 vca_type
= vca
.get("type")
4525 exec_terminate_primitives
= not operation_params
.get(
4526 "skip_terminate_primitives"
4527 ) and vca
.get("needed_terminate")
4528 # For helm we must destroy_ee. Also for native_charm, as juju_model cannot be deleted if there are
4529 # pending native charms
4531 True if vca_type
in ("helm", "helm-v3", "native_charm") else False
4533 # self.logger.debug(logging_text + "vca_index: {}, ee_id: {}, vca_type: {} destroy_ee: {}".format(
4534 # vca_index, vca.get("ee_id"), vca_type, destroy_ee))
4535 task
= asyncio
.ensure_future(
4543 exec_terminate_primitives
,
4547 tasks_dict_info
[task
] = "Terminating VCA {}".format(vca
.get("ee_id"))
4549 # wait for pending tasks of terminate primitives
4553 + "Waiting for tasks {}".format(list(tasks_dict_info
.keys()))
4555 error_list
= await self
._wait
_for
_tasks
(
4558 min(self
.timeout_charm_delete
, timeout_ns_terminate
),
4562 tasks_dict_info
.clear()
4564 return # raise LcmException("; ".join(error_list))
4566 # remove All execution environments at once
4567 stage
[0] = "Stage 3/3 delete all."
4569 if nsr_deployed
.get("VCA"):
4570 stage
[1] = "Deleting all execution environments."
4571 self
.logger
.debug(logging_text
+ stage
[1])
4572 vca_id
= self
.get_vca_id({}, db_nsr
)
4573 task_delete_ee
= asyncio
.ensure_future(
4575 self
._delete
_all
_N
2VC
(db_nsr
=db_nsr
, vca_id
=vca_id
),
4576 timeout
=self
.timeout_charm_delete
,
4579 # task_delete_ee = asyncio.ensure_future(self.n2vc.delete_namespace(namespace="." + nsr_id))
4580 tasks_dict_info
[task_delete_ee
] = "Terminating all VCA"
4582 # Delete from k8scluster
4583 stage
[1] = "Deleting KDUs."
4584 self
.logger
.debug(logging_text
+ stage
[1])
4585 # print(nsr_deployed)
4586 for kdu
in get_iterable(nsr_deployed
, "K8s"):
4587 if not kdu
or not kdu
.get("kdu-instance"):
4589 kdu_instance
= kdu
.get("kdu-instance")
4590 if kdu
.get("k8scluster-type") in self
.k8scluster_map
:
4591 # TODO: Uninstall kdu instances taking into account they could be deployed in different VIMs
4592 vca_id
= self
.get_vca_id({}, db_nsr
)
4593 task_delete_kdu_instance
= asyncio
.ensure_future(
4594 self
.k8scluster_map
[kdu
["k8scluster-type"]].uninstall(
4595 cluster_uuid
=kdu
.get("k8scluster-uuid"),
4596 kdu_instance
=kdu_instance
,
4598 namespace
=kdu
.get("namespace"),
4604 + "Unknown k8s deployment type {}".format(
4605 kdu
.get("k8scluster-type")
4610 task_delete_kdu_instance
4611 ] = "Terminating KDU '{}'".format(kdu
.get("kdu-name"))
4614 stage
[1] = "Deleting ns from VIM."
4616 task_delete_ro
= asyncio
.ensure_future(
4617 self
._terminate
_ng
_ro
(
4618 logging_text
, nsr_deployed
, nsr_id
, nslcmop_id
, stage
4622 task_delete_ro
= asyncio
.ensure_future(
4624 logging_text
, nsr_deployed
, nsr_id
, nslcmop_id
, stage
4627 tasks_dict_info
[task_delete_ro
] = "Removing deployment from VIM"
4629 # rest of staff will be done at finally
4632 ROclient
.ROClientException
,
4637 self
.logger
.error(logging_text
+ "Exit Exception {}".format(e
))
4639 except asyncio
.CancelledError
:
4641 logging_text
+ "Cancelled Exception while '{}'".format(stage
[1])
4643 exc
= "Operation was cancelled"
4644 except Exception as e
:
4645 exc
= traceback
.format_exc()
4646 self
.logger
.critical(
4647 logging_text
+ "Exit Exception while '{}': {}".format(stage
[1], e
),
4652 error_list
.append(str(exc
))
4654 # wait for pending tasks
4656 stage
[1] = "Waiting for terminate pending tasks."
4657 self
.logger
.debug(logging_text
+ stage
[1])
4658 error_list
+= await self
._wait
_for
_tasks
(
4661 timeout_ns_terminate
,
4665 stage
[1] = stage
[2] = ""
4666 except asyncio
.CancelledError
:
4667 error_list
.append("Cancelled")
4668 # TODO cancell all tasks
4669 except Exception as exc
:
4670 error_list
.append(str(exc
))
4671 # update status at database
4673 error_detail
= "; ".join(error_list
)
4674 # self.logger.error(logging_text + error_detail)
4675 error_description_nslcmop
= "{} Detail: {}".format(
4676 stage
[0], error_detail
4678 error_description_nsr
= "Operation: TERMINATING.{}, {}.".format(
4679 nslcmop_id
, stage
[0]
4682 db_nsr_update
["operational-status"] = "failed"
4683 db_nsr_update
["detailed-status"] = (
4684 error_description_nsr
+ " Detail: " + error_detail
4686 db_nslcmop_update
["detailed-status"] = error_detail
4687 nslcmop_operation_state
= "FAILED"
4691 error_description_nsr
= error_description_nslcmop
= None
4692 ns_state
= "NOT_INSTANTIATED"
4693 db_nsr_update
["operational-status"] = "terminated"
4694 db_nsr_update
["detailed-status"] = "Done"
4695 db_nsr_update
["_admin.nsState"] = "NOT_INSTANTIATED"
4696 db_nslcmop_update
["detailed-status"] = "Done"
4697 nslcmop_operation_state
= "COMPLETED"
4700 self
._write
_ns
_status
(
4703 current_operation
="IDLE",
4704 current_operation_id
=None,
4705 error_description
=error_description_nsr
,
4706 error_detail
=error_detail
,
4707 other_update
=db_nsr_update
,
4709 self
._write
_op
_status
(
4712 error_message
=error_description_nslcmop
,
4713 operation_state
=nslcmop_operation_state
,
4714 other_update
=db_nslcmop_update
,
4716 if ns_state
== "NOT_INSTANTIATED":
4720 {"nsr-id-ref": nsr_id
},
4721 {"_admin.nsState": "NOT_INSTANTIATED"},
4723 except DbException
as e
:
4726 + "Error writing VNFR status for nsr-id-ref: {} -> {}".format(
4730 if operation_params
:
4731 autoremove
= operation_params
.get("autoremove", False)
4732 if nslcmop_operation_state
:
4734 await self
.msg
.aiowrite(
4739 "nslcmop_id": nslcmop_id
,
4740 "operationState": nslcmop_operation_state
,
4741 "autoremove": autoremove
,
4745 except Exception as e
:
4747 logging_text
+ "kafka_write notification Exception {}".format(e
)
4750 self
.logger
.debug(logging_text
+ "Exit")
4751 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_terminate")
4753 async def _wait_for_tasks(
4754 self
, logging_text
, created_tasks_info
, timeout
, stage
, nslcmop_id
, nsr_id
=None
4757 error_detail_list
= []
4759 pending_tasks
= list(created_tasks_info
.keys())
4760 num_tasks
= len(pending_tasks
)
4762 stage
[1] = "{}/{}.".format(num_done
, num_tasks
)
4763 self
._write
_op
_status
(nslcmop_id
, stage
)
4764 while pending_tasks
:
4766 _timeout
= timeout
+ time_start
- time()
4767 done
, pending_tasks
= await asyncio
.wait(
4768 pending_tasks
, timeout
=_timeout
, return_when
=asyncio
.FIRST_COMPLETED
4770 num_done
+= len(done
)
4771 if not done
: # Timeout
4772 for task
in pending_tasks
:
4773 new_error
= created_tasks_info
[task
] + ": Timeout"
4774 error_detail_list
.append(new_error
)
4775 error_list
.append(new_error
)
4778 if task
.cancelled():
4781 exc
= task
.exception()
4783 if isinstance(exc
, asyncio
.TimeoutError
):
4785 new_error
= created_tasks_info
[task
] + ": {}".format(exc
)
4786 error_list
.append(created_tasks_info
[task
])
4787 error_detail_list
.append(new_error
)
4794 ROclient
.ROClientException
,
4800 self
.logger
.error(logging_text
+ new_error
)
4802 exc_traceback
= "".join(
4803 traceback
.format_exception(None, exc
, exc
.__traceback
__)
4807 + created_tasks_info
[task
]
4813 logging_text
+ created_tasks_info
[task
] + ": Done"
4815 stage
[1] = "{}/{}.".format(num_done
, num_tasks
)
4817 stage
[1] += " Errors: " + ". ".join(error_detail_list
) + "."
4818 if nsr_id
: # update also nsr
4823 "errorDescription": "Error at: " + ", ".join(error_list
),
4824 "errorDetail": ". ".join(error_detail_list
),
4827 self
._write
_op
_status
(nslcmop_id
, stage
)
4828 return error_detail_list
4831 def _map_primitive_params(primitive_desc
, params
, instantiation_params
):
4833 Generates the params to be provided to charm before executing primitive. If user does not provide a parameter,
4834 The default-value is used. If it is between < > it look for a value at instantiation_params
4835 :param primitive_desc: portion of VNFD/NSD that describes primitive
4836 :param params: Params provided by user
4837 :param instantiation_params: Instantiation params provided by user
4838 :return: a dictionary with the calculated params
4840 calculated_params
= {}
4841 for parameter
in primitive_desc
.get("parameter", ()):
4842 param_name
= parameter
["name"]
4843 if param_name
in params
:
4844 calculated_params
[param_name
] = params
[param_name
]
4845 elif "default-value" in parameter
or "value" in parameter
:
4846 if "value" in parameter
:
4847 calculated_params
[param_name
] = parameter
["value"]
4849 calculated_params
[param_name
] = parameter
["default-value"]
4851 isinstance(calculated_params
[param_name
], str)
4852 and calculated_params
[param_name
].startswith("<")
4853 and calculated_params
[param_name
].endswith(">")
4855 if calculated_params
[param_name
][1:-1] in instantiation_params
:
4856 calculated_params
[param_name
] = instantiation_params
[
4857 calculated_params
[param_name
][1:-1]
4861 "Parameter {} needed to execute primitive {} not provided".format(
4862 calculated_params
[param_name
], primitive_desc
["name"]
4867 "Parameter {} needed to execute primitive {} not provided".format(
4868 param_name
, primitive_desc
["name"]
4872 if isinstance(calculated_params
[param_name
], (dict, list, tuple)):
4873 calculated_params
[param_name
] = yaml
.safe_dump(
4874 calculated_params
[param_name
], default_flow_style
=True, width
=256
4876 elif isinstance(calculated_params
[param_name
], str) and calculated_params
[
4878 ].startswith("!!yaml "):
4879 calculated_params
[param_name
] = calculated_params
[param_name
][7:]
4880 if parameter
.get("data-type") == "INTEGER":
4882 calculated_params
[param_name
] = int(calculated_params
[param_name
])
4883 except ValueError: # error converting string to int
4885 "Parameter {} of primitive {} must be integer".format(
4886 param_name
, primitive_desc
["name"]
4889 elif parameter
.get("data-type") == "BOOLEAN":
4890 calculated_params
[param_name
] = not (
4891 (str(calculated_params
[param_name
])).lower() == "false"
4894 # add always ns_config_info if primitive name is config
4895 if primitive_desc
["name"] == "config":
4896 if "ns_config_info" in instantiation_params
:
4897 calculated_params
["ns_config_info"] = instantiation_params
[
4900 return calculated_params
4902 def _look_for_deployed_vca(
4909 ee_descriptor_id
=None,
4911 # find vca_deployed record for this action. Raise LcmException if not found or there is not any id.
4912 for vca
in deployed_vca
:
4915 if member_vnf_index
!= vca
["member-vnf-index"] or vdu_id
!= vca
["vdu_id"]:
4918 vdu_count_index
is not None
4919 and vdu_count_index
!= vca
["vdu_count_index"]
4922 if kdu_name
and kdu_name
!= vca
["kdu_name"]:
4924 if ee_descriptor_id
and ee_descriptor_id
!= vca
["ee_descriptor_id"]:
4928 # vca_deployed not found
4930 "charm for member_vnf_index={} vdu_id={}.{} kdu_name={} execution-environment-list.id={}"
4931 " is not deployed".format(
4940 ee_id
= vca
.get("ee_id")
4942 "type", "lxc_proxy_charm"
4943 ) # default value for backward compatibility - proxy charm
4946 "charm for member_vnf_index={} vdu_id={} kdu_name={} vdu_count_index={} has not "
4947 "execution environment".format(
4948 member_vnf_index
, vdu_id
, kdu_name
, vdu_count_index
4951 return ee_id
, vca_type
4953 async def _ns_execute_primitive(
4959 retries_interval
=30,
4966 if primitive
== "config":
4967 primitive_params
= {"params": primitive_params
}
4969 vca_type
= vca_type
or "lxc_proxy_charm"
4973 output
= await asyncio
.wait_for(
4974 self
.vca_map
[vca_type
].exec_primitive(
4976 primitive_name
=primitive
,
4977 params_dict
=primitive_params
,
4978 progress_timeout
=self
.timeout_progress_primitive
,
4979 total_timeout
=self
.timeout_primitive
,
4984 timeout
=timeout
or self
.timeout_primitive
,
4988 except asyncio
.CancelledError
:
4990 except Exception as e
: # asyncio.TimeoutError
4991 if isinstance(e
, asyncio
.TimeoutError
):
4996 "Error executing action {} on {} -> {}".format(
5001 await asyncio
.sleep(retries_interval
, loop
=self
.loop
)
5003 return "FAILED", str(e
)
5005 return "COMPLETED", output
5007 except (LcmException
, asyncio
.CancelledError
):
5009 except Exception as e
:
5010 return "FAIL", "Error executing action {}: {}".format(primitive
, e
)
5012 async def vca_status_refresh(self
, nsr_id
, nslcmop_id
):
5014 Updating the vca_status with latest juju information in nsrs record
5015 :param: nsr_id: Id of the nsr
5016 :param: nslcmop_id: Id of the nslcmop
5020 self
.logger
.debug("Task ns={} action={} Enter".format(nsr_id
, nslcmop_id
))
5021 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
5022 vca_id
= self
.get_vca_id({}, db_nsr
)
5023 if db_nsr
["_admin"]["deployed"]["K8s"]:
5024 for _
, k8s
in enumerate(db_nsr
["_admin"]["deployed"]["K8s"]):
5025 cluster_uuid
, kdu_instance
, cluster_type
= (
5026 k8s
["k8scluster-uuid"],
5027 k8s
["kdu-instance"],
5028 k8s
["k8scluster-type"],
5030 await self
._on
_update
_k
8s
_db
(
5031 cluster_uuid
=cluster_uuid
,
5032 kdu_instance
=kdu_instance
,
5033 filter={"_id": nsr_id
},
5035 cluster_type
=cluster_type
,
5038 for vca_index
, _
in enumerate(db_nsr
["_admin"]["deployed"]["VCA"]):
5039 table
, filter = "nsrs", {"_id": nsr_id
}
5040 path
= "_admin.deployed.VCA.{}.".format(vca_index
)
5041 await self
._on
_update
_n
2vc
_db
(table
, filter, path
, {})
5043 self
.logger
.debug("Task ns={} action={} Exit".format(nsr_id
, nslcmop_id
))
5044 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_vca_status_refresh")
5046 async def action(self
, nsr_id
, nslcmop_id
):
5047 # Try to lock HA task here
5048 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
5049 if not task_is_locked_by_me
:
5052 logging_text
= "Task ns={} action={} ".format(nsr_id
, nslcmop_id
)
5053 self
.logger
.debug(logging_text
+ "Enter")
5054 # get all needed from database
5058 db_nslcmop_update
= {}
5059 nslcmop_operation_state
= None
5060 error_description_nslcmop
= None
5063 # wait for any previous tasks in process
5064 step
= "Waiting for previous operations to terminate"
5065 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
5067 self
._write
_ns
_status
(
5070 current_operation
="RUNNING ACTION",
5071 current_operation_id
=nslcmop_id
,
5074 step
= "Getting information from database"
5075 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
5076 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
5077 if db_nslcmop
["operationParams"].get("primitive_params"):
5078 db_nslcmop
["operationParams"]["primitive_params"] = json
.loads(
5079 db_nslcmop
["operationParams"]["primitive_params"]
5082 nsr_deployed
= db_nsr
["_admin"].get("deployed")
5083 vnf_index
= db_nslcmop
["operationParams"].get("member_vnf_index")
5084 vdu_id
= db_nslcmop
["operationParams"].get("vdu_id")
5085 kdu_name
= db_nslcmop
["operationParams"].get("kdu_name")
5086 vdu_count_index
= db_nslcmop
["operationParams"].get("vdu_count_index")
5087 primitive
= db_nslcmop
["operationParams"]["primitive"]
5088 primitive_params
= db_nslcmop
["operationParams"]["primitive_params"]
5089 timeout_ns_action
= db_nslcmop
["operationParams"].get(
5090 "timeout_ns_action", self
.timeout_primitive
5094 step
= "Getting vnfr from database"
5095 db_vnfr
= self
.db
.get_one(
5096 "vnfrs", {"member-vnf-index-ref": vnf_index
, "nsr-id-ref": nsr_id
}
5098 if db_vnfr
.get("kdur"):
5100 for kdur
in db_vnfr
["kdur"]:
5101 if kdur
.get("additionalParams"):
5102 kdur
["additionalParams"] = json
.loads(
5103 kdur
["additionalParams"]
5105 kdur_list
.append(kdur
)
5106 db_vnfr
["kdur"] = kdur_list
5107 step
= "Getting vnfd from database"
5108 db_vnfd
= self
.db
.get_one("vnfds", {"_id": db_vnfr
["vnfd-id"]})
5110 # Sync filesystem before running a primitive
5111 self
.fs
.sync(db_vnfr
["vnfd-id"])
5113 step
= "Getting nsd from database"
5114 db_nsd
= self
.db
.get_one("nsds", {"_id": db_nsr
["nsd-id"]})
5116 vca_id
= self
.get_vca_id(db_vnfr
, db_nsr
)
5117 # for backward compatibility
5118 if nsr_deployed
and isinstance(nsr_deployed
.get("VCA"), dict):
5119 nsr_deployed
["VCA"] = list(nsr_deployed
["VCA"].values())
5120 db_nsr_update
["_admin.deployed.VCA"] = nsr_deployed
["VCA"]
5121 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
5123 # look for primitive
5124 config_primitive_desc
= descriptor_configuration
= None
5126 descriptor_configuration
= get_configuration(db_vnfd
, vdu_id
)
5128 descriptor_configuration
= get_configuration(db_vnfd
, kdu_name
)
5130 descriptor_configuration
= get_configuration(db_vnfd
, db_vnfd
["id"])
5132 descriptor_configuration
= db_nsd
.get("ns-configuration")
5134 if descriptor_configuration
and descriptor_configuration
.get(
5137 for config_primitive
in descriptor_configuration
["config-primitive"]:
5138 if config_primitive
["name"] == primitive
:
5139 config_primitive_desc
= config_primitive
5142 if not config_primitive_desc
:
5143 if not (kdu_name
and primitive
in ("upgrade", "rollback", "status")):
5145 "Primitive {} not found at [ns|vnf|vdu]-configuration:config-primitive ".format(
5149 primitive_name
= primitive
5150 ee_descriptor_id
= None
5152 primitive_name
= config_primitive_desc
.get(
5153 "execution-environment-primitive", primitive
5155 ee_descriptor_id
= config_primitive_desc
.get(
5156 "execution-environment-ref"
5162 (x
for x
in db_vnfr
["vdur"] if x
["vdu-id-ref"] == vdu_id
), None
5164 desc_params
= parse_yaml_strings(vdur
.get("additionalParams"))
5167 (x
for x
in db_vnfr
["kdur"] if x
["kdu-name"] == kdu_name
), None
5169 desc_params
= parse_yaml_strings(kdur
.get("additionalParams"))
5171 desc_params
= parse_yaml_strings(
5172 db_vnfr
.get("additionalParamsForVnf")
5175 desc_params
= parse_yaml_strings(db_nsr
.get("additionalParamsForNs"))
5176 if kdu_name
and get_configuration(db_vnfd
, kdu_name
):
5177 kdu_configuration
= get_configuration(db_vnfd
, kdu_name
)
5179 for primitive
in kdu_configuration
.get("initial-config-primitive", []):
5180 actions
.add(primitive
["name"])
5181 for primitive
in kdu_configuration
.get("config-primitive", []):
5182 actions
.add(primitive
["name"])
5184 nsr_deployed
["K8s"],
5185 lambda kdu
: kdu_name
== kdu
["kdu-name"]
5186 and kdu
["member-vnf-index"] == vnf_index
,
5190 if primitive_name
in actions
5191 and kdu
["k8scluster-type"] not in ("helm-chart", "helm-chart-v3")
5195 # TODO check if ns is in a proper status
5197 primitive_name
in ("upgrade", "rollback", "status") or kdu_action
5199 # kdur and desc_params already set from before
5200 if primitive_params
:
5201 desc_params
.update(primitive_params
)
5202 # TODO Check if we will need something at vnf level
5203 for index
, kdu
in enumerate(get_iterable(nsr_deployed
, "K8s")):
5205 kdu_name
== kdu
["kdu-name"]
5206 and kdu
["member-vnf-index"] == vnf_index
5211 "KDU '{}' for vnf '{}' not deployed".format(kdu_name
, vnf_index
)
5214 if kdu
.get("k8scluster-type") not in self
.k8scluster_map
:
5215 msg
= "unknown k8scluster-type '{}'".format(
5216 kdu
.get("k8scluster-type")
5218 raise LcmException(msg
)
5221 "collection": "nsrs",
5222 "filter": {"_id": nsr_id
},
5223 "path": "_admin.deployed.K8s.{}".format(index
),
5227 + "Exec k8s {} on {}.{}".format(primitive_name
, vnf_index
, kdu_name
)
5229 step
= "Executing kdu {}".format(primitive_name
)
5230 if primitive_name
== "upgrade":
5231 if desc_params
.get("kdu_model"):
5232 kdu_model
= desc_params
.get("kdu_model")
5233 del desc_params
["kdu_model"]
5235 kdu_model
= kdu
.get("kdu-model")
5236 parts
= kdu_model
.split(sep
=":")
5238 kdu_model
= parts
[0]
5240 detailed_status
= await asyncio
.wait_for(
5241 self
.k8scluster_map
[kdu
["k8scluster-type"]].upgrade(
5242 cluster_uuid
=kdu
.get("k8scluster-uuid"),
5243 kdu_instance
=kdu
.get("kdu-instance"),
5245 kdu_model
=kdu_model
,
5248 timeout
=timeout_ns_action
,
5250 timeout
=timeout_ns_action
+ 10,
5253 logging_text
+ " Upgrade of kdu {} done".format(detailed_status
)
5255 elif primitive_name
== "rollback":
5256 detailed_status
= await asyncio
.wait_for(
5257 self
.k8scluster_map
[kdu
["k8scluster-type"]].rollback(
5258 cluster_uuid
=kdu
.get("k8scluster-uuid"),
5259 kdu_instance
=kdu
.get("kdu-instance"),
5262 timeout
=timeout_ns_action
,
5264 elif primitive_name
== "status":
5265 detailed_status
= await asyncio
.wait_for(
5266 self
.k8scluster_map
[kdu
["k8scluster-type"]].status_kdu(
5267 cluster_uuid
=kdu
.get("k8scluster-uuid"),
5268 kdu_instance
=kdu
.get("kdu-instance"),
5271 timeout
=timeout_ns_action
,
5274 kdu_instance
= kdu
.get("kdu-instance") or "{}-{}".format(
5275 kdu
["kdu-name"], nsr_id
5277 params
= self
._map
_primitive
_params
(
5278 config_primitive_desc
, primitive_params
, desc_params
5281 detailed_status
= await asyncio
.wait_for(
5282 self
.k8scluster_map
[kdu
["k8scluster-type"]].exec_primitive(
5283 cluster_uuid
=kdu
.get("k8scluster-uuid"),
5284 kdu_instance
=kdu_instance
,
5285 primitive_name
=primitive_name
,
5288 timeout
=timeout_ns_action
,
5291 timeout
=timeout_ns_action
,
5295 nslcmop_operation_state
= "COMPLETED"
5297 detailed_status
= ""
5298 nslcmop_operation_state
= "FAILED"
5300 ee_id
, vca_type
= self
._look
_for
_deployed
_vca
(
5301 nsr_deployed
["VCA"],
5302 member_vnf_index
=vnf_index
,
5304 vdu_count_index
=vdu_count_index
,
5305 ee_descriptor_id
=ee_descriptor_id
,
5307 for vca_index
, vca_deployed
in enumerate(
5308 db_nsr
["_admin"]["deployed"]["VCA"]
5310 if vca_deployed
.get("member-vnf-index") == vnf_index
:
5312 "collection": "nsrs",
5313 "filter": {"_id": nsr_id
},
5314 "path": "_admin.deployed.VCA.{}.".format(vca_index
),
5318 nslcmop_operation_state
,
5320 ) = await self
._ns
_execute
_primitive
(
5322 primitive
=primitive_name
,
5323 primitive_params
=self
._map
_primitive
_params
(
5324 config_primitive_desc
, primitive_params
, desc_params
5326 timeout
=timeout_ns_action
,
5332 db_nslcmop_update
["detailed-status"] = detailed_status
5333 error_description_nslcmop
= (
5334 detailed_status
if nslcmop_operation_state
== "FAILED" else ""
5338 + " task Done with result {} {}".format(
5339 nslcmop_operation_state
, detailed_status
5342 return # database update is called inside finally
5344 except (DbException
, LcmException
, N2VCException
, K8sException
) as e
:
5345 self
.logger
.error(logging_text
+ "Exit Exception {}".format(e
))
5347 except asyncio
.CancelledError
:
5349 logging_text
+ "Cancelled Exception while '{}'".format(step
)
5351 exc
= "Operation was cancelled"
5352 except asyncio
.TimeoutError
:
5353 self
.logger
.error(logging_text
+ "Timeout while '{}'".format(step
))
5355 except Exception as e
:
5356 exc
= traceback
.format_exc()
5357 self
.logger
.critical(
5358 logging_text
+ "Exit Exception {} {}".format(type(e
).__name
__, e
),
5367 ) = error_description_nslcmop
= "FAILED {}: {}".format(step
, exc
)
5368 nslcmop_operation_state
= "FAILED"
5370 self
._write
_ns
_status
(
5374 ], # TODO check if degraded. For the moment use previous status
5375 current_operation
="IDLE",
5376 current_operation_id
=None,
5377 # error_description=error_description_nsr,
5378 # error_detail=error_detail,
5379 other_update
=db_nsr_update
,
5382 self
._write
_op
_status
(
5385 error_message
=error_description_nslcmop
,
5386 operation_state
=nslcmop_operation_state
,
5387 other_update
=db_nslcmop_update
,
5390 if nslcmop_operation_state
:
5392 await self
.msg
.aiowrite(
5397 "nslcmop_id": nslcmop_id
,
5398 "operationState": nslcmop_operation_state
,
5402 except Exception as e
:
5404 logging_text
+ "kafka_write notification Exception {}".format(e
)
5406 self
.logger
.debug(logging_text
+ "Exit")
5407 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_action")
5408 return nslcmop_operation_state
, detailed_status
5410 async def terminate_vdus(
5411 self
, db_vnfr
, member_vnf_index
, db_nsr
, update_db_nslcmops
, stage
, logging_text
5413 """This method terminates VDUs
5416 db_vnfr: VNF instance record
5417 member_vnf_index: VNF index to identify the VDUs to be removed
5418 db_nsr: NS instance record
5419 update_db_nslcmops: Nslcmop update record
5421 vca_scaling_info
= []
5422 scaling_info
= {"scaling_group_name": "vdu_autoscale", "vdu": [], "kdu": []}
5423 scaling_info
["scaling_direction"] = "IN"
5424 scaling_info
["vdu-delete"] = {}
5425 scaling_info
["kdu-delete"] = {}
5426 db_vdur
= db_vnfr
.get("vdur")
5427 vdur_list
= copy(db_vdur
)
5429 for index
, vdu
in enumerate(vdur_list
):
5430 vca_scaling_info
.append(
5432 "osm_vdu_id": vdu
["vdu-id-ref"],
5433 "member-vnf-index": member_vnf_index
,
5435 "vdu_index": count_index
,
5437 scaling_info
["vdu-delete"][vdu
["vdu-id-ref"]] = count_index
5438 scaling_info
["vdu"].append(
5440 "name": vdu
.get("name") or vdu
.get("vdu-name"),
5441 "vdu_id": vdu
["vdu-id-ref"],
5444 for interface
in vdu
["interfaces"]:
5445 scaling_info
["vdu"][index
]["interface"].append(
5447 "name": interface
["name"],
5448 "ip_address": interface
["ip-address"],
5449 "mac_address": interface
.get("mac-address"),
5451 self
.logger
.info("NS update scaling info{}".format(scaling_info
))
5452 stage
[2] = "Terminating VDUs"
5453 if scaling_info
.get("vdu-delete"):
5454 # scale_process = "RO"
5455 if self
.ro_config
.get("ng"):
5456 await self
._scale
_ng
_ro
(
5457 logging_text
, db_nsr
, update_db_nslcmops
, db_vnfr
, scaling_info
, stage
5460 async def remove_vnf(
5461 self
, nsr_id
, nslcmop_id
, vnf_instance_id
5463 """This method is to Remove VNF instances from NS.
5466 nsr_id: NS instance id
5467 nslcmop_id: nslcmop id of update
5468 vnf_instance_id: id of the VNF instance to be removed
5471 result: (str, str) COMPLETED/FAILED, details
5475 logging_text
= "Task ns={} update ".format(nsr_id
)
5476 check_vnfr_count
= len(self
.db
.get_list("vnfrs", {"nsr-id-ref": nsr_id
}))
5477 self
.logger
.info("check_vnfr_count {}".format(check_vnfr_count
))
5478 if check_vnfr_count
> 1:
5479 stage
= ["", "", ""]
5480 step
= "Getting nslcmop from database"
5481 self
.logger
.debug(step
+ " after having waited for previous tasks to be completed")
5482 # db_nslcmop = self.db.get_one("nslcmops", {"_id": nslcmop_id})
5483 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
5484 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnf_instance_id
})
5485 member_vnf_index
= db_vnfr
["member-vnf-index-ref"]
5486 """ db_vnfr = self.db.get_one(
5487 "vnfrs", {"member-vnf-index-ref": member_vnf_index, "nsr-id-ref": nsr_id}) """
5489 update_db_nslcmops
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
5490 await self
.terminate_vdus(db_vnfr
, member_vnf_index
, db_nsr
, update_db_nslcmops
, stage
, logging_text
)
5492 constituent_vnfr
= db_nsr
.get("constituent-vnfr-ref")
5493 constituent_vnfr
.remove(db_vnfr
.get("_id"))
5494 db_nsr_update
["constituent-vnfr-ref"] = db_nsr
.get("constituent-vnfr-ref")
5495 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
5496 self
.db
.del_one("vnfrs", {"_id": db_vnfr
.get("_id")})
5497 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
5498 return "COMPLETED", "Done"
5500 step
= "Terminate VNF Failed with"
5501 raise LcmException("{} Cannot terminate the last VNF in this NS.".format(
5503 except (LcmException
, asyncio
.CancelledError
):
5505 except Exception as e
:
5506 self
.logger
.debug("Error removing VNF {}".format(e
))
5507 return "FAILED", "Error removing VNF {}".format(e
)
5509 async def _ns_redeploy_vnf(
5510 self
, nsr_id
, nslcmop_id
, db_vnfd
, db_vnfr
, db_nsr
,
5512 """This method updates and redeploys VNF instances
5515 nsr_id: NS instance id
5516 nslcmop_id: nslcmop id
5517 db_vnfd: VNF descriptor
5518 db_vnfr: VNF instance record
5519 db_nsr: NS instance record
5522 result: (str, str) COMPLETED/FAILED, details
5526 stage
= ["", "", ""]
5527 logging_text
= "Task ns={} update ".format(nsr_id
)
5528 latest_vnfd_revision
= db_vnfd
["_admin"].get("revision")
5529 member_vnf_index
= db_vnfr
["member-vnf-index-ref"]
5531 # Terminate old VNF resources
5532 update_db_nslcmops
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
5533 await self
.terminate_vdus(db_vnfr
, member_vnf_index
, db_nsr
, update_db_nslcmops
, stage
, logging_text
)
5535 # old_vnfd_id = db_vnfr["vnfd-id"]
5536 # new_db_vnfd = self.db.get_one("vnfds", {"_id": vnfd_id})
5537 new_db_vnfd
= db_vnfd
5538 # new_vnfd_ref = new_db_vnfd["id"]
5539 # new_vnfd_id = vnfd_id
5543 for cp
in new_db_vnfd
.get("ext-cpd", ()):
5545 "name": cp
.get("id"),
5546 "connection-point-id": cp
.get("int-cpd", {}).get("cpd"),
5547 "connection-point-vdu-id": cp
.get("int-cpd", {}).get("vdu-id"),
5550 new_vnfr_cp
.append(vnf_cp
)
5551 new_vdur
= update_db_nslcmops
["operationParams"]["newVdur"]
5552 # new_vdur = self._create_vdur_descriptor_from_vnfd(db_nsd, db_vnfd, old_db_vnfd, vnfd_id, db_nsr, member_vnf_index)
5553 # new_vnfr_update = {"vnfd-ref": new_vnfd_ref, "vnfd-id": new_vnfd_id, "connection-point": new_vnfr_cp, "vdur": new_vdur, "ip-address": ""}
5554 new_vnfr_update
= {"revision": latest_vnfd_revision
, "connection-point": new_vnfr_cp
, "vdur": new_vdur
, "ip-address": ""}
5555 self
.update_db_2("vnfrs", db_vnfr
["_id"], new_vnfr_update
)
5556 updated_db_vnfr
= self
.db
.get_one(
5557 "vnfrs", {"member-vnf-index-ref": member_vnf_index
, "nsr-id-ref": nsr_id
}
5560 # Instantiate new VNF resources
5561 # update_db_nslcmops = self.db.get_one("nslcmops", {"_id": nslcmop_id})
5562 vca_scaling_info
= []
5563 scaling_info
= {"scaling_group_name": "vdu_autoscale", "vdu": [], "kdu": []}
5564 scaling_info
["scaling_direction"] = "OUT"
5565 scaling_info
["vdu-create"] = {}
5566 scaling_info
["kdu-create"] = {}
5567 vdud_instantiate_list
= db_vnfd
["vdu"]
5568 for index
, vdud
in enumerate(vdud_instantiate_list
):
5569 cloud_init_text
= self
._get
_vdu
_cloud
_init
_content
(
5573 additional_params
= (
5574 self
._get
_vdu
_additional
_params
(updated_db_vnfr
, vdud
["id"])
5577 cloud_init_list
= []
5579 # TODO Information of its own ip is not available because db_vnfr is not updated.
5580 additional_params
["OSM"] = get_osm_params(
5581 updated_db_vnfr
, vdud
["id"], 1
5583 cloud_init_list
.append(
5584 self
._parse
_cloud
_init
(
5591 vca_scaling_info
.append(
5593 "osm_vdu_id": vdud
["id"],
5594 "member-vnf-index": member_vnf_index
,
5596 "vdu_index": count_index
,
5599 scaling_info
["vdu-create"][vdud
["id"]] = count_index
5600 if self
.ro_config
.get("ng"):
5602 "New Resources to be deployed: {}".format(scaling_info
))
5603 await self
._scale
_ng
_ro
(
5604 logging_text
, db_nsr
, update_db_nslcmops
, updated_db_vnfr
, scaling_info
, stage
5606 return "COMPLETED", "Done"
5607 except (LcmException
, asyncio
.CancelledError
):
5609 except Exception as e
:
5610 self
.logger
.debug("Error updating VNF {}".format(e
))
5611 return "FAILED", "Error updating VNF {}".format(e
)
5613 async def _ns_charm_upgrade(
5619 timeout
: float = None,
5621 """This method upgrade charms in VNF instances
5624 ee_id: Execution environment id
5625 path: Local path to the charm
5627 charm_type: Charm type can be lxc-proxy-charm, native-charm or k8s-proxy-charm
5628 timeout: (Float) Timeout for the ns update operation
5631 result: (str, str) COMPLETED/FAILED, details
5634 charm_type
= charm_type
or "lxc_proxy_charm"
5635 output
= await self
.vca_map
[charm_type
].upgrade_charm(
5639 charm_type
=charm_type
,
5640 timeout
=timeout
or self
.timeout_ns_update
,
5644 return "COMPLETED", output
5646 except (LcmException
, asyncio
.CancelledError
):
5649 except Exception as e
:
5651 self
.logger
.debug("Error upgrading charm {}".format(path
))
5653 return "FAILED", "Error upgrading charm {}: {}".format(path
, e
)
5655 async def update(self
, nsr_id
, nslcmop_id
):
5656 """Update NS according to different update types
5658 This method performs upgrade of VNF instances then updates the revision
5659 number in VNF record
5662 nsr_id: Network service will be updated
5663 nslcmop_id: ns lcm operation id
5666 It may raise DbException, LcmException, N2VCException, K8sException
5669 # Try to lock HA task here
5670 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
5671 if not task_is_locked_by_me
:
5674 logging_text
= "Task ns={} update={} ".format(nsr_id
, nslcmop_id
)
5675 self
.logger
.debug(logging_text
+ "Enter")
5677 # Set the required variables to be filled up later
5679 db_nslcmop_update
= {}
5681 nslcmop_operation_state
= None
5683 error_description_nslcmop
= ""
5685 change_type
= "updated"
5686 detailed_status
= ""
5689 # wait for any previous tasks in process
5690 step
= "Waiting for previous operations to terminate"
5691 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
5692 self
._write
_ns
_status
(
5695 current_operation
="UPDATING",
5696 current_operation_id
=nslcmop_id
,
5699 step
= "Getting nslcmop from database"
5700 db_nslcmop
= self
.db
.get_one(
5701 "nslcmops", {"_id": nslcmop_id
}, fail_on_empty
=False
5703 update_type
= db_nslcmop
["operationParams"]["updateType"]
5705 step
= "Getting nsr from database"
5706 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
5707 old_operational_status
= db_nsr
["operational-status"]
5708 db_nsr_update
["operational-status"] = "updating"
5709 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
5710 nsr_deployed
= db_nsr
["_admin"].get("deployed")
5712 if update_type
== "CHANGE_VNFPKG":
5714 # Get the input parameters given through update request
5715 vnf_instance_id
= db_nslcmop
["operationParams"][
5716 "changeVnfPackageData"
5717 ].get("vnfInstanceId")
5719 vnfd_id
= db_nslcmop
["operationParams"]["changeVnfPackageData"].get(
5722 timeout_seconds
= db_nslcmop
["operationParams"].get("timeout_ns_update")
5724 step
= "Getting vnfr from database"
5725 db_vnfr
= self
.db
.get_one(
5726 "vnfrs", {"_id": vnf_instance_id
}, fail_on_empty
=False
5729 step
= "Getting vnfds from database"
5731 latest_vnfd
= self
.db
.get_one(
5732 "vnfds", {"_id": vnfd_id
}, fail_on_empty
=False
5734 latest_vnfd_revision
= latest_vnfd
["_admin"].get("revision")
5737 current_vnf_revision
= db_vnfr
.get("revision", 1)
5738 current_vnfd
= self
.db
.get_one(
5740 {"_id": vnfd_id
+ ":" + str(current_vnf_revision
)},
5741 fail_on_empty
=False,
5743 # Charm artifact paths will be filled up later
5745 current_charm_artifact_path
,
5746 target_charm_artifact_path
,
5747 charm_artifact_paths
,
5750 step
= "Checking if revision has changed in VNFD"
5751 if current_vnf_revision
!= latest_vnfd_revision
:
5753 change_type
= "policy_updated"
5755 # There is new revision of VNFD, update operation is required
5756 current_vnfd_path
= vnfd_id
+ ":" + str(current_vnf_revision
)
5757 latest_vnfd_path
= vnfd_id
+ ":" + str(latest_vnfd_revision
)
5759 step
= "Removing the VNFD packages if they exist in the local path"
5760 shutil
.rmtree(self
.fs
.path
+ current_vnfd_path
, ignore_errors
=True)
5761 shutil
.rmtree(self
.fs
.path
+ latest_vnfd_path
, ignore_errors
=True)
5763 step
= "Get the VNFD packages from FSMongo"
5764 self
.fs
.sync(from_path
=latest_vnfd_path
)
5765 self
.fs
.sync(from_path
=current_vnfd_path
)
5768 "Get the charm-type, charm-id, ee-id if there is deployed VCA"
5770 base_folder
= latest_vnfd
["_admin"]["storage"]
5772 for charm_index
, charm_deployed
in enumerate(
5773 get_iterable(nsr_deployed
, "VCA")
5775 vnf_index
= db_vnfr
.get("member-vnf-index-ref")
5777 # Getting charm-id and charm-type
5778 if charm_deployed
.get("member-vnf-index") == vnf_index
:
5779 charm_id
= self
.get_vca_id(db_vnfr
, db_nsr
)
5780 charm_type
= charm_deployed
.get("type")
5783 ee_id
= charm_deployed
.get("ee_id")
5785 step
= "Getting descriptor config"
5786 descriptor_config
= get_configuration(
5787 current_vnfd
, current_vnfd
["id"]
5790 if "execution-environment-list" in descriptor_config
:
5791 ee_list
= descriptor_config
.get(
5792 "execution-environment-list", []
5797 # There could be several charm used in the same VNF
5798 for ee_item
in ee_list
:
5799 if ee_item
.get("juju"):
5801 step
= "Getting charm name"
5802 charm_name
= ee_item
["juju"].get("charm")
5804 step
= "Setting Charm artifact paths"
5805 current_charm_artifact_path
.append(
5806 get_charm_artifact_path(
5810 current_vnf_revision
,
5813 target_charm_artifact_path
.append(
5814 get_charm_artifact_path(
5818 latest_vnfd_revision
,
5822 charm_artifact_paths
= zip(
5823 current_charm_artifact_path
, target_charm_artifact_path
5826 step
= "Checking if software version has changed in VNFD"
5827 if find_software_version(current_vnfd
) != find_software_version(
5831 step
= "Checking if existing VNF has charm"
5832 for current_charm_path
, target_charm_path
in list(
5833 charm_artifact_paths
5835 if current_charm_path
:
5837 "Software version change is not supported as VNF instance {} has charm.".format(
5842 # There is no change in the charm package, then redeploy the VNF
5843 # based on new descriptor
5844 step
= "Redeploying VNF"
5845 member_vnf_index
= db_vnfr
["member-vnf-index-ref"]
5849 ) = await self
._ns
_redeploy
_vnf
(
5856 if result
== "FAILED":
5857 nslcmop_operation_state
= result
5858 error_description_nslcmop
= detailed_status
5859 db_nslcmop_update
["detailed-status"] = detailed_status
5862 + " step {} Done with result {} {}".format(
5863 step
, nslcmop_operation_state
, detailed_status
5868 step
= "Checking if any charm package has changed or not"
5869 for current_charm_path
, target_charm_path
in list(
5870 charm_artifact_paths
5874 and target_charm_path
5875 and self
.check_charm_hash_changed(
5876 current_charm_path
, target_charm_path
5880 step
= "Checking whether VNF uses juju bundle"
5881 if check_juju_bundle_existence(current_vnfd
):
5884 "Charm upgrade is not supported for the instance which"
5885 " uses juju-bundle: {}".format(
5886 check_juju_bundle_existence(current_vnfd
)
5890 step
= "Upgrading Charm"
5894 ) = await self
._ns
_charm
_upgrade
(
5897 charm_type
=charm_type
,
5898 path
=self
.fs
.path
+ target_charm_path
,
5899 timeout
=timeout_seconds
,
5902 if result
== "FAILED":
5903 nslcmop_operation_state
= result
5904 error_description_nslcmop
= detailed_status
5906 db_nslcmop_update
["detailed-status"] = detailed_status
5909 + " step {} Done with result {} {}".format(
5910 step
, nslcmop_operation_state
, detailed_status
5914 step
= "Updating policies"
5915 member_vnf_index
= db_vnfr
["member-vnf-index-ref"]
5916 result
= "COMPLETED"
5917 detailed_status
= "Done"
5918 db_nslcmop_update
["detailed-status"] = "Done"
5920 # If nslcmop_operation_state is None, so any operation is not failed.
5921 if not nslcmop_operation_state
:
5922 nslcmop_operation_state
= "COMPLETED"
5924 # If update CHANGE_VNFPKG nslcmop_operation is successful
5925 # vnf revision need to be updated
5926 vnfr_update
["revision"] = latest_vnfd_revision
5927 self
.update_db_2("vnfrs", db_vnfr
["_id"], vnfr_update
)
5931 + " task Done with result {} {}".format(
5932 nslcmop_operation_state
, detailed_status
5935 elif update_type
== "REMOVE_VNF":
5936 # This part is included in https://osm.etsi.org/gerrit/11876
5937 vnf_instance_id
= db_nslcmop
["operationParams"]["removeVnfInstanceId"]
5938 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnf_instance_id
})
5939 member_vnf_index
= db_vnfr
["member-vnf-index-ref"]
5940 step
= "Removing VNF"
5941 (result
, detailed_status
) = await self
.remove_vnf(nsr_id
, nslcmop_id
, vnf_instance_id
)
5942 if result
== "FAILED":
5943 nslcmop_operation_state
= result
5944 error_description_nslcmop
= detailed_status
5945 db_nslcmop_update
["detailed-status"] = detailed_status
5946 change_type
= "vnf_terminated"
5947 if not nslcmop_operation_state
:
5948 nslcmop_operation_state
= "COMPLETED"
5951 + " task Done with result {} {}".format(
5952 nslcmop_operation_state
, detailed_status
5956 elif update_type
== "OPERATE_VNF":
5957 vnf_id
= db_nslcmop
["operationParams"]["operateVnfData"]["vnfInstanceId"]
5958 operation_type
= db_nslcmop
["operationParams"]["operateVnfData"]["changeStateTo"]
5959 additional_param
= db_nslcmop
["operationParams"]["operateVnfData"]["additionalParam"]
5960 (result
, detailed_status
) = await self
.rebuild_start_stop(
5961 nsr_id
, nslcmop_id
, vnf_id
, additional_param
, operation_type
5963 if result
== "FAILED":
5964 nslcmop_operation_state
= result
5965 error_description_nslcmop
= detailed_status
5966 db_nslcmop_update
["detailed-status"] = detailed_status
5967 if not nslcmop_operation_state
:
5968 nslcmop_operation_state
= "COMPLETED"
5971 + " task Done with result {} {}".format(
5972 nslcmop_operation_state
, detailed_status
5976 # If nslcmop_operation_state is None, so any operation is not failed.
5977 # All operations are executed in overall.
5978 if not nslcmop_operation_state
:
5979 nslcmop_operation_state
= "COMPLETED"
5980 db_nsr_update
["operational-status"] = old_operational_status
5982 except (DbException
, LcmException
, N2VCException
, K8sException
) as e
:
5983 self
.logger
.error(logging_text
+ "Exit Exception {}".format(e
))
5985 except asyncio
.CancelledError
:
5987 logging_text
+ "Cancelled Exception while '{}'".format(step
)
5989 exc
= "Operation was cancelled"
5990 except asyncio
.TimeoutError
:
5991 self
.logger
.error(logging_text
+ "Timeout while '{}'".format(step
))
5993 except Exception as e
:
5994 exc
= traceback
.format_exc()
5995 self
.logger
.critical(
5996 logging_text
+ "Exit Exception {} {}".format(type(e
).__name
__, e
),
6005 ) = error_description_nslcmop
= "FAILED {}: {}".format(step
, exc
)
6006 nslcmop_operation_state
= "FAILED"
6007 db_nsr_update
["operational-status"] = old_operational_status
6009 self
._write
_ns
_status
(
6011 ns_state
=db_nsr
["nsState"],
6012 current_operation
="IDLE",
6013 current_operation_id
=None,
6014 other_update
=db_nsr_update
,
6017 self
._write
_op
_status
(
6020 error_message
=error_description_nslcmop
,
6021 operation_state
=nslcmop_operation_state
,
6022 other_update
=db_nslcmop_update
,
6025 if nslcmop_operation_state
:
6029 "nslcmop_id": nslcmop_id
,
6030 "operationState": nslcmop_operation_state
,
6032 if change_type
in ("vnf_terminated", "policy_updated"):
6033 msg
.update({"vnf_member_index": member_vnf_index
})
6034 await self
.msg
.aiowrite("ns", change_type
, msg
, loop
=self
.loop
)
6035 except Exception as e
:
6037 logging_text
+ "kafka_write notification Exception {}".format(e
)
6039 self
.logger
.debug(logging_text
+ "Exit")
6040 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_update")
6041 return nslcmop_operation_state
, detailed_status
6043 async def scale(self
, nsr_id
, nslcmop_id
):
6044 # Try to lock HA task here
6045 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
6046 if not task_is_locked_by_me
:
6049 logging_text
= "Task ns={} scale={} ".format(nsr_id
, nslcmop_id
)
6050 stage
= ["", "", ""]
6051 tasks_dict_info
= {}
6052 # ^ stage, step, VIM progress
6053 self
.logger
.debug(logging_text
+ "Enter")
6054 # get all needed from database
6056 db_nslcmop_update
= {}
6059 # in case of error, indicates what part of scale was failed to put nsr at error status
6060 scale_process
= None
6061 old_operational_status
= ""
6062 old_config_status
= ""
6065 # wait for any previous tasks in process
6066 step
= "Waiting for previous operations to terminate"
6067 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
6068 self
._write
_ns
_status
(
6071 current_operation
="SCALING",
6072 current_operation_id
=nslcmop_id
,
6075 step
= "Getting nslcmop from database"
6077 step
+ " after having waited for previous tasks to be completed"
6079 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
6081 step
= "Getting nsr from database"
6082 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
6083 old_operational_status
= db_nsr
["operational-status"]
6084 old_config_status
= db_nsr
["config-status"]
6086 step
= "Parsing scaling parameters"
6087 db_nsr_update
["operational-status"] = "scaling"
6088 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
6089 nsr_deployed
= db_nsr
["_admin"].get("deployed")
6091 vnf_index
= db_nslcmop
["operationParams"]["scaleVnfData"][
6093 ]["member-vnf-index"]
6094 scaling_group
= db_nslcmop
["operationParams"]["scaleVnfData"][
6096 ]["scaling-group-descriptor"]
6097 scaling_type
= db_nslcmop
["operationParams"]["scaleVnfData"]["scaleVnfType"]
6098 # for backward compatibility
6099 if nsr_deployed
and isinstance(nsr_deployed
.get("VCA"), dict):
6100 nsr_deployed
["VCA"] = list(nsr_deployed
["VCA"].values())
6101 db_nsr_update
["_admin.deployed.VCA"] = nsr_deployed
["VCA"]
6102 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
6104 step
= "Getting vnfr from database"
6105 db_vnfr
= self
.db
.get_one(
6106 "vnfrs", {"member-vnf-index-ref": vnf_index
, "nsr-id-ref": nsr_id
}
6109 vca_id
= self
.get_vca_id(db_vnfr
, db_nsr
)
6111 step
= "Getting vnfd from database"
6112 db_vnfd
= self
.db
.get_one("vnfds", {"_id": db_vnfr
["vnfd-id"]})
6114 base_folder
= db_vnfd
["_admin"]["storage"]
6116 step
= "Getting scaling-group-descriptor"
6117 scaling_descriptor
= find_in_list(
6118 get_scaling_aspect(db_vnfd
),
6119 lambda scale_desc
: scale_desc
["name"] == scaling_group
,
6121 if not scaling_descriptor
:
6123 "input parameter 'scaleByStepData':'scaling-group-descriptor':'{}' is not present "
6124 "at vnfd:scaling-group-descriptor".format(scaling_group
)
6127 step
= "Sending scale order to VIM"
6128 # TODO check if ns is in a proper status
6130 if not db_nsr
["_admin"].get("scaling-group"):
6135 "_admin.scaling-group": [
6136 {"name": scaling_group
, "nb-scale-op": 0}
6140 admin_scale_index
= 0
6142 for admin_scale_index
, admin_scale_info
in enumerate(
6143 db_nsr
["_admin"]["scaling-group"]
6145 if admin_scale_info
["name"] == scaling_group
:
6146 nb_scale_op
= admin_scale_info
.get("nb-scale-op", 0)
6148 else: # not found, set index one plus last element and add new entry with the name
6149 admin_scale_index
+= 1
6151 "_admin.scaling-group.{}.name".format(admin_scale_index
)
6154 vca_scaling_info
= []
6155 scaling_info
= {"scaling_group_name": scaling_group
, "vdu": [], "kdu": []}
6156 if scaling_type
== "SCALE_OUT":
6157 if "aspect-delta-details" not in scaling_descriptor
:
6159 "Aspect delta details not fount in scaling descriptor {}".format(
6160 scaling_descriptor
["name"]
6163 # count if max-instance-count is reached
6164 deltas
= scaling_descriptor
.get("aspect-delta-details")["deltas"]
6166 scaling_info
["scaling_direction"] = "OUT"
6167 scaling_info
["vdu-create"] = {}
6168 scaling_info
["kdu-create"] = {}
6169 for delta
in deltas
:
6170 for vdu_delta
in delta
.get("vdu-delta", {}):
6171 vdud
= get_vdu(db_vnfd
, vdu_delta
["id"])
6172 # vdu_index also provides the number of instance of the targeted vdu
6173 vdu_count
= vdu_index
= get_vdur_index(db_vnfr
, vdu_delta
)
6174 cloud_init_text
= self
._get
_vdu
_cloud
_init
_content
(
6178 additional_params
= (
6179 self
._get
_vdu
_additional
_params
(db_vnfr
, vdud
["id"])
6182 cloud_init_list
= []
6184 vdu_profile
= get_vdu_profile(db_vnfd
, vdu_delta
["id"])
6185 max_instance_count
= 10
6186 if vdu_profile
and "max-number-of-instances" in vdu_profile
:
6187 max_instance_count
= vdu_profile
.get(
6188 "max-number-of-instances", 10
6191 default_instance_num
= get_number_of_instances(
6194 instances_number
= vdu_delta
.get("number-of-instances", 1)
6195 nb_scale_op
+= instances_number
6197 new_instance_count
= nb_scale_op
+ default_instance_num
6198 # Control if new count is over max and vdu count is less than max.
6199 # Then assign new instance count
6200 if new_instance_count
> max_instance_count
> vdu_count
:
6201 instances_number
= new_instance_count
- max_instance_count
6203 instances_number
= instances_number
6205 if new_instance_count
> max_instance_count
:
6207 "reached the limit of {} (max-instance-count) "
6208 "scaling-out operations for the "
6209 "scaling-group-descriptor '{}'".format(
6210 nb_scale_op
, scaling_group
6213 for x
in range(vdu_delta
.get("number-of-instances", 1)):
6215 # TODO Information of its own ip is not available because db_vnfr is not updated.
6216 additional_params
["OSM"] = get_osm_params(
6217 db_vnfr
, vdu_delta
["id"], vdu_index
+ x
6219 cloud_init_list
.append(
6220 self
._parse
_cloud
_init
(
6227 vca_scaling_info
.append(
6229 "osm_vdu_id": vdu_delta
["id"],
6230 "member-vnf-index": vnf_index
,
6232 "vdu_index": vdu_index
+ x
,
6235 scaling_info
["vdu-create"][vdu_delta
["id"]] = instances_number
6236 for kdu_delta
in delta
.get("kdu-resource-delta", {}):
6237 kdu_profile
= get_kdu_resource_profile(db_vnfd
, kdu_delta
["id"])
6238 kdu_name
= kdu_profile
["kdu-name"]
6239 resource_name
= kdu_profile
.get("resource-name", "")
6241 # Might have different kdus in the same delta
6242 # Should have list for each kdu
6243 if not scaling_info
["kdu-create"].get(kdu_name
, None):
6244 scaling_info
["kdu-create"][kdu_name
] = []
6246 kdur
= get_kdur(db_vnfr
, kdu_name
)
6247 if kdur
.get("helm-chart"):
6248 k8s_cluster_type
= "helm-chart-v3"
6249 self
.logger
.debug("kdur: {}".format(kdur
))
6251 kdur
.get("helm-version")
6252 and kdur
.get("helm-version") == "v2"
6254 k8s_cluster_type
= "helm-chart"
6255 elif kdur
.get("juju-bundle"):
6256 k8s_cluster_type
= "juju-bundle"
6259 "kdu type for kdu='{}.{}' is neither helm-chart nor "
6260 "juju-bundle. Maybe an old NBI version is running".format(
6261 db_vnfr
["member-vnf-index-ref"], kdu_name
6265 max_instance_count
= 10
6266 if kdu_profile
and "max-number-of-instances" in kdu_profile
:
6267 max_instance_count
= kdu_profile
.get(
6268 "max-number-of-instances", 10
6271 nb_scale_op
+= kdu_delta
.get("number-of-instances", 1)
6272 deployed_kdu
, _
= get_deployed_kdu(
6273 nsr_deployed
, kdu_name
, vnf_index
6275 if deployed_kdu
is None:
6277 "KDU '{}' for vnf '{}' not deployed".format(
6281 kdu_instance
= deployed_kdu
.get("kdu-instance")
6282 instance_num
= await self
.k8scluster_map
[
6288 cluster_uuid
=deployed_kdu
.get("k8scluster-uuid"),
6289 kdu_model
=deployed_kdu
.get("kdu-model"),
6291 kdu_replica_count
= instance_num
+ kdu_delta
.get(
6292 "number-of-instances", 1
6295 # Control if new count is over max and instance_num is less than max.
6296 # Then assign max instance number to kdu replica count
6297 if kdu_replica_count
> max_instance_count
> instance_num
:
6298 kdu_replica_count
= max_instance_count
6299 if kdu_replica_count
> max_instance_count
:
6301 "reached the limit of {} (max-instance-count) "
6302 "scaling-out operations for the "
6303 "scaling-group-descriptor '{}'".format(
6304 instance_num
, scaling_group
6308 for x
in range(kdu_delta
.get("number-of-instances", 1)):
6309 vca_scaling_info
.append(
6311 "osm_kdu_id": kdu_name
,
6312 "member-vnf-index": vnf_index
,
6314 "kdu_index": instance_num
+ x
- 1,
6317 scaling_info
["kdu-create"][kdu_name
].append(
6319 "member-vnf-index": vnf_index
,
6321 "k8s-cluster-type": k8s_cluster_type
,
6322 "resource-name": resource_name
,
6323 "scale": kdu_replica_count
,
6326 elif scaling_type
== "SCALE_IN":
6327 deltas
= scaling_descriptor
.get("aspect-delta-details")["deltas"]
6329 scaling_info
["scaling_direction"] = "IN"
6330 scaling_info
["vdu-delete"] = {}
6331 scaling_info
["kdu-delete"] = {}
6333 for delta
in deltas
:
6334 for vdu_delta
in delta
.get("vdu-delta", {}):
6335 vdu_count
= vdu_index
= get_vdur_index(db_vnfr
, vdu_delta
)
6336 min_instance_count
= 0
6337 vdu_profile
= get_vdu_profile(db_vnfd
, vdu_delta
["id"])
6338 if vdu_profile
and "min-number-of-instances" in vdu_profile
:
6339 min_instance_count
= vdu_profile
["min-number-of-instances"]
6341 default_instance_num
= get_number_of_instances(
6342 db_vnfd
, vdu_delta
["id"]
6344 instance_num
= vdu_delta
.get("number-of-instances", 1)
6345 nb_scale_op
-= instance_num
6347 new_instance_count
= nb_scale_op
+ default_instance_num
6349 if new_instance_count
< min_instance_count
< vdu_count
:
6350 instances_number
= min_instance_count
- new_instance_count
6352 instances_number
= instance_num
6354 if new_instance_count
< min_instance_count
:
6356 "reached the limit of {} (min-instance-count) scaling-in operations for the "
6357 "scaling-group-descriptor '{}'".format(
6358 nb_scale_op
, scaling_group
6361 for x
in range(vdu_delta
.get("number-of-instances", 1)):
6362 vca_scaling_info
.append(
6364 "osm_vdu_id": vdu_delta
["id"],
6365 "member-vnf-index": vnf_index
,
6367 "vdu_index": vdu_index
- 1 - x
,
6370 scaling_info
["vdu-delete"][vdu_delta
["id"]] = instances_number
6371 for kdu_delta
in delta
.get("kdu-resource-delta", {}):
6372 kdu_profile
= get_kdu_resource_profile(db_vnfd
, kdu_delta
["id"])
6373 kdu_name
= kdu_profile
["kdu-name"]
6374 resource_name
= kdu_profile
.get("resource-name", "")
6376 if not scaling_info
["kdu-delete"].get(kdu_name
, None):
6377 scaling_info
["kdu-delete"][kdu_name
] = []
6379 kdur
= get_kdur(db_vnfr
, kdu_name
)
6380 if kdur
.get("helm-chart"):
6381 k8s_cluster_type
= "helm-chart-v3"
6382 self
.logger
.debug("kdur: {}".format(kdur
))
6384 kdur
.get("helm-version")
6385 and kdur
.get("helm-version") == "v2"
6387 k8s_cluster_type
= "helm-chart"
6388 elif kdur
.get("juju-bundle"):
6389 k8s_cluster_type
= "juju-bundle"
6392 "kdu type for kdu='{}.{}' is neither helm-chart nor "
6393 "juju-bundle. Maybe an old NBI version is running".format(
6394 db_vnfr
["member-vnf-index-ref"], kdur
["kdu-name"]
6398 min_instance_count
= 0
6399 if kdu_profile
and "min-number-of-instances" in kdu_profile
:
6400 min_instance_count
= kdu_profile
["min-number-of-instances"]
6402 nb_scale_op
-= kdu_delta
.get("number-of-instances", 1)
6403 deployed_kdu
, _
= get_deployed_kdu(
6404 nsr_deployed
, kdu_name
, vnf_index
6406 if deployed_kdu
is None:
6408 "KDU '{}' for vnf '{}' not deployed".format(
6412 kdu_instance
= deployed_kdu
.get("kdu-instance")
6413 instance_num
= await self
.k8scluster_map
[
6419 cluster_uuid
=deployed_kdu
.get("k8scluster-uuid"),
6420 kdu_model
=deployed_kdu
.get("kdu-model"),
6422 kdu_replica_count
= instance_num
- kdu_delta
.get(
6423 "number-of-instances", 1
6426 if kdu_replica_count
< min_instance_count
< instance_num
:
6427 kdu_replica_count
= min_instance_count
6428 if kdu_replica_count
< min_instance_count
:
6430 "reached the limit of {} (min-instance-count) scaling-in operations for the "
6431 "scaling-group-descriptor '{}'".format(
6432 instance_num
, scaling_group
6436 for x
in range(kdu_delta
.get("number-of-instances", 1)):
6437 vca_scaling_info
.append(
6439 "osm_kdu_id": kdu_name
,
6440 "member-vnf-index": vnf_index
,
6442 "kdu_index": instance_num
- x
- 1,
6445 scaling_info
["kdu-delete"][kdu_name
].append(
6447 "member-vnf-index": vnf_index
,
6449 "k8s-cluster-type": k8s_cluster_type
,
6450 "resource-name": resource_name
,
6451 "scale": kdu_replica_count
,
6455 # update VDU_SCALING_INFO with the VDUs to delete ip_addresses
6456 vdu_delete
= copy(scaling_info
.get("vdu-delete"))
6457 if scaling_info
["scaling_direction"] == "IN":
6458 for vdur
in reversed(db_vnfr
["vdur"]):
6459 if vdu_delete
.get(vdur
["vdu-id-ref"]):
6460 vdu_delete
[vdur
["vdu-id-ref"]] -= 1
6461 scaling_info
["vdu"].append(
6463 "name": vdur
.get("name") or vdur
.get("vdu-name"),
6464 "vdu_id": vdur
["vdu-id-ref"],
6468 for interface
in vdur
["interfaces"]:
6469 scaling_info
["vdu"][-1]["interface"].append(
6471 "name": interface
["name"],
6472 "ip_address": interface
["ip-address"],
6473 "mac_address": interface
.get("mac-address"),
6476 # vdu_delete = vdu_scaling_info.pop("vdu-delete")
6479 step
= "Executing pre-scale vnf-config-primitive"
6480 if scaling_descriptor
.get("scaling-config-action"):
6481 for scaling_config_action
in scaling_descriptor
[
6482 "scaling-config-action"
6485 scaling_config_action
.get("trigger") == "pre-scale-in"
6486 and scaling_type
== "SCALE_IN"
6488 scaling_config_action
.get("trigger") == "pre-scale-out"
6489 and scaling_type
== "SCALE_OUT"
6491 vnf_config_primitive
= scaling_config_action
[
6492 "vnf-config-primitive-name-ref"
6494 step
= db_nslcmop_update
[
6496 ] = "executing pre-scale scaling-config-action '{}'".format(
6497 vnf_config_primitive
6500 # look for primitive
6501 for config_primitive
in (
6502 get_configuration(db_vnfd
, db_vnfd
["id"]) or {}
6503 ).get("config-primitive", ()):
6504 if config_primitive
["name"] == vnf_config_primitive
:
6508 "Invalid vnfd descriptor at scaling-group-descriptor[name='{}']:scaling-config-action"
6509 "[vnf-config-primitive-name-ref='{}'] does not match any vnf-configuration:config-"
6510 "primitive".format(scaling_group
, vnf_config_primitive
)
6513 vnfr_params
= {"VDU_SCALE_INFO": scaling_info
}
6514 if db_vnfr
.get("additionalParamsForVnf"):
6515 vnfr_params
.update(db_vnfr
["additionalParamsForVnf"])
6517 scale_process
= "VCA"
6518 db_nsr_update
["config-status"] = "configuring pre-scaling"
6519 primitive_params
= self
._map
_primitive
_params
(
6520 config_primitive
, {}, vnfr_params
6523 # Pre-scale retry check: Check if this sub-operation has been executed before
6524 op_index
= self
._check
_or
_add
_scale
_suboperation
(
6527 vnf_config_primitive
,
6531 if op_index
== self
.SUBOPERATION_STATUS_SKIP
:
6532 # Skip sub-operation
6533 result
= "COMPLETED"
6534 result_detail
= "Done"
6537 + "vnf_config_primitive={} Skipped sub-operation, result {} {}".format(
6538 vnf_config_primitive
, result
, result_detail
6542 if op_index
== self
.SUBOPERATION_STATUS_NEW
:
6543 # New sub-operation: Get index of this sub-operation
6545 len(db_nslcmop
.get("_admin", {}).get("operations"))
6550 + "vnf_config_primitive={} New sub-operation".format(
6551 vnf_config_primitive
6555 # retry: Get registered params for this existing sub-operation
6556 op
= db_nslcmop
.get("_admin", {}).get("operations", [])[
6559 vnf_index
= op
.get("member_vnf_index")
6560 vnf_config_primitive
= op
.get("primitive")
6561 primitive_params
= op
.get("primitive_params")
6564 + "vnf_config_primitive={} Sub-operation retry".format(
6565 vnf_config_primitive
6568 # Execute the primitive, either with new (first-time) or registered (reintent) args
6569 ee_descriptor_id
= config_primitive
.get(
6570 "execution-environment-ref"
6572 primitive_name
= config_primitive
.get(
6573 "execution-environment-primitive", vnf_config_primitive
6575 ee_id
, vca_type
= self
._look
_for
_deployed
_vca
(
6576 nsr_deployed
["VCA"],
6577 member_vnf_index
=vnf_index
,
6579 vdu_count_index
=None,
6580 ee_descriptor_id
=ee_descriptor_id
,
6582 result
, result_detail
= await self
._ns
_execute
_primitive
(
6591 + "vnf_config_primitive={} Done with result {} {}".format(
6592 vnf_config_primitive
, result
, result_detail
6595 # Update operationState = COMPLETED | FAILED
6596 self
._update
_suboperation
_status
(
6597 db_nslcmop
, op_index
, result
, result_detail
6600 if result
== "FAILED":
6601 raise LcmException(result_detail
)
6602 db_nsr_update
["config-status"] = old_config_status
6603 scale_process
= None
6607 "_admin.scaling-group.{}.nb-scale-op".format(admin_scale_index
)
6610 "_admin.scaling-group.{}.time".format(admin_scale_index
)
6613 # SCALE-IN VCA - BEGIN
6614 if vca_scaling_info
:
6615 step
= db_nslcmop_update
[
6617 ] = "Deleting the execution environments"
6618 scale_process
= "VCA"
6619 for vca_info
in vca_scaling_info
:
6620 if vca_info
["type"] == "delete" and not vca_info
.get("osm_kdu_id"):
6621 member_vnf_index
= str(vca_info
["member-vnf-index"])
6623 logging_text
+ "vdu info: {}".format(vca_info
)
6625 if vca_info
.get("osm_vdu_id"):
6626 vdu_id
= vca_info
["osm_vdu_id"]
6627 vdu_index
= int(vca_info
["vdu_index"])
6630 ] = "Scaling member_vnf_index={}, vdu_id={}, vdu_index={} ".format(
6631 member_vnf_index
, vdu_id
, vdu_index
6633 stage
[2] = step
= "Scaling in VCA"
6634 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
)
6635 vca_update
= db_nsr
["_admin"]["deployed"]["VCA"]
6636 config_update
= db_nsr
["configurationStatus"]
6637 for vca_index
, vca
in enumerate(vca_update
):
6639 (vca
or vca
.get("ee_id"))
6640 and vca
["member-vnf-index"] == member_vnf_index
6641 and vca
["vdu_count_index"] == vdu_index
6643 if vca
.get("vdu_id"):
6644 config_descriptor
= get_configuration(
6645 db_vnfd
, vca
.get("vdu_id")
6647 elif vca
.get("kdu_name"):
6648 config_descriptor
= get_configuration(
6649 db_vnfd
, vca
.get("kdu_name")
6652 config_descriptor
= get_configuration(
6653 db_vnfd
, db_vnfd
["id"]
6655 operation_params
= (
6656 db_nslcmop
.get("operationParams") or {}
6658 exec_terminate_primitives
= not operation_params
.get(
6659 "skip_terminate_primitives"
6660 ) and vca
.get("needed_terminate")
6661 task
= asyncio
.ensure_future(
6670 exec_primitives
=exec_terminate_primitives
,
6674 timeout
=self
.timeout_charm_delete
,
6677 tasks_dict_info
[task
] = "Terminating VCA {}".format(
6680 del vca_update
[vca_index
]
6681 del config_update
[vca_index
]
6682 # wait for pending tasks of terminate primitives
6686 + "Waiting for tasks {}".format(
6687 list(tasks_dict_info
.keys())
6690 error_list
= await self
._wait
_for
_tasks
(
6694 self
.timeout_charm_delete
, self
.timeout_ns_terminate
6699 tasks_dict_info
.clear()
6701 raise LcmException("; ".join(error_list
))
6703 db_vca_and_config_update
= {
6704 "_admin.deployed.VCA": vca_update
,
6705 "configurationStatus": config_update
,
6708 "nsrs", db_nsr
["_id"], db_vca_and_config_update
6710 scale_process
= None
6711 # SCALE-IN VCA - END
6714 if scaling_info
.get("vdu-create") or scaling_info
.get("vdu-delete"):
6715 scale_process
= "RO"
6716 if self
.ro_config
.get("ng"):
6717 await self
._scale
_ng
_ro
(
6718 logging_text
, db_nsr
, db_nslcmop
, db_vnfr
, scaling_info
, stage
6720 scaling_info
.pop("vdu-create", None)
6721 scaling_info
.pop("vdu-delete", None)
6723 scale_process
= None
6727 if scaling_info
.get("kdu-create") or scaling_info
.get("kdu-delete"):
6728 scale_process
= "KDU"
6729 await self
._scale
_kdu
(
6730 logging_text
, nsr_id
, nsr_deployed
, db_vnfd
, vca_id
, scaling_info
6732 scaling_info
.pop("kdu-create", None)
6733 scaling_info
.pop("kdu-delete", None)
6735 scale_process
= None
6739 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
6741 # SCALE-UP VCA - BEGIN
6742 if vca_scaling_info
:
6743 step
= db_nslcmop_update
[
6745 ] = "Creating new execution environments"
6746 scale_process
= "VCA"
6747 for vca_info
in vca_scaling_info
:
6748 if vca_info
["type"] == "create" and not vca_info
.get("osm_kdu_id"):
6749 member_vnf_index
= str(vca_info
["member-vnf-index"])
6751 logging_text
+ "vdu info: {}".format(vca_info
)
6753 vnfd_id
= db_vnfr
["vnfd-ref"]
6754 if vca_info
.get("osm_vdu_id"):
6755 vdu_index
= int(vca_info
["vdu_index"])
6756 deploy_params
= {"OSM": get_osm_params(db_vnfr
)}
6757 if db_vnfr
.get("additionalParamsForVnf"):
6758 deploy_params
.update(
6760 db_vnfr
["additionalParamsForVnf"].copy()
6763 descriptor_config
= get_configuration(
6764 db_vnfd
, db_vnfd
["id"]
6766 if descriptor_config
:
6771 logging_text
=logging_text
6772 + "member_vnf_index={} ".format(member_vnf_index
),
6775 nslcmop_id
=nslcmop_id
,
6781 member_vnf_index
=member_vnf_index
,
6782 vdu_index
=vdu_index
,
6784 deploy_params
=deploy_params
,
6785 descriptor_config
=descriptor_config
,
6786 base_folder
=base_folder
,
6787 task_instantiation_info
=tasks_dict_info
,
6790 vdu_id
= vca_info
["osm_vdu_id"]
6791 vdur
= find_in_list(
6792 db_vnfr
["vdur"], lambda vdu
: vdu
["vdu-id-ref"] == vdu_id
6794 descriptor_config
= get_configuration(db_vnfd
, vdu_id
)
6795 if vdur
.get("additionalParams"):
6796 deploy_params_vdu
= parse_yaml_strings(
6797 vdur
["additionalParams"]
6800 deploy_params_vdu
= deploy_params
6801 deploy_params_vdu
["OSM"] = get_osm_params(
6802 db_vnfr
, vdu_id
, vdu_count_index
=vdu_index
6804 if descriptor_config
:
6809 ] = "Scaling member_vnf_index={}, vdu_id={}, vdu_index={} ".format(
6810 member_vnf_index
, vdu_id
, vdu_index
6812 stage
[2] = step
= "Scaling out VCA"
6813 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
)
6815 logging_text
=logging_text
6816 + "member_vnf_index={}, vdu_id={}, vdu_index={} ".format(
6817 member_vnf_index
, vdu_id
, vdu_index
6821 nslcmop_id
=nslcmop_id
,
6827 member_vnf_index
=member_vnf_index
,
6828 vdu_index
=vdu_index
,
6830 deploy_params
=deploy_params_vdu
,
6831 descriptor_config
=descriptor_config
,
6832 base_folder
=base_folder
,
6833 task_instantiation_info
=tasks_dict_info
,
6836 # SCALE-UP VCA - END
6837 scale_process
= None
6840 # execute primitive service POST-SCALING
6841 step
= "Executing post-scale vnf-config-primitive"
6842 if scaling_descriptor
.get("scaling-config-action"):
6843 for scaling_config_action
in scaling_descriptor
[
6844 "scaling-config-action"
6847 scaling_config_action
.get("trigger") == "post-scale-in"
6848 and scaling_type
== "SCALE_IN"
6850 scaling_config_action
.get("trigger") == "post-scale-out"
6851 and scaling_type
== "SCALE_OUT"
6853 vnf_config_primitive
= scaling_config_action
[
6854 "vnf-config-primitive-name-ref"
6856 step
= db_nslcmop_update
[
6858 ] = "executing post-scale scaling-config-action '{}'".format(
6859 vnf_config_primitive
6862 vnfr_params
= {"VDU_SCALE_INFO": scaling_info
}
6863 if db_vnfr
.get("additionalParamsForVnf"):
6864 vnfr_params
.update(db_vnfr
["additionalParamsForVnf"])
6866 # look for primitive
6867 for config_primitive
in (
6868 get_configuration(db_vnfd
, db_vnfd
["id"]) or {}
6869 ).get("config-primitive", ()):
6870 if config_primitive
["name"] == vnf_config_primitive
:
6874 "Invalid vnfd descriptor at scaling-group-descriptor[name='{}']:scaling-config-"
6875 "action[vnf-config-primitive-name-ref='{}'] does not match any vnf-configuration:"
6876 "config-primitive".format(
6877 scaling_group
, vnf_config_primitive
6880 scale_process
= "VCA"
6881 db_nsr_update
["config-status"] = "configuring post-scaling"
6882 primitive_params
= self
._map
_primitive
_params
(
6883 config_primitive
, {}, vnfr_params
6886 # Post-scale retry check: Check if this sub-operation has been executed before
6887 op_index
= self
._check
_or
_add
_scale
_suboperation
(
6890 vnf_config_primitive
,
6894 if op_index
== self
.SUBOPERATION_STATUS_SKIP
:
6895 # Skip sub-operation
6896 result
= "COMPLETED"
6897 result_detail
= "Done"
6900 + "vnf_config_primitive={} Skipped sub-operation, result {} {}".format(
6901 vnf_config_primitive
, result
, result_detail
6905 if op_index
== self
.SUBOPERATION_STATUS_NEW
:
6906 # New sub-operation: Get index of this sub-operation
6908 len(db_nslcmop
.get("_admin", {}).get("operations"))
6913 + "vnf_config_primitive={} New sub-operation".format(
6914 vnf_config_primitive
6918 # retry: Get registered params for this existing sub-operation
6919 op
= db_nslcmop
.get("_admin", {}).get("operations", [])[
6922 vnf_index
= op
.get("member_vnf_index")
6923 vnf_config_primitive
= op
.get("primitive")
6924 primitive_params
= op
.get("primitive_params")
6927 + "vnf_config_primitive={} Sub-operation retry".format(
6928 vnf_config_primitive
6931 # Execute the primitive, either with new (first-time) or registered (reintent) args
6932 ee_descriptor_id
= config_primitive
.get(
6933 "execution-environment-ref"
6935 primitive_name
= config_primitive
.get(
6936 "execution-environment-primitive", vnf_config_primitive
6938 ee_id
, vca_type
= self
._look
_for
_deployed
_vca
(
6939 nsr_deployed
["VCA"],
6940 member_vnf_index
=vnf_index
,
6942 vdu_count_index
=None,
6943 ee_descriptor_id
=ee_descriptor_id
,
6945 result
, result_detail
= await self
._ns
_execute
_primitive
(
6954 + "vnf_config_primitive={} Done with result {} {}".format(
6955 vnf_config_primitive
, result
, result_detail
6958 # Update operationState = COMPLETED | FAILED
6959 self
._update
_suboperation
_status
(
6960 db_nslcmop
, op_index
, result
, result_detail
6963 if result
== "FAILED":
6964 raise LcmException(result_detail
)
6965 db_nsr_update
["config-status"] = old_config_status
6966 scale_process
= None
6971 ] = "" # "scaled {} {}".format(scaling_group, scaling_type)
6972 db_nsr_update
["operational-status"] = (
6974 if old_operational_status
== "failed"
6975 else old_operational_status
6977 db_nsr_update
["config-status"] = old_config_status
6980 ROclient
.ROClientException
,
6985 self
.logger
.error(logging_text
+ "Exit Exception {}".format(e
))
6987 except asyncio
.CancelledError
:
6989 logging_text
+ "Cancelled Exception while '{}'".format(step
)
6991 exc
= "Operation was cancelled"
6992 except Exception as e
:
6993 exc
= traceback
.format_exc()
6994 self
.logger
.critical(
6995 logging_text
+ "Exit Exception {} {}".format(type(e
).__name
__, e
),
6999 self
._write
_ns
_status
(
7002 current_operation
="IDLE",
7003 current_operation_id
=None,
7006 stage
[1] = "Waiting for instantiate pending tasks."
7007 self
.logger
.debug(logging_text
+ stage
[1])
7008 exc
= await self
._wait
_for
_tasks
(
7011 self
.timeout_ns_deploy
,
7019 ] = error_description_nslcmop
= "FAILED {}: {}".format(step
, exc
)
7020 nslcmop_operation_state
= "FAILED"
7022 db_nsr_update
["operational-status"] = old_operational_status
7023 db_nsr_update
["config-status"] = old_config_status
7024 db_nsr_update
["detailed-status"] = ""
7026 if "VCA" in scale_process
:
7027 db_nsr_update
["config-status"] = "failed"
7028 if "RO" in scale_process
:
7029 db_nsr_update
["operational-status"] = "failed"
7032 ] = "FAILED scaling nslcmop={} {}: {}".format(
7033 nslcmop_id
, step
, exc
7036 error_description_nslcmop
= None
7037 nslcmop_operation_state
= "COMPLETED"
7038 db_nslcmop_update
["detailed-status"] = "Done"
7040 self
._write
_op
_status
(
7043 error_message
=error_description_nslcmop
,
7044 operation_state
=nslcmop_operation_state
,
7045 other_update
=db_nslcmop_update
,
7048 self
._write
_ns
_status
(
7051 current_operation
="IDLE",
7052 current_operation_id
=None,
7053 other_update
=db_nsr_update
,
7056 if nslcmop_operation_state
:
7060 "nslcmop_id": nslcmop_id
,
7061 "operationState": nslcmop_operation_state
,
7063 await self
.msg
.aiowrite("ns", "scaled", msg
, loop
=self
.loop
)
7064 except Exception as e
:
7066 logging_text
+ "kafka_write notification Exception {}".format(e
)
7068 self
.logger
.debug(logging_text
+ "Exit")
7069 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_scale")
7071 async def _scale_kdu(
7072 self
, logging_text
, nsr_id
, nsr_deployed
, db_vnfd
, vca_id
, scaling_info
7074 _scaling_info
= scaling_info
.get("kdu-create") or scaling_info
.get("kdu-delete")
7075 for kdu_name
in _scaling_info
:
7076 for kdu_scaling_info
in _scaling_info
[kdu_name
]:
7077 deployed_kdu
, index
= get_deployed_kdu(
7078 nsr_deployed
, kdu_name
, kdu_scaling_info
["member-vnf-index"]
7080 cluster_uuid
= deployed_kdu
["k8scluster-uuid"]
7081 kdu_instance
= deployed_kdu
["kdu-instance"]
7082 kdu_model
= deployed_kdu
.get("kdu-model")
7083 scale
= int(kdu_scaling_info
["scale"])
7084 k8s_cluster_type
= kdu_scaling_info
["k8s-cluster-type"]
7087 "collection": "nsrs",
7088 "filter": {"_id": nsr_id
},
7089 "path": "_admin.deployed.K8s.{}".format(index
),
7092 step
= "scaling application {}".format(
7093 kdu_scaling_info
["resource-name"]
7095 self
.logger
.debug(logging_text
+ step
)
7097 if kdu_scaling_info
["type"] == "delete":
7098 kdu_config
= get_configuration(db_vnfd
, kdu_name
)
7101 and kdu_config
.get("terminate-config-primitive")
7102 and get_juju_ee_ref(db_vnfd
, kdu_name
) is None
7104 terminate_config_primitive_list
= kdu_config
.get(
7105 "terminate-config-primitive"
7107 terminate_config_primitive_list
.sort(
7108 key
=lambda val
: int(val
["seq"])
7112 terminate_config_primitive
7113 ) in terminate_config_primitive_list
:
7114 primitive_params_
= self
._map
_primitive
_params
(
7115 terminate_config_primitive
, {}, {}
7117 step
= "execute terminate config primitive"
7118 self
.logger
.debug(logging_text
+ step
)
7119 await asyncio
.wait_for(
7120 self
.k8scluster_map
[k8s_cluster_type
].exec_primitive(
7121 cluster_uuid
=cluster_uuid
,
7122 kdu_instance
=kdu_instance
,
7123 primitive_name
=terminate_config_primitive
["name"],
7124 params
=primitive_params_
,
7131 await asyncio
.wait_for(
7132 self
.k8scluster_map
[k8s_cluster_type
].scale(
7135 kdu_scaling_info
["resource-name"],
7137 cluster_uuid
=cluster_uuid
,
7138 kdu_model
=kdu_model
,
7142 timeout
=self
.timeout_vca_on_error
,
7145 if kdu_scaling_info
["type"] == "create":
7146 kdu_config
= get_configuration(db_vnfd
, kdu_name
)
7149 and kdu_config
.get("initial-config-primitive")
7150 and get_juju_ee_ref(db_vnfd
, kdu_name
) is None
7152 initial_config_primitive_list
= kdu_config
.get(
7153 "initial-config-primitive"
7155 initial_config_primitive_list
.sort(
7156 key
=lambda val
: int(val
["seq"])
7159 for initial_config_primitive
in initial_config_primitive_list
:
7160 primitive_params_
= self
._map
_primitive
_params
(
7161 initial_config_primitive
, {}, {}
7163 step
= "execute initial config primitive"
7164 self
.logger
.debug(logging_text
+ step
)
7165 await asyncio
.wait_for(
7166 self
.k8scluster_map
[k8s_cluster_type
].exec_primitive(
7167 cluster_uuid
=cluster_uuid
,
7168 kdu_instance
=kdu_instance
,
7169 primitive_name
=initial_config_primitive
["name"],
7170 params
=primitive_params_
,
7177 async def _scale_ng_ro(
7178 self
, logging_text
, db_nsr
, db_nslcmop
, db_vnfr
, vdu_scaling_info
, stage
7180 nsr_id
= db_nslcmop
["nsInstanceId"]
7181 db_nsd
= self
.db
.get_one("nsds", {"_id": db_nsr
["nsd-id"]})
7184 # read from db: vnfd's for every vnf
7187 # for each vnf in ns, read vnfd
7188 for vnfr
in self
.db
.get_list("vnfrs", {"nsr-id-ref": nsr_id
}):
7189 db_vnfrs
[vnfr
["member-vnf-index-ref"]] = vnfr
7190 vnfd_id
= vnfr
["vnfd-id"] # vnfd uuid for this vnf
7191 # if we haven't this vnfd, read it from db
7192 if not find_in_list(db_vnfds
, lambda a_vnfd
: a_vnfd
["id"] == vnfd_id
):
7194 vnfd
= self
.db
.get_one("vnfds", {"_id": vnfd_id
})
7195 db_vnfds
.append(vnfd
)
7196 n2vc_key
= self
.n2vc
.get_public_key()
7197 n2vc_key_list
= [n2vc_key
]
7200 vdu_scaling_info
.get("vdu-create"),
7201 vdu_scaling_info
.get("vdu-delete"),
7204 # db_vnfr has been updated, update db_vnfrs to use it
7205 db_vnfrs
[db_vnfr
["member-vnf-index-ref"]] = db_vnfr
7206 await self
._instantiate
_ng
_ro
(
7216 start_deploy
=time(),
7217 timeout_ns_deploy
=self
.timeout_ns_deploy
,
7219 if vdu_scaling_info
.get("vdu-delete"):
7221 db_vnfr
, None, vdu_scaling_info
["vdu-delete"], mark_delete
=False
7224 async def extract_prometheus_scrape_jobs(
7225 self
, ee_id
, artifact_path
, ee_config_descriptor
, vnfr_id
, nsr_id
, target_ip
7227 # look if exist a file called 'prometheus*.j2' and
7228 artifact_content
= self
.fs
.dir_ls(artifact_path
)
7232 for f
in artifact_content
7233 if f
.startswith("prometheus") and f
.endswith(".j2")
7239 with self
.fs
.file_open((artifact_path
, job_file
), "r") as f
:
7243 _
, _
, service
= ee_id
.partition(".") # remove prefix "namespace."
7244 host_name
= "{}-{}".format(service
, ee_config_descriptor
["metric-service"])
7246 vnfr_id
= vnfr_id
.replace("-", "")
7248 "JOB_NAME": vnfr_id
,
7249 "TARGET_IP": target_ip
,
7250 "EXPORTER_POD_IP": host_name
,
7251 "EXPORTER_POD_PORT": host_port
,
7253 job_list
= parse_job(job_data
, variables
)
7254 # ensure job_name is using the vnfr_id. Adding the metadata nsr_id
7255 for job
in job_list
:
7257 not isinstance(job
.get("job_name"), str)
7258 or vnfr_id
not in job
["job_name"]
7260 job
["job_name"] = vnfr_id
+ "_" + str(randint(1, 10000))
7261 job
["nsr_id"] = nsr_id
7262 job
["vnfr_id"] = vnfr_id
7265 async def rebuild_start_stop(self
, nsr_id
, nslcmop_id
, vnf_id
, additional_param
, operation_type
):
7266 logging_text
= "Task ns={} {}={} ".format(nsr_id
, operation_type
, nslcmop_id
)
7267 self
.logger
.info(logging_text
+ "Enter")
7268 stage
= ["Preparing the environment", ""]
7269 # database nsrs record
7273 # in case of error, indicates what part of scale was failed to put nsr at error status
7274 start_deploy
= time()
7276 db_vnfr
= self
.db
.get_one("vnfrs", {"_id": vnf_id
})
7277 vim_account_id
= db_vnfr
.get("vim-account-id")
7278 vim_info_key
= "vim:" + vim_account_id
7279 vdu_id
= additional_param
["vdu_id"]
7280 vdurs
= [item
for item
in db_vnfr
["vdur"] if item
["vdu-id-ref"] == vdu_id
]
7281 vdur
= find_in_list(
7282 vdurs
, lambda vdu
: vdu
["count-index"] == additional_param
["count-index"]
7285 vdu_vim_name
= vdur
["name"]
7286 vim_vm_id
= vdur
["vim_info"][vim_info_key
]["vim_id"]
7287 target_vim
, _
= next(k_v
for k_v
in vdur
["vim_info"].items())
7289 raise LcmException("Target vdu is not found")
7290 self
.logger
.info("vdu_vim_name >> {} ".format(vdu_vim_name
))
7291 # wait for any previous tasks in process
7292 stage
[1] = "Waiting for previous operations to terminate"
7293 self
.logger
.info(stage
[1])
7294 await self
.lcm_tasks
.waitfor_related_HA('ns', 'nslcmops', nslcmop_id
)
7296 stage
[1] = "Reading from database."
7297 self
.logger
.info(stage
[1])
7298 self
._write
_ns
_status
(
7301 current_operation
=operation_type
.upper(),
7302 current_operation_id
=nslcmop_id
7304 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
, queuePosition
=0)
7307 stage
[1] = "Getting nsr={} from db.".format(nsr_id
)
7308 db_nsr_update
["operational-status"] = operation_type
7309 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
7313 "vim_vm_id": vim_vm_id
,
7315 "vdu_index": additional_param
["count-index"],
7316 "vdu_id": vdur
["id"],
7317 "target_vim": target_vim
,
7318 "vim_account_id": vim_account_id
7321 stage
[1] = "Sending rebuild request to RO... {}".format(desc
)
7322 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
, queuePosition
=0)
7323 self
.logger
.info("ro nsr id: {}".format(nsr_id
))
7324 result_dict
= await self
.RO
.operate(nsr_id
, desc
, operation_type
)
7325 self
.logger
.info("response from RO: {}".format(result_dict
))
7326 action_id
= result_dict
["action_id"]
7327 await self
._wait
_ng
_ro
(
7328 nsr_id
, action_id
, nslcmop_id
, start_deploy
,
7329 self
.timeout_operate
, None, "start_stop_rebuild",
7331 return "COMPLETED", "Done"
7332 except (ROclient
.ROClientException
, DbException
, LcmException
) as e
:
7333 self
.logger
.error("Exit Exception {}".format(e
))
7335 except asyncio
.CancelledError
:
7336 self
.logger
.error("Cancelled Exception while '{}'".format(stage
))
7337 exc
= "Operation was cancelled"
7338 except Exception as e
:
7339 exc
= traceback
.format_exc()
7340 self
.logger
.critical("Exit Exception {} {}".format(type(e
).__name
__, e
), exc_info
=True)
7341 return "FAILED", "Error in operate VNF {}".format(exc
)
7343 def get_vca_cloud_and_credentials(self
, vim_account_id
: str) -> (str, str):
7345 Get VCA Cloud and VCA Cloud Credentials for the VIM account
7347 :param: vim_account_id: VIM Account ID
7349 :return: (cloud_name, cloud_credential)
7351 config
= VimAccountDB
.get_vim_account_with_id(vim_account_id
).get("config", {})
7352 return config
.get("vca_cloud"), config
.get("vca_cloud_credential")
7354 def get_vca_k8s_cloud_and_credentials(self
, vim_account_id
: str) -> (str, str):
7356 Get VCA K8s Cloud and VCA K8s Cloud Credentials for the VIM account
7358 :param: vim_account_id: VIM Account ID
7360 :return: (cloud_name, cloud_credential)
7362 config
= VimAccountDB
.get_vim_account_with_id(vim_account_id
).get("config", {})
7363 return config
.get("vca_k8s_cloud"), config
.get("vca_k8s_cloud_credential")
7365 async def migrate(self
, nsr_id
, nslcmop_id
):
7367 Migrate VNFs and VDUs instances in a NS
7369 :param: nsr_id: NS Instance ID
7370 :param: nslcmop_id: nslcmop ID of migrate
7373 # Try to lock HA task here
7374 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
7375 if not task_is_locked_by_me
:
7377 logging_text
= "Task ns={} migrate ".format(nsr_id
)
7378 self
.logger
.debug(logging_text
+ "Enter")
7379 # get all needed from database
7381 db_nslcmop_update
= {}
7382 nslcmop_operation_state
= None
7386 # in case of error, indicates what part of scale was failed to put nsr at error status
7387 start_deploy
= time()
7390 # wait for any previous tasks in process
7391 step
= "Waiting for previous operations to terminate"
7392 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
7394 self
._write
_ns
_status
(
7397 current_operation
="MIGRATING",
7398 current_operation_id
=nslcmop_id
,
7400 step
= "Getting nslcmop from database"
7402 step
+ " after having waited for previous tasks to be completed"
7404 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
7405 migrate_params
= db_nslcmop
.get("operationParams")
7408 target
.update(migrate_params
)
7409 desc
= await self
.RO
.migrate(nsr_id
, target
)
7410 self
.logger
.debug("RO return > {}".format(desc
))
7411 action_id
= desc
["action_id"]
7412 await self
._wait
_ng
_ro
(
7413 nsr_id
, action_id
, nslcmop_id
, start_deploy
, self
.timeout_migrate
,
7416 except (ROclient
.ROClientException
, DbException
, LcmException
) as e
:
7417 self
.logger
.error("Exit Exception {}".format(e
))
7419 except asyncio
.CancelledError
:
7420 self
.logger
.error("Cancelled Exception while '{}'".format(step
))
7421 exc
= "Operation was cancelled"
7422 except Exception as e
:
7423 exc
= traceback
.format_exc()
7424 self
.logger
.critical(
7425 "Exit Exception {} {}".format(type(e
).__name
__, e
), exc_info
=True
7428 self
._write
_ns
_status
(
7431 current_operation
="IDLE",
7432 current_operation_id
=None,
7435 db_nslcmop_update
["detailed-status"] = "FAILED {}: {}".format(step
, exc
)
7436 nslcmop_operation_state
= "FAILED"
7438 nslcmop_operation_state
= "COMPLETED"
7439 db_nslcmop_update
["detailed-status"] = "Done"
7440 db_nsr_update
["detailed-status"] = "Done"
7442 self
._write
_op
_status
(
7446 operation_state
=nslcmop_operation_state
,
7447 other_update
=db_nslcmop_update
,
7449 if nslcmop_operation_state
:
7453 "nslcmop_id": nslcmop_id
,
7454 "operationState": nslcmop_operation_state
,
7456 await self
.msg
.aiowrite("ns", "migrated", msg
, loop
=self
.loop
)
7457 except Exception as e
:
7459 logging_text
+ "kafka_write notification Exception {}".format(e
)
7461 self
.logger
.debug(logging_text
+ "Exit")
7462 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_migrate")
7465 async def heal(self
, nsr_id
, nslcmop_id
):
7469 :param nsr_id: ns instance to heal
7470 :param nslcmop_id: operation to run
7474 # Try to lock HA task here
7475 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
7476 if not task_is_locked_by_me
:
7479 logging_text
= "Task ns={} heal={} ".format(nsr_id
, nslcmop_id
)
7480 stage
= ["", "", ""]
7481 tasks_dict_info
= {}
7482 # ^ stage, step, VIM progress
7483 self
.logger
.debug(logging_text
+ "Enter")
7484 # get all needed from database
7486 db_nslcmop_update
= {}
7488 db_vnfrs
= {} # vnf's info indexed by _id
7490 old_operational_status
= ""
7491 old_config_status
= ""
7494 # wait for any previous tasks in process
7495 step
= "Waiting for previous operations to terminate"
7496 await self
.lcm_tasks
.waitfor_related_HA("ns", "nslcmops", nslcmop_id
)
7497 self
._write
_ns
_status
(
7500 current_operation
="HEALING",
7501 current_operation_id
=nslcmop_id
,
7504 step
= "Getting nslcmop from database"
7506 step
+ " after having waited for previous tasks to be completed"
7508 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
7510 step
= "Getting nsr from database"
7511 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
7512 old_operational_status
= db_nsr
["operational-status"]
7513 old_config_status
= db_nsr
["config-status"]
7516 "_admin.deployed.RO.operational-status": "healing",
7518 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
7520 step
= "Sending heal order to VIM"
7521 task_ro
= asyncio
.ensure_future(
7523 logging_text
=logging_text
,
7525 db_nslcmop
=db_nslcmop
,
7529 self
.lcm_tasks
.register("ns", nsr_id
, nslcmop_id
, "heal_RO", task_ro
)
7530 tasks_dict_info
[task_ro
] = "Healing at VIM"
7534 stage
[1] = "Getting nsd={} from db.".format(db_nsr
["nsd-id"])
7535 self
.logger
.debug(logging_text
+ stage
[1])
7536 nsd
= self
.db
.get_one("nsds", {"_id": db_nsr
["nsd-id"]})
7537 self
.fs
.sync(db_nsr
["nsd-id"])
7539 # read from db: vnfr's of this ns
7540 step
= "Getting vnfrs from db"
7541 db_vnfrs_list
= self
.db
.get_list("vnfrs", {"nsr-id-ref": nsr_id
})
7542 for vnfr
in db_vnfrs_list
:
7543 db_vnfrs
[vnfr
["_id"]] = vnfr
7544 self
.logger
.debug("ns.heal db_vnfrs={}".format(db_vnfrs
))
7546 # Check for each target VNF
7547 target_list
= db_nslcmop
.get("operationParams", {}).get("healVnfData", {})
7548 for target_vnf
in target_list
:
7549 # Find this VNF in the list from DB
7550 vnfr_id
= target_vnf
.get("vnfInstanceId", None)
7552 db_vnfr
= db_vnfrs
[vnfr_id
]
7553 vnfd_id
= db_vnfr
.get("vnfd-id")
7554 vnfd_ref
= db_vnfr
.get("vnfd-ref")
7555 vnfd
= self
.db
.get_one("vnfds", {"_id": vnfd_id
})
7556 base_folder
= vnfd
["_admin"]["storage"]
7561 nsi_id
= None # TODO put nsi_id when this nsr belongs to a NSI
7562 member_vnf_index
= db_vnfr
.get("member-vnf-index-ref")
7564 # Check each target VDU and deploy N2VC
7565 for target_vdu
in target_vnf
["additionalParams"].get("vdu", None):
7566 deploy_params_vdu
= target_vdu
7567 # Set run-day1 vnf level value if not vdu level value exists
7568 if not deploy_params_vdu
.get("run-day1") and target_vnf
["additionalParams"].get("run-day1"):
7569 deploy_params_vdu
["run-day1"] = target_vnf
["additionalParams"].get("run-day1")
7570 vdu_name
= target_vdu
.get("vdu-id", None)
7571 # TODO: Get vdu_id from vdud.
7573 # For multi instance VDU count-index is mandatory
7574 # For single session VDU count-indes is 0
7575 vdu_index
= target_vdu
.get("count-index",0)
7577 # n2vc_redesign STEP 3 to 6 Deploy N2VC
7578 stage
[1] = "Deploying Execution Environments."
7579 self
.logger
.debug(logging_text
+ stage
[1])
7581 # VNF Level charm. Normal case when proxy charms.
7582 # If target instance is management machine continue with actions: recreate EE for native charms or reinject juju key for proxy charms.
7583 descriptor_config
= get_configuration(vnfd
, vnfd_ref
)
7584 if descriptor_config
:
7585 # Continue if healed machine is management machine
7586 vnf_ip_address
= db_vnfr
.get("ip-address")
7587 target_instance
= None
7588 for instance
in db_vnfr
.get("vdur", None):
7589 if ( instance
["vdu-name"] == vdu_name
and instance
["count-index"] == vdu_index
):
7590 target_instance
= instance
7592 if vnf_ip_address
== target_instance
.get("ip-address"):
7594 logging_text
=logging_text
7595 + "member_vnf_index={}, vdu_name={}, vdu_index={} ".format(
7596 member_vnf_index
, vdu_name
, vdu_index
7600 nslcmop_id
=nslcmop_id
,
7606 member_vnf_index
=member_vnf_index
,
7609 deploy_params
=deploy_params_vdu
,
7610 descriptor_config
=descriptor_config
,
7611 base_folder
=base_folder
,
7612 task_instantiation_info
=tasks_dict_info
,
7616 # VDU Level charm. Normal case with native charms.
7617 descriptor_config
= get_configuration(vnfd
, vdu_name
)
7618 if descriptor_config
:
7620 logging_text
=logging_text
7621 + "member_vnf_index={}, vdu_name={}, vdu_index={} ".format(
7622 member_vnf_index
, vdu_name
, vdu_index
7626 nslcmop_id
=nslcmop_id
,
7632 member_vnf_index
=member_vnf_index
,
7633 vdu_index
=vdu_index
,
7635 deploy_params
=deploy_params_vdu
,
7636 descriptor_config
=descriptor_config
,
7637 base_folder
=base_folder
,
7638 task_instantiation_info
=tasks_dict_info
,
7643 ROclient
.ROClientException
,
7648 self
.logger
.error(logging_text
+ "Exit Exception {}".format(e
))
7650 except asyncio
.CancelledError
:
7652 logging_text
+ "Cancelled Exception while '{}'".format(step
)
7654 exc
= "Operation was cancelled"
7655 except Exception as e
:
7656 exc
= traceback
.format_exc()
7657 self
.logger
.critical(
7658 logging_text
+ "Exit Exception {} {}".format(type(e
).__name
__, e
),
7663 stage
[1] = "Waiting for healing pending tasks."
7664 self
.logger
.debug(logging_text
+ stage
[1])
7665 exc
= await self
._wait
_for
_tasks
(
7668 self
.timeout_ns_deploy
,
7676 ] = error_description_nslcmop
= "FAILED {}: {}".format(step
, exc
)
7677 nslcmop_operation_state
= "FAILED"
7679 db_nsr_update
["operational-status"] = old_operational_status
7680 db_nsr_update
["config-status"] = old_config_status
7683 ] = "FAILED healing nslcmop={} {}: {}".format(
7684 nslcmop_id
, step
, exc
7686 for task
, task_name
in tasks_dict_info
.items():
7687 if not task
.done() or task
.cancelled() or task
.exception():
7688 if task_name
.startswith(self
.task_name_deploy_vca
):
7689 # A N2VC task is pending
7690 db_nsr_update
["config-status"] = "failed"
7692 # RO task is pending
7693 db_nsr_update
["operational-status"] = "failed"
7695 error_description_nslcmop
= None
7696 nslcmop_operation_state
= "COMPLETED"
7697 db_nslcmop_update
["detailed-status"] = "Done"
7698 db_nsr_update
["detailed-status"] = "Done"
7699 db_nsr_update
["operational-status"] = "running"
7700 db_nsr_update
["config-status"] = "configured"
7702 self
._write
_op
_status
(
7705 error_message
=error_description_nslcmop
,
7706 operation_state
=nslcmop_operation_state
,
7707 other_update
=db_nslcmop_update
,
7710 self
._write
_ns
_status
(
7713 current_operation
="IDLE",
7714 current_operation_id
=None,
7715 other_update
=db_nsr_update
,
7718 if nslcmop_operation_state
:
7722 "nslcmop_id": nslcmop_id
,
7723 "operationState": nslcmop_operation_state
,
7725 await self
.msg
.aiowrite("ns", "healed", msg
, loop
=self
.loop
)
7726 except Exception as e
:
7728 logging_text
+ "kafka_write notification Exception {}".format(e
)
7730 self
.logger
.debug(logging_text
+ "Exit")
7731 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_heal")
7742 :param logging_text: preffix text to use at logging
7743 :param nsr_id: nsr identity
7744 :param db_nslcmop: database content of ns operation, in this case, 'instantiate'
7745 :param stage: list with 3 items: [general stage, tasks, vim_specific]. This task will write over vim_specific
7746 :return: None or exception
7748 def get_vim_account(vim_account_id
):
7750 if vim_account_id
in db_vims
:
7751 return db_vims
[vim_account_id
]
7752 db_vim
= self
.db
.get_one("vim_accounts", {"_id": vim_account_id
})
7753 db_vims
[vim_account_id
] = db_vim
7758 ns_params
= db_nslcmop
.get("operationParams")
7759 if ns_params
and ns_params
.get("timeout_ns_heal"):
7760 timeout_ns_heal
= ns_params
["timeout_ns_heal"]
7762 timeout_ns_heal
= self
.timeout
.get(
7763 "ns_heal", self
.timeout_ns_heal
7768 nslcmop_id
= db_nslcmop
["_id"]
7770 "action_id": nslcmop_id
,
7772 self
.logger
.warning("db_nslcmop={} and timeout_ns_heal={}".format(db_nslcmop
,timeout_ns_heal
))
7773 target
.update(db_nslcmop
.get("operationParams", {}))
7775 self
.logger
.debug("Send to RO > nsr_id={} target={}".format(nsr_id
, target
))
7776 desc
= await self
.RO
.recreate(nsr_id
, target
)
7777 self
.logger
.debug("RO return > {}".format(desc
))
7778 action_id
= desc
["action_id"]
7779 # waits for RO to complete because Reinjecting juju key at ro can find VM in state Deleted
7780 await self
._wait
_ng
_ro
(
7781 nsr_id
, action_id
, nslcmop_id
, start_heal
, timeout_ns_heal
, stage
,
7787 "_admin.deployed.RO.operational-status": "running",
7788 "detailed-status": " ".join(stage
),
7790 self
.update_db_2("nsrs", nsr_id
, db_nsr_update
)
7791 self
._write
_op
_status
(nslcmop_id
, stage
)
7793 logging_text
+ "ns healed at RO. RO_id={}".format(action_id
)
7796 except Exception as e
:
7797 stage
[2] = "ERROR healing at VIM"
7798 #self.set_vnfr_at_error(db_vnfrs, str(e))
7800 "Error healing at VIM {}".format(e
),
7801 exc_info
=not isinstance(
7804 ROclient
.ROClientException
,
7830 task_instantiation_info
,
7833 # launch instantiate_N2VC in a asyncio task and register task object
7834 # Look where information of this charm is at database <nsrs>._admin.deployed.VCA
7835 # if not found, create one entry and update database
7836 # fill db_nsr._admin.deployed.VCA.<index>
7839 logging_text
+ "_deploy_n2vc vnfd_id={}, vdu_id={}".format(vnfd_id
, vdu_id
)
7841 if "execution-environment-list" in descriptor_config
:
7842 ee_list
= descriptor_config
.get("execution-environment-list", [])
7843 elif "juju" in descriptor_config
:
7844 ee_list
= [descriptor_config
] # ns charms
7845 else: # other types as script are not supported
7848 for ee_item
in ee_list
:
7851 + "_deploy_n2vc ee_item juju={}, helm={}".format(
7852 ee_item
.get("juju"), ee_item
.get("helm-chart")
7855 ee_descriptor_id
= ee_item
.get("id")
7856 if ee_item
.get("juju"):
7857 vca_name
= ee_item
["juju"].get("charm")
7860 if ee_item
["juju"].get("charm") is not None
7863 if ee_item
["juju"].get("cloud") == "k8s":
7864 vca_type
= "k8s_proxy_charm"
7865 elif ee_item
["juju"].get("proxy") is False:
7866 vca_type
= "native_charm"
7867 elif ee_item
.get("helm-chart"):
7868 vca_name
= ee_item
["helm-chart"]
7869 if ee_item
.get("helm-version") and ee_item
.get("helm-version") == "v2":
7872 vca_type
= "helm-v3"
7875 logging_text
+ "skipping non juju neither charm configuration"
7880 for vca_index
, vca_deployed
in enumerate(
7881 db_nsr
["_admin"]["deployed"]["VCA"]
7883 if not vca_deployed
:
7886 vca_deployed
.get("member-vnf-index") == member_vnf_index
7887 and vca_deployed
.get("vdu_id") == vdu_id
7888 and vca_deployed
.get("kdu_name") == kdu_name
7889 and vca_deployed
.get("vdu_count_index", 0) == vdu_index
7890 and vca_deployed
.get("ee_descriptor_id") == ee_descriptor_id
7894 # not found, create one.
7896 "ns" if not member_vnf_index
else "vnf/{}".format(member_vnf_index
)
7899 target
+= "/vdu/{}/{}".format(vdu_id
, vdu_index
or 0)
7901 target
+= "/kdu/{}".format(kdu_name
)
7903 "target_element": target
,
7904 # ^ target_element will replace member-vnf-index, kdu_name, vdu_id ... in a single string
7905 "member-vnf-index": member_vnf_index
,
7907 "kdu_name": kdu_name
,
7908 "vdu_count_index": vdu_index
,
7909 "operational-status": "init", # TODO revise
7910 "detailed-status": "", # TODO revise
7911 "step": "initial-deploy", # TODO revise
7913 "vdu_name": vdu_name
,
7915 "ee_descriptor_id": ee_descriptor_id
,
7919 # create VCA and configurationStatus in db
7921 "_admin.deployed.VCA.{}".format(vca_index
): vca_deployed
,
7922 "configurationStatus.{}".format(vca_index
): dict(),
7924 self
.update_db_2("nsrs", nsr_id
, db_dict
)
7926 db_nsr
["_admin"]["deployed"]["VCA"].append(vca_deployed
)
7928 self
.logger
.debug("N2VC > NSR_ID > {}".format(nsr_id
))
7929 self
.logger
.debug("N2VC > DB_NSR > {}".format(db_nsr
))
7930 self
.logger
.debug("N2VC > VCA_DEPLOYED > {}".format(vca_deployed
))
7933 task_n2vc
= asyncio
.ensure_future(
7935 logging_text
=logging_text
,
7936 vca_index
=vca_index
,
7942 vdu_index
=vdu_index
,
7943 deploy_params
=deploy_params
,
7944 config_descriptor
=descriptor_config
,
7945 base_folder
=base_folder
,
7946 nslcmop_id
=nslcmop_id
,
7950 ee_config_descriptor
=ee_item
,
7953 self
.lcm_tasks
.register(
7957 "instantiate_N2VC-{}".format(vca_index
),
7960 task_instantiation_info
[
7962 ] = self
.task_name_deploy_vca
+ " {}.{}".format(
7963 member_vnf_index
or "", vdu_id
or ""
7966 async def heal_N2VC(
7983 ee_config_descriptor
,
7985 nsr_id
= db_nsr
["_id"]
7986 db_update_entry
= "_admin.deployed.VCA.{}.".format(vca_index
)
7987 vca_deployed_list
= db_nsr
["_admin"]["deployed"]["VCA"]
7988 vca_deployed
= db_nsr
["_admin"]["deployed"]["VCA"][vca_index
]
7989 osm_config
= {"osm": {"ns_id": db_nsr
["_id"]}}
7991 "collection": "nsrs",
7992 "filter": {"_id": nsr_id
},
7993 "path": db_update_entry
,
7999 element_under_configuration
= nsr_id
8003 vnfr_id
= db_vnfr
["_id"]
8004 osm_config
["osm"]["vnf_id"] = vnfr_id
8006 namespace
= "{nsi}.{ns}".format(nsi
=nsi_id
if nsi_id
else "", ns
=nsr_id
)
8008 if vca_type
== "native_charm":
8011 index_number
= vdu_index
or 0
8014 element_type
= "VNF"
8015 element_under_configuration
= vnfr_id
8016 namespace
+= ".{}-{}".format(vnfr_id
, index_number
)
8018 namespace
+= ".{}-{}".format(vdu_id
, index_number
)
8019 element_type
= "VDU"
8020 element_under_configuration
= "{}-{}".format(vdu_id
, index_number
)
8021 osm_config
["osm"]["vdu_id"] = vdu_id
8023 namespace
+= ".{}".format(kdu_name
)
8024 element_type
= "KDU"
8025 element_under_configuration
= kdu_name
8026 osm_config
["osm"]["kdu_name"] = kdu_name
8029 if base_folder
["pkg-dir"]:
8030 artifact_path
= "{}/{}/{}/{}".format(
8031 base_folder
["folder"],
8032 base_folder
["pkg-dir"],
8035 in ("native_charm", "lxc_proxy_charm", "k8s_proxy_charm")
8040 artifact_path
= "{}/Scripts/{}/{}/".format(
8041 base_folder
["folder"],
8044 in ("native_charm", "lxc_proxy_charm", "k8s_proxy_charm")
8049 self
.logger
.debug("Artifact path > {}".format(artifact_path
))
8051 # get initial_config_primitive_list that applies to this element
8052 initial_config_primitive_list
= config_descriptor
.get(
8053 "initial-config-primitive"
8057 "Initial config primitive list > {}".format(
8058 initial_config_primitive_list
8062 # add config if not present for NS charm
8063 ee_descriptor_id
= ee_config_descriptor
.get("id")
8064 self
.logger
.debug("EE Descriptor > {}".format(ee_descriptor_id
))
8065 initial_config_primitive_list
= get_ee_sorted_initial_config_primitive_list(
8066 initial_config_primitive_list
, vca_deployed
, ee_descriptor_id
8070 "Initial config primitive list #2 > {}".format(
8071 initial_config_primitive_list
8074 # n2vc_redesign STEP 3.1
8075 # find old ee_id if exists
8076 ee_id
= vca_deployed
.get("ee_id")
8078 vca_id
= self
.get_vca_id(db_vnfr
, db_nsr
)
8079 # create or register execution environment in VCA. Only for native charms when healing
8080 if vca_type
== "native_charm":
8081 step
= "Waiting to VM being up and getting IP address"
8082 self
.logger
.debug(logging_text
+ step
)
8083 rw_mgmt_ip
= await self
.wait_vm_up_insert_key_ro(
8092 credentials
= {"hostname": rw_mgmt_ip
}
8094 username
= deep_get(
8095 config_descriptor
, ("config-access", "ssh-access", "default-user")
8097 # TODO remove this when changes on IM regarding config-access:ssh-access:default-user were
8098 # merged. Meanwhile let's get username from initial-config-primitive
8099 if not username
and initial_config_primitive_list
:
8100 for config_primitive
in initial_config_primitive_list
:
8101 for param
in config_primitive
.get("parameter", ()):
8102 if param
["name"] == "ssh-username":
8103 username
= param
["value"]
8107 "Cannot determine the username neither with 'initial-config-primitive' nor with "
8108 "'config-access.ssh-access.default-user'"
8110 credentials
["username"] = username
8112 # n2vc_redesign STEP 3.2
8113 # TODO: Before healing at RO it is needed to destroy native charm units to be deleted.
8114 self
._write
_configuration
_status
(
8116 vca_index
=vca_index
,
8117 status
="REGISTERING",
8118 element_under_configuration
=element_under_configuration
,
8119 element_type
=element_type
,
8122 step
= "register execution environment {}".format(credentials
)
8123 self
.logger
.debug(logging_text
+ step
)
8124 ee_id
= await self
.vca_map
[vca_type
].register_execution_environment(
8125 credentials
=credentials
,
8126 namespace
=namespace
,
8131 # update ee_id en db
8133 "_admin.deployed.VCA.{}.ee_id".format(vca_index
): ee_id
,
8135 self
.update_db_2("nsrs", nsr_id
, db_dict_ee_id
)
8137 # for compatibility with MON/POL modules, the need model and application name at database
8138 # TODO ask MON/POL if needed to not assuming anymore the format "model_name.application_name"
8139 # Not sure if this need to be done when healing
8141 ee_id_parts = ee_id.split(".")
8142 db_nsr_update = {db_update_entry + "ee_id": ee_id}
8143 if len(ee_id_parts) >= 2:
8144 model_name = ee_id_parts[0]
8145 application_name = ee_id_parts[1]
8146 db_nsr_update[db_update_entry + "model"] = model_name
8147 db_nsr_update[db_update_entry + "application"] = application_name
8150 # n2vc_redesign STEP 3.3
8151 # Install configuration software. Only for native charms.
8152 step
= "Install configuration Software"
8154 self
._write
_configuration
_status
(
8156 vca_index
=vca_index
,
8157 status
="INSTALLING SW",
8158 element_under_configuration
=element_under_configuration
,
8159 element_type
=element_type
,
8160 #other_update=db_nsr_update,
8164 # TODO check if already done
8165 self
.logger
.debug(logging_text
+ step
)
8167 if vca_type
== "native_charm":
8168 config_primitive
= next(
8169 (p
for p
in initial_config_primitive_list
if p
["name"] == "config"),
8172 if config_primitive
:
8173 config
= self
._map
_primitive
_params
(
8174 config_primitive
, {}, deploy_params
8176 await self
.vca_map
[vca_type
].install_configuration_sw(
8178 artifact_path
=artifact_path
,
8186 # write in db flag of configuration_sw already installed
8188 "nsrs", nsr_id
, {db_update_entry
+ "config_sw_installed": True}
8191 # Not sure if this need to be done when healing
8193 # add relations for this VCA (wait for other peers related with this VCA)
8194 await self._add_vca_relations(
8195 logging_text=logging_text,
8198 vca_index=vca_index,
8202 # if SSH access is required, then get execution environment SSH public
8203 # if native charm we have waited already to VM be UP
8204 if vca_type
in ("k8s_proxy_charm", "lxc_proxy_charm", "helm", "helm-v3"):
8207 # self.logger.debug("get ssh key block")
8209 config_descriptor
, ("config-access", "ssh-access", "required")
8211 # self.logger.debug("ssh key needed")
8212 # Needed to inject a ssh key
8215 ("config-access", "ssh-access", "default-user"),
8217 step
= "Install configuration Software, getting public ssh key"
8218 pub_key
= await self
.vca_map
[vca_type
].get_ee_ssh_public__key(
8219 ee_id
=ee_id
, db_dict
=db_dict
, vca_id
=vca_id
8222 step
= "Insert public key into VM user={} ssh_key={}".format(
8226 # self.logger.debug("no need to get ssh key")
8227 step
= "Waiting to VM being up and getting IP address"
8228 self
.logger
.debug(logging_text
+ step
)
8230 # n2vc_redesign STEP 5.1
8231 # wait for RO (ip-address) Insert pub_key into VM
8232 # IMPORTANT: We need do wait for RO to complete healing operation.
8233 await self
._wait
_heal
_ro
(nsr_id
,self
.timeout_ns_heal
)
8236 rw_mgmt_ip
= await self
.wait_kdu_up(
8237 logging_text
, nsr_id
, vnfr_id
, kdu_name
8240 rw_mgmt_ip
= await self
.wait_vm_up_insert_key_ro(
8250 rw_mgmt_ip
= None # This is for a NS configuration
8252 self
.logger
.debug(logging_text
+ " VM_ip_address={}".format(rw_mgmt_ip
))
8254 # store rw_mgmt_ip in deploy params for later replacement
8255 deploy_params
["rw_mgmt_ip"] = rw_mgmt_ip
8258 # get run-day1 operation parameter
8259 runDay1
= deploy_params
.get("run-day1",False)
8260 self
.logger
.debug(" Healing vnf={}, vdu={}, runDay1 ={}".format(vnfr_id
,vdu_id
,runDay1
))
8262 # n2vc_redesign STEP 6 Execute initial config primitive
8263 step
= "execute initial config primitive"
8265 # wait for dependent primitives execution (NS -> VNF -> VDU)
8266 if initial_config_primitive_list
:
8267 await self
._wait
_dependent
_n
2vc
(nsr_id
, vca_deployed_list
, vca_index
)
8269 # stage, in function of element type: vdu, kdu, vnf or ns
8270 my_vca
= vca_deployed_list
[vca_index
]
8271 if my_vca
.get("vdu_id") or my_vca
.get("kdu_name"):
8273 stage
[0] = "Stage 3/5: running Day-1 primitives for VDU."
8274 elif my_vca
.get("member-vnf-index"):
8276 stage
[0] = "Stage 4/5: running Day-1 primitives for VNF."
8279 stage
[0] = "Stage 5/5: running Day-1 primitives for NS."
8281 self
._write
_configuration
_status
(
8282 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="EXECUTING PRIMITIVE"
8285 self
._write
_op
_status
(op_id
=nslcmop_id
, stage
=stage
)
8287 check_if_terminated_needed
= True
8288 for initial_config_primitive
in initial_config_primitive_list
:
8289 # adding information on the vca_deployed if it is a NS execution environment
8290 if not vca_deployed
["member-vnf-index"]:
8291 deploy_params
["ns_config_info"] = json
.dumps(
8292 self
._get
_ns
_config
_info
(nsr_id
)
8294 # TODO check if already done
8295 primitive_params_
= self
._map
_primitive
_params
(
8296 initial_config_primitive
, {}, deploy_params
8299 step
= "execute primitive '{}' params '{}'".format(
8300 initial_config_primitive
["name"], primitive_params_
8302 self
.logger
.debug(logging_text
+ step
)
8303 await self
.vca_map
[vca_type
].exec_primitive(
8305 primitive_name
=initial_config_primitive
["name"],
8306 params_dict
=primitive_params_
,
8311 # Once some primitive has been exec, check and write at db if it needs to exec terminated primitives
8312 if check_if_terminated_needed
:
8313 if config_descriptor
.get("terminate-config-primitive"):
8315 "nsrs", nsr_id
, {db_update_entry
+ "needed_terminate": True}
8317 check_if_terminated_needed
= False
8319 # TODO register in database that primitive is done
8321 # STEP 7 Configure metrics
8322 # Not sure if this need to be done when healing
8324 if vca_type == "helm" or vca_type == "helm-v3":
8325 prometheus_jobs = await self.extract_prometheus_scrape_jobs(
8327 artifact_path=artifact_path,
8328 ee_config_descriptor=ee_config_descriptor,
8331 target_ip=rw_mgmt_ip,
8337 {db_update_entry + "prometheus_jobs": prometheus_jobs},
8340 for job in prometheus_jobs:
8343 {"job_name": job["job_name"]},
8346 fail_on_empty=False,
8350 step
= "instantiated at VCA"
8351 self
.logger
.debug(logging_text
+ step
)
8353 self
._write
_configuration
_status
(
8354 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="READY"
8357 except Exception as e
: # TODO not use Exception but N2VC exception
8358 # self.update_db_2("nsrs", nsr_id, {db_update_entry + "instantiation": "FAILED"})
8360 e
, (DbException
, N2VCException
, LcmException
, asyncio
.CancelledError
)
8363 "Exception while {} : {}".format(step
, e
), exc_info
=True
8365 self
._write
_configuration
_status
(
8366 nsr_id
=nsr_id
, vca_index
=vca_index
, status
="BROKEN"
8368 raise LcmException("{} {}".format(step
, e
)) from e
8370 async def _wait_heal_ro(
8376 while time() <= start_time
+ timeout
:
8377 db_nsr
= self
.db
.get_one("nsrs", {"_id": nsr_id
})
8378 operational_status_ro
= db_nsr
["_admin"]["deployed"]["RO"]["operational-status"]
8379 self
.logger
.debug("Wait Heal RO > {}".format(operational_status_ro
))
8380 if operational_status_ro
!= "healing":
8382 await asyncio
.sleep(15, loop
=self
.loop
)
8383 else: # timeout_ns_deploy
8384 raise NgRoException("Timeout waiting ns to deploy")
8386 async def vertical_scale(self
, nsr_id
, nslcmop_id
):
8388 Vertical Scale the VDUs in a NS
8390 :param: nsr_id: NS Instance ID
8391 :param: nslcmop_id: nslcmop ID of migrate
8394 # Try to lock HA task here
8395 task_is_locked_by_me
= self
.lcm_tasks
.lock_HA("ns", "nslcmops", nslcmop_id
)
8396 if not task_is_locked_by_me
:
8398 logging_text
= "Task ns={} vertical scale ".format(nsr_id
)
8399 self
.logger
.debug(logging_text
+ "Enter")
8400 # get all needed from database
8402 db_nslcmop_update
= {}
8403 nslcmop_operation_state
= None
8407 # in case of error, indicates what part of scale was failed to put nsr at error status
8408 start_deploy
= time()
8411 # wait for any previous tasks in process
8412 step
= "Waiting for previous operations to terminate"
8413 await self
.lcm_tasks
.waitfor_related_HA('ns', 'nslcmops', nslcmop_id
)
8415 self
._write
_ns
_status
(
8418 current_operation
="VerticalScale",
8419 current_operation_id
=nslcmop_id
8421 step
= "Getting nslcmop from database"
8422 self
.logger
.debug(step
+ " after having waited for previous tasks to be completed")
8423 db_nslcmop
= self
.db
.get_one("nslcmops", {"_id": nslcmop_id
})
8424 operationParams
= db_nslcmop
.get("operationParams")
8426 target
.update(operationParams
)
8427 desc
= await self
.RO
.vertical_scale(nsr_id
, target
)
8428 self
.logger
.debug("RO return > {}".format(desc
))
8429 action_id
= desc
["action_id"]
8430 await self
._wait
_ng
_ro
(
8431 nsr_id
, action_id
, nslcmop_id
, start_deploy
, self
.timeout_verticalscale
,
8432 operation
="verticalscale"
8434 except (ROclient
.ROClientException
, DbException
, LcmException
) as e
:
8435 self
.logger
.error("Exit Exception {}".format(e
))
8437 except asyncio
.CancelledError
:
8438 self
.logger
.error("Cancelled Exception while '{}'".format(step
))
8439 exc
= "Operation was cancelled"
8440 except Exception as e
:
8441 exc
= traceback
.format_exc()
8442 self
.logger
.critical("Exit Exception {} {}".format(type(e
).__name
__, e
), exc_info
=True)
8444 self
._write
_ns
_status
(
8447 current_operation
="IDLE",
8448 current_operation_id
=None,
8453 ] = "FAILED {}: {}".format(step
, exc
)
8454 nslcmop_operation_state
= "FAILED"
8456 nslcmop_operation_state
= "COMPLETED"
8457 db_nslcmop_update
["detailed-status"] = "Done"
8458 db_nsr_update
["detailed-status"] = "Done"
8460 self
._write
_op
_status
(
8464 operation_state
=nslcmop_operation_state
,
8465 other_update
=db_nslcmop_update
,
8467 if nslcmop_operation_state
:
8471 "nslcmop_id": nslcmop_id
,
8472 "operationState": nslcmop_operation_state
,
8474 await self
.msg
.aiowrite("ns", "verticalscaled", msg
, loop
=self
.loop
)
8475 except Exception as e
:
8477 logging_text
+ "kafka_write notification Exception {}".format(e
)
8479 self
.logger
.debug(logging_text
+ "Exit")
8480 self
.lcm_tasks
.remove("ns", nsr_id
, nslcmop_id
, "ns_verticalscale")