import abc
import asyncio
+from typing import Union
import time
from n2vc.loggable import 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):
"""
@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
self,
cluster_uuid: str,
kdu_model: str,
+ kdu_instance: str,
atomic: bool = True,
timeout: float = 300,
params: dict = None,
- 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
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
path: <str>},
e.g. {collection: "nsrs", filter:
{_id: <nsd-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
: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:
"""
"""
@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
: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:
"""
+ @abc.abstractmethod
+ 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.
+
+ :param cluster_uuid: UUID of a K8s cluster known by OSM
+ :param kdu_instance: unique name for the KDU instance
+ :param namespace: K8s namespace used by the KDU instance
+ :return: If successful, it will return a list of services, Each service
+ can have the following data:
+ - `name` of the service
+ - `type` type of service in the k8 cluster
+ - `ports` List of ports offered by the service, for each port includes at least
+ name, port, protocol
+ - `cluster_ip` Internal ip to be used inside k8s cluster
+ - `external_ip` List of external ips (in case they are available)
+ """
+
+ @abc.abstractmethod
+ 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.
+
+ :param cluster_uuid: UUID of a K8s cluster known by OSM
+ :param service_name: name of the K8s service in the specified namespace
+ :param namespace: K8s namespace used by the KDU instance
+ :return: If successful, it will return a list of services, Each service can have
+ the following data:
+ - `name` of the service
+ - `type` type of service in the k8 cluster
+ - `ports` List of ports offered by the service, for each port includes at least
+ name, port, protocol
+ - `cluster_ip` Internal ip to be used inside k8s cluster
+ - `external_ip` List of external ips (in case they are available)
+ """
+
"""
####################################################################################
################################### P R I V A T E ##################################
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")
self.log.debug("status={}".format(status))
try:
-
the_table = db_dict["collection"]
the_filter = db_dict["filter"]
the_path = db_dict["path"]