X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=osm_lcm%2Flcm_utils.py;h=12fd7fbb0d6624397dc9e1f8a69e833aef3c79ed;hb=7f26b3f6740e12dd35d8024b14c3fe3a32ec5dbf;hp=1854da7052a1a75666a1a57bc7669c61f0d6bd4e;hpb=d708354a4c899a118bc68a93caf8b22aabd2e723;p=osm%2FLCM.git diff --git a/osm_lcm/lcm_utils.py b/osm_lcm/lcm_utils.py index 1854da7..12fd7fb 100644 --- a/osm_lcm/lcm_utils.py +++ b/osm_lcm/lcm_utils.py @@ -19,10 +19,17 @@ import asyncio import checksumdir from collections import OrderedDict +import hashlib import os +import shutil +import traceback from time import time + +from osm_common.fsbase import FsException from osm_lcm.data_utils.database.database import Database from osm_lcm.data_utils.filesystem.filesystem import Filesystem +import yaml +from zipfile import ZipFile, BadZipfile # from osm_common.dbbase import DbException @@ -33,10 +40,6 @@ class LcmException(Exception): pass -class LcmExceptionNoMgmtIP(LcmException): - pass - - class LcmExceptionExit(LcmException): pass @@ -155,6 +158,46 @@ def populate_dict(target_dict, key_list, value): target_dict[key_list[-1]] = value +def get_ee_id_parts(ee_id): + """ + Parses ee_id stored at database that can be either 'version:namespace.helm_id' or only + namespace.helm_id for backward compatibility + If exists helm version can be helm-v3 or helm (helm-v2 old version) + """ + version, _, part_id = ee_id.rpartition(":") + namespace, _, helm_id = part_id.rpartition(".") + return version, namespace, helm_id + + +def vld_to_ro_ip_profile(source_data): + if source_data: + return { + "ip_version": "IPv4" + if "v4" in source_data.get("ip-version", "ipv4") + else "IPv6", + "subnet_address": source_data.get("cidr") + or source_data.get("subnet-address"), + "gateway_address": source_data.get("gateway-ip") + or source_data.get("gateway-address"), + "dns_address": ";".join( + [v["address"] for v in source_data["dns-server"] if v.get("address")] + ) + if source_data.get("dns-server") + else None, + "dhcp_enabled": source_data.get("dhcp-params", {}).get("enabled", False) + or source_data.get("dhcp-enabled", False), + "dhcp_start_address": source_data["dhcp-params"].get("start-address") + if source_data.get("dhcp-params") + else None, + "dhcp_count": source_data["dhcp-params"].get("count") + if source_data.get("dhcp-params") + else None, + "ipv6_address_mode": source_data["ipv6-address-mode"] + if "ipv6-address-mode" in source_data + else None, + } + + class LcmBase: def __init__(self, msg, logger): """ @@ -183,6 +226,54 @@ class LcmBase: # except DbException as e: # self.logger.error("Updating {} _id={} with '{}'. Error: {}".format(item, _id, _desc, e)) + @staticmethod + def calculate_charm_hash(zipped_file): + """Calculate the hash of charm files which ends with .charm + + Args: + zipped_file (str): Existing charm package full path + + Returns: + hex digest (str): The hash of the charm file + """ + filehash = hashlib.sha256() + with open(zipped_file, mode="rb") as file: + contents = file.read() + filehash.update(contents) + return filehash.hexdigest() + + @staticmethod + def compare_charm_hash(current_charm, target_charm): + """Compare the existing charm and the target charm if the charms + are given as zip files ends with .charm + + Args: + current_charm (str): Existing charm package full path + target_charm (str): Target charm package full path + + Returns: + True/False (bool): if charm has changed it returns True + """ + return LcmBase.calculate_charm_hash( + current_charm + ) != LcmBase.calculate_charm_hash(target_charm) + + @staticmethod + def compare_charmdir_hash(current_charm_dir, target_charm_dir): + """Compare the existing charm and the target charm if the charms + are given as directories + + Args: + current_charm_dir (str): Existing charm package directory path + target_charm_dir (str): Target charm package directory path + + Returns: + True/False (bool): if charm has changed it returns True + """ + return checksumdir.dirhash(current_charm_dir) != checksumdir.dirhash( + target_charm_dir + ) + def check_charm_hash_changed( self, current_charm_path: str, target_charm_path: str ) -> bool: @@ -197,25 +288,165 @@ class LcmBase: True/False (bool): if charm has changed it returns True """ - # Check if the charm artifacts are available - if os.path.exists(self.fs.path + current_charm_path) and os.path.exists( - self.fs.path + target_charm_path - ): - # Compare the hash of charm folders - if checksumdir.dirhash( - self.fs.path + current_charm_path - ) != checksumdir.dirhash(self.fs.path + target_charm_path): + try: + # Check if the charm artifacts are available + current_charm = self.fs.path + current_charm_path + target_charm = self.fs.path + target_charm_path - return True + if os.path.exists(current_charm) and os.path.exists(target_charm): + # Compare the hash of .charm files + if current_charm.endswith(".charm"): + return LcmBase.compare_charm_hash(current_charm, target_charm) - return False + # Compare the hash of charm folders + return LcmBase.compare_charmdir_hash(current_charm, target_charm) - else: - raise LcmException( - "Charm artifact {} does not exist in the VNF Package".format( - self.fs.path + target_charm_path + else: + raise LcmException( + "Charm artifact {} does not exist in the VNF Package".format( + self.fs.path + target_charm_path + ) ) + except (IOError, OSError, TypeError) as error: + self.logger.debug(traceback.format_exc()) + self.logger.error(f"{error} occured while checking the charm hashes") + raise LcmException(error) + + @staticmethod + def get_charm_name(charm_metadata_file: str) -> str: + """Get the charm name from metadata file. + + Args: + charm_metadata_file (str): charm metadata file full path + + Returns: + charm_name (str): charm name + + """ + # Read charm metadata.yaml to get the charm name + with open(charm_metadata_file, "r") as metadata_file: + content = yaml.safe_load(metadata_file) + charm_name = content["name"] + return str(charm_name) + + def _get_charm_path( + self, nsd_package_path: str, nsd_package_name: str, charm_folder_name: str + ) -> str: + """Get the full path of charm folder. + + Args: + nsd_package_path (str): NSD package full path + nsd_package_name (str): NSD package name + charm_folder_name (str): folder name + + Returns: + charm_path (str): charm folder full path + """ + charm_path = ( + self.fs.path + + nsd_package_path + + "/" + + nsd_package_name + + "/charms/" + + charm_folder_name + ) + return charm_path + + def _get_charm_metadata_file( + self, + charm_folder_name: str, + nsd_package_path: str, + nsd_package_name: str, + charm_path: str = None, + ) -> str: + """Get the path of charm metadata file. + + Args: + charm_folder_name (str): folder name + nsd_package_path (str): NSD package full path + nsd_package_name (str): NSD package name + charm_path (str): Charm full path + + Returns: + charm_metadata_file_path (str): charm metadata file full path + + """ + # Locate the charm metadata.yaml + if charm_folder_name.endswith(".charm"): + extract_path = ( + self.fs.path + + nsd_package_path + + "/" + + nsd_package_name + + "/charms/" + + charm_folder_name.replace(".charm", "") ) + # Extract .charm to extract path + with ZipFile(charm_path, "r") as zipfile: + zipfile.extractall(extract_path) + return extract_path + "/metadata.yaml" + else: + return charm_path + "/metadata.yaml" + + def find_charm_name(self, db_nsr: dict, charm_folder_name: str) -> str: + """Get the charm name from metadata.yaml of charm package. + + Args: + db_nsr (dict): NS record as a dictionary + charm_folder_name (str): charm folder name + + Returns: + charm_name (str): charm name + """ + try: + if not charm_folder_name: + raise LcmException("charm_folder_name should be provided.") + + # Find nsd_package details: path, name + revision = db_nsr.get("revision", "") + + # Get the NSD package path + if revision: + nsd_package_path = db_nsr["nsd-id"] + ":" + str(revision) + db_nsd = self.db.get_one("nsds_revisions", {"_id": nsd_package_path}) + + else: + nsd_package_path = db_nsr["nsd-id"] + + db_nsd = self.db.get_one("nsds", {"_id": nsd_package_path}) + + # Get the NSD package name + nsd_package_name = db_nsd["_admin"]["storage"]["pkg-dir"] + + # Remove the existing nsd package and sync from FsMongo + shutil.rmtree(self.fs.path + nsd_package_path, ignore_errors=True) + self.fs.sync(from_path=nsd_package_path) + + # Get the charm path + charm_path = self._get_charm_path( + nsd_package_path, nsd_package_name, charm_folder_name + ) + + # Find charm metadata file full path + charm_metadata_file = self._get_charm_metadata_file( + charm_folder_name, nsd_package_path, nsd_package_name, charm_path + ) + + # Return charm name + return self.get_charm_name(charm_metadata_file) + + except ( + yaml.YAMLError, + IOError, + FsException, + KeyError, + TypeError, + FileNotFoundError, + BadZipfile, + ) as error: + self.logger.debug(traceback.format_exc()) + self.logger.error(f"{error} occured while getting the charm name") + raise LcmException(error) class TaskRegistry(LcmBase): @@ -336,17 +567,19 @@ class TaskRegistry(LcmBase): """ Cancel all active tasks of a concrete ns, nsi, vim_account, sdn identified for _id. If op_id is supplied only this is cancelled, and the same with task_name + :return: cancelled task to be awaited if needed """ if not self.task_registry[topic].get(_id): return for op_id in reversed(self.task_registry[topic][_id]): if target_op_id and target_op_id != op_id: continue - for task_name, task in self.task_registry[topic][_id][op_id].items(): + for task_name, task in list(self.task_registry[topic][_id][op_id].items()): if target_task_name and target_task_name != task_name: continue # result = task.cancel() + yield task # if result: # self.logger.debug("{} _id={} order_id={} task={} cancelled".format(topic, _id, op_id, task_name))