X-Git-Url: https://osm.etsi.org/gitweb/?p=osm%2FN2VC.git;a=blobdiff_plain;f=n2vc%2Fk8s_conn.py;h=89805b3211fdef9f0998a9b22121aee261d53078;hp=5bdc8acb2c6e804205d50510d612dafae9116be3;hb=HEAD;hpb=d99f3f2f67d693c30494be7ad19b97f3f5528961 diff --git a/n2vc/k8s_conn.py b/n2vc/k8s_conn.py index 5bdc8ac..3a1a5ef 100644 --- a/n2vc/k8s_conn.py +++ b/n2vc/k8s_conn.py @@ -22,6 +22,7 @@ import abc import asyncio +from typing import Union import time from n2vc.loggable import Loggable @@ -34,6 +35,10 @@ class K8sConnector(abc.ABC, Loggable): #################################################################################### """ + @staticmethod + def generate_kdu_instance_name(**kwargs): + raise NotImplementedError("Method not implemented") + def __init__(self, db: object, log: object = None, on_update_db=None): """ @@ -74,7 +79,14 @@ class K8sConnector(abc.ABC, Loggable): @abc.abstractmethod async def repo_add( - self, cluster_uuid: str, name: str, url: str, repo_type: str = "chart" + self, + cluster_uuid: str, + name: str, + url: str, + repo_type: str = "chart", + cert: str = None, + user: str = None, + password: str = None, ): """ Add a new repository to OSM database @@ -136,6 +148,7 @@ class K8sConnector(abc.ABC, Loggable): self, cluster_uuid: str, kdu_model: str, + kdu_instance: str, atomic: bool = True, timeout: float = 300, params: dict = None, @@ -154,6 +167,7 @@ class K8sConnector(abc.ABC, Loggable): - a name of chart/bundle available via the repos known by OSM - a path to a packaged chart/bundle - a path to an unpacked chart/bundle directory or a URL + :param kdu_instance: Kdu instance name :param atomic: If set, installation process purges chart/bundle on fail, also will wait until all the K8s objects are active :param timeout: Time in seconds to wait for the install of the chart/bundle @@ -180,6 +194,7 @@ class K8sConnector(abc.ABC, Loggable): timeout: float = 300, params: dict = None, db_dict: dict = None, + force: bool = False, ): """ Upgrades an existing KDU instance. It would implicitly use the `upgrade` call @@ -199,9 +214,67 @@ class K8sConnector(abc.ABC, Loggable): path: }, e.g. {collection: "nsrs", filter: {_id: , path: "_admin.deployed.K8S.3"} + :param force: force recreation of resources if necessary :return: reference to the new revision number of the KDU instance """ + @abc.abstractmethod + async def scale( + self, + kdu_instance: str, + scale: int, + resource_name: str, + total_timeout: float = 1800, + cluster_uuid: str = None, + kdu_model: str = None, + atomic: bool = True, + db_dict: dict = None, + **kwargs, + ) -> bool: + """Scale a resource in a KDU instance. + + Args: + kdu_instance: KDU instance name + scale: Scale to which to set the resource + resource_name: Resource name + total_timeout: The time, in seconds, to wait for the install + to finish + cluster_uuid: The UUID of the cluster + kdu_model: The chart/bundle reference + atomic: if set, upgrade process rolls back changes made in case of failed upgrade. + The --wait flag will be set automatically if --atomic is used + db_dict: Dictionary for any additional data + kwargs: Additional parameters + vca_id (str): VCA ID + + Returns: + True if successful, False otherwise + """ + + @abc.abstractmethod + async def get_scale_count( + self, + resource_name: str, + kdu_instance: str, + cluster_uuid: str, + kdu_model: str, + timeout: float = 300, + **kwargs, + ) -> int: + """Get a resource scale count in a KDU instance. + + Args: + resource_name: Resource name + kdu_instance: KDU instance name + cluster_uuid: The UUID of the cluster + kdu_model: chart/bundle reference + timeout: The time, in seconds, to wait + kwargs: Additional parameters + + Returns: + Resource instance count + """ + @abc.abstractmethod async def rollback( self, cluster_uuid: str, kdu_instance: str, revision=0, db_dict: dict = None @@ -258,6 +331,28 @@ class K8sConnector(abc.ABC, Loggable): :return: Returns the output of the action """ + @abc.abstractmethod + async def upgrade_charm( + self, + ee_id: str = None, + path: str = None, + charm_id: str = None, + charm_type: str = None, + timeout: float = None, + ) -> str: + """This method upgrade charms in VNFs + + Args: + ee_id: Execution environment id + path: Local path to the charm + charm_id: charm-id + charm_type: Charm type can be lxc-proxy-charm, native-charm or k8s-proxy-charm + timeout: (Float) Timeout for the ns update operation + + Returns: + The output of the update operation if status equals to "completed" + """ + @abc.abstractmethod async def inspect_kdu(self, kdu_model: str, repo_url: str = None) -> str: """ @@ -288,7 +383,9 @@ class K8sConnector(abc.ABC, Loggable): """ @abc.abstractmethod - async def status_kdu(self, cluster_uuid: str, kdu_instance: str) -> str: + async def status_kdu( + self, cluster_uuid: str, kdu_instance: str, yaml_format: str + ) -> Union[str, dict]: """ This call would retrieve tha current state of a given KDU instance. It would be would allow to retrieve the _composition_ (i.e. K8s objects) and _specific @@ -297,6 +394,8 @@ class K8sConnector(abc.ABC, Loggable): :param cluster_uuid: UUID of a K8s cluster known by OSM :param kdu_instance: unique name for the KDU instance + :param yaml_format: if the return shall be returned as an YAML string or as a + dictionary :return: If successful, it will return the following vector of arguments: - K8s `namespace` in the cluster where the KDU lives - `state` of the KDU instance. It can be: @@ -313,10 +412,9 @@ class K8sConnector(abc.ABC, Loggable): """ @abc.abstractmethod - async def get_services(self, - cluster_uuid: str, - kdu_instance: str, - namespace: str) -> list: + async def get_services( + self, cluster_uuid: str, kdu_instance: str, namespace: str + ) -> list: """ Returns a list of services defined for the specified kdu instance. @@ -334,10 +432,9 @@ class K8sConnector(abc.ABC, Loggable): """ @abc.abstractmethod - async def get_service(self, - cluster_uuid: str, - service_name: str, - namespace: str = None) -> object: + async def get_service( + self, cluster_uuid: str, service_name: str, namespace: str = None + ) -> object: """ Obtains the data of the specified service in the k8cluster. @@ -363,6 +460,18 @@ class K8sConnector(abc.ABC, Loggable): async def write_app_status_to_db( self, db_dict: dict, status: str, detailed_status: str, operation: str ) -> bool: + """ + This method will write the status of the application to the database. + + :param db_dict: A dictionary with the database necessary information. It shall contain the values for the keys: + - "collection": The Mongo DB collection to write to + - "filter": The query filter to use in the update process + - "path": The dot separated keys which targets the object to be updated + :param status: Status of the application + :param detailed_status: Detailed status of the application + :param operation: Operation that is being performed on the application + :return: True if successful + """ if not self.db: self.warning("No db => No database write") @@ -375,7 +484,6 @@ class K8sConnector(abc.ABC, Loggable): self.log.debug("status={}".format(status)) try: - the_table = db_dict["collection"] the_filter = db_dict["filter"] the_path = db_dict["path"]