Bug 1980 fixed

[osm/N2VC.git] / n2vc / k8s_helm_base_conn.py

diff --git a/n2vc/k8s_helm_base_conn.py b/n2vc/k8s_helm_base_conn.py
index 273b206..5079dbe 100644 (file)
--- a/n2vc/k8s_helm_base_conn.py
+++ b/n2vc/k8s_helm_base_conn.py
@@ -21,6 +21,7 @@
 ##
 import abc
 import asyncio
 ##
 import abc
 import asyncio

+from typing import Union

 import random
 import time
 import shlex
 import random
 import time
 import shlex


@@ -89,14 +90,18 @@ class K8sHelmBaseConnector(K8sConnector):
         if self._stable_repo_url == "None":
             self._stable_repo_url = None
 
         if self._stable_repo_url == "None":
             self._stable_repo_url = None
 

-    @staticmethod
-    def _get_namespace_cluster_id(cluster_uuid: str) -> (str, str):
+    def _get_namespace(self, cluster_uuid: str) -> str:

         """
         """

-        Parses cluster_uuid stored at database that can be either 'namespace:cluster_id' or only
-        cluster_id for backward compatibility
+        Obtains the namespace used by the cluster with the uuid passed by argument
+
+        param: cluster_uuid: cluster's uuid

         """
         """

-        namespace, _, cluster_id = cluster_uuid.rpartition(":")
-        return namespace, cluster_id
+
+        # first, obtain the cluster corresponding to the uuid passed by argument
+        k8scluster = self.db.get_one(
+            "k8sclusters", q_filter={"_id": cluster_uuid}, fail_on_empty=False
+        )
+        return k8scluster.get("namespace")

 
     async def init_env(
         self,
 
     async def init_env(
         self,


@@ -120,11 +125,9 @@ class K8sHelmBaseConnector(K8sConnector):
         """
 
         if reuse_cluster_uuid:
         """
 
         if reuse_cluster_uuid:

-            namespace_, cluster_id = self._get_namespace_cluster_id(reuse_cluster_uuid)
-            namespace = namespace_ or namespace
+            cluster_id = reuse_cluster_uuid

         else:
             cluster_id = str(uuid4())
         else:
             cluster_id = str(uuid4())

-        cluster_uuid = "{}:{}".format(namespace, cluster_id)

 
         self.log.debug(
             "Initializing K8S Cluster {}. namespace: {}".format(cluster_id, namespace)
 
         self.log.debug(
             "Initializing K8S Cluster {}. namespace: {}".format(cluster_id, namespace)


@@ -146,25 +149,31 @@ class K8sHelmBaseConnector(K8sConnector):
 
         self.log.info("Cluster {} initialized".format(cluster_id))
 
 
         self.log.info("Cluster {} initialized".format(cluster_id))
 

-        return cluster_uuid, n2vc_installed_sw
+        return cluster_id, n2vc_installed_sw

 
     async def repo_add(
 
     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,

     ):
     ):

-        _, cluster_id = self._get_namespace_cluster_id(cluster_uuid)

         self.log.debug(
             "Cluster {}, adding {} repository {}. URL: {}".format(
         self.log.debug(
             "Cluster {}, adding {} repository {}. URL: {}".format(

-                cluster_id, repo_type, name, url
+                cluster_uuid, repo_type, name, url

             )
         )
 
         # init_env
         paths, env = self._init_paths_env(
             )
         )
 
         # init_env
         paths, env = self._init_paths_env(

-            cluster_name=cluster_id, create_if_not_exist=True
+            cluster_name=cluster_uuid, create_if_not_exist=True

         )
 
         # sync local dir
         )
 
         # sync local dir

-        self.fs.sync(from_path=cluster_id)
+        self.fs.sync(from_path=cluster_uuid)

 
         # helm repo update
         command = "env KUBECONFIG={} {} repo update".format(
 
         # helm repo update
         command = "env KUBECONFIG={} {} repo update".format(


@@ -176,16 +185,32 @@ class K8sHelmBaseConnector(K8sConnector):
         )
 
         # helm repo add name url
         )
 
         # helm repo add name url

-        command = "env KUBECONFIG={} {} repo add {} {}".format(
+        command = ("env KUBECONFIG={} {} repo add {} {}").format(

             paths["kube_config"], self._helm_command, name, url
         )
             paths["kube_config"], self._helm_command, name, url
         )

+
+        if cert:
+            temp_cert_file = os.path.join(
+                self.fs.path, "{}/helmcerts/".format(cluster_id), "temp.crt"
+            )
+            os.makedirs(os.path.dirname(temp_cert_file), exist_ok=True)
+            with open(temp_cert_file, "w") as the_cert:
+                the_cert.write(cert)
+            command += " --ca-file {}".format(temp_cert_file)
+
+        if user:
+            command += " --username={}".format(user)
+
+        if password:
+            command += " --password={}".format(password)
+

         self.log.debug("adding repo: {}".format(command))
         await self._local_async_exec(
             command=command, raise_exception_on_error=True, env=env
         )
 
         # sync fs
         self.log.debug("adding repo: {}".format(command))
         await self._local_async_exec(
             command=command, raise_exception_on_error=True, env=env
         )
 
         # sync fs

-        self.fs.reverse_sync(from_path=cluster_id)
+        self.fs.reverse_sync(from_path=cluster_uuid)

 
     async def repo_list(self, cluster_uuid: str) -> list:
         """
 
     async def repo_list(self, cluster_uuid: str) -> list:
         """


@@ -194,16 +219,15 @@ class K8sHelmBaseConnector(K8sConnector):
         :return: list of registered repositories: [ (name, url) .... ]
         """
 
         :return: list of registered repositories: [ (name, url) .... ]
         """
 

-        _, cluster_id = self._get_namespace_cluster_id(cluster_uuid)
-        self.log.debug("list repositories for cluster {}".format(cluster_id))
+        self.log.debug("list repositories for cluster {}".format(cluster_uuid))

 
         # config filename
         paths, env = self._init_paths_env(
 
         # config filename
         paths, env = self._init_paths_env(

-            cluster_name=cluster_id, create_if_not_exist=True
+            cluster_name=cluster_uuid, create_if_not_exist=True

         )
 
         # sync local dir
         )
 
         # sync local dir

-        self.fs.sync(from_path=cluster_id)
+        self.fs.sync(from_path=cluster_uuid)

 
         command = "env KUBECONFIG={} {} repo list --output yaml".format(
             paths["kube_config"], self._helm_command
 
         command = "env KUBECONFIG={} {} repo list --output yaml".format(
             paths["kube_config"], self._helm_command


@@ -215,7 +239,7 @@ class K8sHelmBaseConnector(K8sConnector):
         )
 
         # sync fs
         )
 
         # sync fs

-        self.fs.reverse_sync(from_path=cluster_id)
+        self.fs.reverse_sync(from_path=cluster_uuid)

 
         if _rc == 0:
             if output and len(output) > 0:
 
         if _rc == 0:
             if output and len(output) > 0:


@@ -228,17 +252,17 @@ class K8sHelmBaseConnector(K8sConnector):
             return []
 
     async def repo_remove(self, cluster_uuid: str, name: str):
             return []
 
     async def repo_remove(self, cluster_uuid: str, name: str):

-
-        _, cluster_id = self._get_namespace_cluster_id(cluster_uuid)
-        self.log.debug("remove {} repositories for cluster {}".format(name, cluster_id))
+        self.log.debug(
+            "remove {} repositories for cluster {}".format(name, cluster_uuid)
+        )

 
         # init env, paths
         paths, env = self._init_paths_env(
 
         # init env, paths
         paths, env = self._init_paths_env(

-            cluster_name=cluster_id, create_if_not_exist=True
+            cluster_name=cluster_uuid, create_if_not_exist=True

         )
 
         # sync local dir
         )
 
         # sync local dir

-        self.fs.sync(from_path=cluster_id)
+        self.fs.sync(from_path=cluster_uuid)

 
         command = "env KUBECONFIG={} {} repo remove {}".format(
             paths["kube_config"], self._helm_command, name
 
         command = "env KUBECONFIG={} {} repo remove {}".format(
             paths["kube_config"], self._helm_command, name


@@ -248,7 +272,7 @@ class K8sHelmBaseConnector(K8sConnector):
         )
 
         # sync fs
         )
 
         # sync fs

-        self.fs.reverse_sync(from_path=cluster_id)
+        self.fs.reverse_sync(from_path=cluster_uuid)

 
     async def reset(
         self,
 
     async def reset(
         self,


@@ -267,15 +291,15 @@ class K8sHelmBaseConnector(K8sConnector):
         :param kwargs: Additional parameters (None yet)
         :return: Returns True if successful or raises an exception.
         """
         :param kwargs: Additional parameters (None yet)
         :return: Returns True if successful or raises an exception.
         """

-        namespace, cluster_id = self._get_namespace_cluster_id(cluster_uuid)
+        namespace = self._get_namespace(cluster_uuid=cluster_uuid)

         self.log.debug(
             "Resetting K8s environment. cluster uuid: {} uninstall={}".format(
         self.log.debug(
             "Resetting K8s environment. cluster uuid: {} uninstall={}".format(

-                cluster_id, uninstall_sw
+                cluster_uuid, uninstall_sw

             )
         )
 
         # sync local dir
             )
         )
 
         # sync local dir

-        self.fs.sync(from_path=cluster_id)
+        self.fs.sync(from_path=cluster_uuid)

 
         # uninstall releases if needed.
         if uninstall_sw:
 
         # uninstall releases if needed.
         if uninstall_sw:


@@ -304,20 +328,20 @@ class K8sHelmBaseConnector(K8sConnector):
                 else:
                     msg = (
                         "Cluster uuid: {} has releases and not force. Leaving K8s helm environment"
                 else:
                     msg = (
                         "Cluster uuid: {} has releases and not force. Leaving K8s helm environment"

-                    ).format(cluster_id)
+                    ).format(cluster_uuid)

                     self.log.warn(msg)
                     uninstall_sw = (
                         False  # Allow to remove k8s cluster without removing Tiller
                     )
 
         if uninstall_sw:
                     self.log.warn(msg)
                     uninstall_sw = (
                         False  # Allow to remove k8s cluster without removing Tiller
                     )
 
         if uninstall_sw:

-            await self._uninstall_sw(cluster_id, namespace)
+            await self._uninstall_sw(cluster_id=cluster_uuid, namespace=namespace)

 
         # delete cluster directory
 
         # delete cluster directory

-        self.log.debug("Removing directory {}".format(cluster_id))
-        self.fs.file_delete(cluster_id, ignore_non_exist=True)
+        self.log.debug("Removing directory {}".format(cluster_uuid))
+        self.fs.file_delete(cluster_uuid, ignore_non_exist=True)

         # Remove also local directorio if still exist
         # Remove also local directorio if still exist

-        direct = self.fs.path + "/" + cluster_id
+        direct = self.fs.path + "/" + cluster_uuid

         shutil.rmtree(direct, ignore_errors=True)
 
         return True
         shutil.rmtree(direct, ignore_errors=True)
 
         return True


@@ -426,11 +450,10 @@ class K8sHelmBaseConnector(K8sConnector):
         params: dict = None,
         db_dict: dict = None,
     ):
         params: dict = None,
         db_dict: dict = None,
     ):

-        _, cluster_id = self._get_namespace_cluster_id(cluster_uuid)
-        self.log.debug("upgrading {} in cluster {}".format(kdu_model, cluster_id))
+        self.log.debug("upgrading {} in cluster {}".format(kdu_model, cluster_uuid))

 
         # sync local dir
 
         # sync local dir

-        self.fs.sync(from_path=cluster_id)
+        self.fs.sync(from_path=cluster_uuid)

 
         # look for instance to obtain namespace
         instance_info = await self.get_instance_info(cluster_uuid, kdu_instance)
 
         # look for instance to obtain namespace
         instance_info = await self.get_instance_info(cluster_uuid, kdu_instance)


@@ -439,15 +462,15 @@ class K8sHelmBaseConnector(K8sConnector):
 
         # init env, paths
         paths, env = self._init_paths_env(
 
         # init env, paths
         paths, env = self._init_paths_env(

-            cluster_name=cluster_id, create_if_not_exist=True
+            cluster_name=cluster_uuid, create_if_not_exist=True

         )
 
         # sync local dir
         )
 
         # sync local dir

-        self.fs.sync(from_path=cluster_id)
+        self.fs.sync(from_path=cluster_uuid)

 
         # params to str
         params_str, file_to_delete = self._params_to_file_option(
 
         # params to str
         params_str, file_to_delete = self._params_to_file_option(

-            cluster_id=cluster_id, params=params
+            cluster_id=cluster_uuid, params=params

         )
 
         # version
         )
 
         # version


@@ -477,7 +500,7 @@ class K8sHelmBaseConnector(K8sConnector):
             # write status in another task
             status_task = asyncio.ensure_future(
                 coro_or_future=self._store_status(
             # write status in another task
             status_task = asyncio.ensure_future(
                 coro_or_future=self._store_status(

-                    cluster_id=cluster_id,
+                    cluster_id=cluster_uuid,

                     kdu_instance=kdu_instance,
                     namespace=instance_info["namespace"],
                     db_dict=db_dict,
                     kdu_instance=kdu_instance,
                     namespace=instance_info["namespace"],
                     db_dict=db_dict,


@@ -505,7 +528,7 @@ class K8sHelmBaseConnector(K8sConnector):
 
         # write final status
         await self._store_status(
 
         # write final status
         await self._store_status(

-            cluster_id=cluster_id,
+            cluster_id=cluster_uuid,

             kdu_instance=kdu_instance,
             namespace=instance_info["namespace"],
             db_dict=db_dict,
             kdu_instance=kdu_instance,
             namespace=instance_info["namespace"],
             db_dict=db_dict,


@@ -520,7 +543,7 @@ class K8sHelmBaseConnector(K8sConnector):
             raise K8sException(msg)
 
         # sync fs
             raise K8sException(msg)
 
         # sync fs

-        self.fs.reverse_sync(from_path=cluster_id)
+        self.fs.reverse_sync(from_path=cluster_uuid)

 
         # return new revision number
         instance = await self.get_instance_info(
 
         # return new revision number
         instance = await self.get_instance_info(


@@ -563,12 +586,10 @@ class K8sHelmBaseConnector(K8sConnector):
             True if successful, False otherwise
         """
 
             True if successful, False otherwise
         """
 

-        _, cluster_id = self._get_namespace_cluster_id(cluster_uuid)
-
-        debug_mgs = "scaling {} in cluster {}".format(kdu_model, cluster_id)
+        debug_mgs = "scaling {} in cluster {}".format(kdu_model, cluster_uuid)

         if resource_name:
             debug_mgs = "scaling resource {} in model {} (cluster {})".format(
         if resource_name:
             debug_mgs = "scaling resource {} in model {} (cluster {})".format(

-                resource_name, kdu_model, cluster_id
+                resource_name, kdu_model, cluster_uuid

             )
 
         self.log.debug(debug_mgs)
             )
 
         self.log.debug(debug_mgs)


@@ -581,7 +602,7 @@ class K8sHelmBaseConnector(K8sConnector):
 
         # init env, paths
         paths, env = self._init_paths_env(
 
         # init env, paths
         paths, env = self._init_paths_env(

-            cluster_name=cluster_id, create_if_not_exist=True
+            cluster_name=cluster_uuid, create_if_not_exist=True

         )
 
         # version
         )
 
         # version


@@ -622,7 +643,7 @@ class K8sHelmBaseConnector(K8sConnector):
             # write status in another task
             status_task = asyncio.ensure_future(
                 coro_or_future=self._store_status(
             # write status in another task
             status_task = asyncio.ensure_future(
                 coro_or_future=self._store_status(

-                    cluster_id=cluster_id,
+                    cluster_id=cluster_uuid,

                     kdu_instance=kdu_instance,
                     namespace=instance_info["namespace"],
                     db_dict=db_dict,
                     kdu_instance=kdu_instance,
                     namespace=instance_info["namespace"],
                     db_dict=db_dict,


@@ -645,7 +666,7 @@ class K8sHelmBaseConnector(K8sConnector):
 
         # write final status
         await self._store_status(
 
         # write final status
         await self._store_status(

-            cluster_id=cluster_id,
+            cluster_id=cluster_uuid,

             kdu_instance=kdu_instance,
             namespace=instance_info["namespace"],
             db_dict=db_dict,
             kdu_instance=kdu_instance,
             namespace=instance_info["namespace"],
             db_dict=db_dict,


@@ -660,7 +681,7 @@ class K8sHelmBaseConnector(K8sConnector):
             raise K8sException(msg)
 
         # sync fs
             raise K8sException(msg)
 
         # sync fs

-        self.fs.reverse_sync(from_path=cluster_id)
+        self.fs.reverse_sync(from_path=cluster_uuid)

 
         return True
 
 
         return True
 


@@ -685,9 +706,8 @@ class K8sHelmBaseConnector(K8sConnector):
             Resource instance count
         """
 
             Resource instance count
         """
 

-        _, cluster_id = self._get_namespace_cluster_id(cluster_uuid)

         self.log.debug(
         self.log.debug(

-            "getting scale count for {} in cluster {}".format(kdu_model, cluster_id)
+            "getting scale count for {} in cluster {}".format(kdu_model, cluster_uuid)

         )
 
         # look for instance to obtain namespace
         )
 
         # look for instance to obtain namespace


@@ -697,7 +717,7 @@ class K8sHelmBaseConnector(K8sConnector):
 
         # init env, paths
         paths, env = self._init_paths_env(
 
         # init env, paths
         paths, env = self._init_paths_env(

-            cluster_name=cluster_id, create_if_not_exist=True
+            cluster_name=cluster_uuid, create_if_not_exist=True

         )
 
         replicas = await self._get_replica_count_instance(
         )
 
         replicas = await self._get_replica_count_instance(


@@ -726,16 +746,14 @@ class K8sHelmBaseConnector(K8sConnector):
     async def rollback(
         self, cluster_uuid: str, kdu_instance: str, revision=0, db_dict: dict = None
     ):
     async def rollback(
         self, cluster_uuid: str, kdu_instance: str, revision=0, db_dict: dict = None
     ):

-
-        _, cluster_id = self._get_namespace_cluster_id(cluster_uuid)

         self.log.debug(
             "rollback kdu_instance {} to revision {} from cluster {}".format(
         self.log.debug(
             "rollback kdu_instance {} to revision {} from cluster {}".format(

-                kdu_instance, revision, cluster_id
+                kdu_instance, revision, cluster_uuid

             )
         )
 
         # sync local dir
             )
         )
 
         # sync local dir

-        self.fs.sync(from_path=cluster_id)
+        self.fs.sync(from_path=cluster_uuid)

 
         # look for instance to obtain namespace
         instance_info = await self.get_instance_info(cluster_uuid, kdu_instance)
 
         # look for instance to obtain namespace
         instance_info = await self.get_instance_info(cluster_uuid, kdu_instance)


@@ -744,11 +762,11 @@ class K8sHelmBaseConnector(K8sConnector):
 
         # init env, paths
         paths, env = self._init_paths_env(
 
         # init env, paths
         paths, env = self._init_paths_env(

-            cluster_name=cluster_id, create_if_not_exist=True
+            cluster_name=cluster_uuid, create_if_not_exist=True

         )
 
         # sync local dir
         )
 
         # sync local dir

-        self.fs.sync(from_path=cluster_id)
+        self.fs.sync(from_path=cluster_uuid)

 
         command = self._get_rollback_command(
             kdu_instance, instance_info["namespace"], revision, paths["kube_config"]
 
         command = self._get_rollback_command(
             kdu_instance, instance_info["namespace"], revision, paths["kube_config"]


@@ -765,7 +783,7 @@ class K8sHelmBaseConnector(K8sConnector):
         # write status in another task
         status_task = asyncio.ensure_future(
             coro_or_future=self._store_status(
         # write status in another task
         status_task = asyncio.ensure_future(
             coro_or_future=self._store_status(

-                cluster_id=cluster_id,
+                cluster_id=cluster_uuid,

                 kdu_instance=kdu_instance,
                 namespace=instance_info["namespace"],
                 db_dict=db_dict,
                 kdu_instance=kdu_instance,
                 namespace=instance_info["namespace"],
                 db_dict=db_dict,


@@ -784,7 +802,7 @@ class K8sHelmBaseConnector(K8sConnector):
 
         # write final status
         await self._store_status(
 
         # write final status
         await self._store_status(

-            cluster_id=cluster_id,
+            cluster_id=cluster_uuid,

             kdu_instance=kdu_instance,
             namespace=instance_info["namespace"],
             db_dict=db_dict,
             kdu_instance=kdu_instance,
             namespace=instance_info["namespace"],
             db_dict=db_dict,


@@ -799,7 +817,7 @@ class K8sHelmBaseConnector(K8sConnector):
             raise K8sException(msg)
 
         # sync fs
             raise K8sException(msg)
 
         # sync fs

-        self.fs.reverse_sync(from_path=cluster_id)
+        self.fs.reverse_sync(from_path=cluster_uuid)

 
         # return new revision number
         instance = await self.get_instance_info(
 
         # return new revision number
         instance = await self.get_instance_info(


@@ -824,13 +842,14 @@ class K8sHelmBaseConnector(K8sConnector):
         :return: True if successful
         """
 
         :return: True if successful
         """
 

-        _, cluster_id = self._get_namespace_cluster_id(cluster_uuid)

         self.log.debug(
         self.log.debug(

-            "uninstall kdu_instance {} from cluster {}".format(kdu_instance, cluster_id)
+            "uninstall kdu_instance {} from cluster {}".format(
+                kdu_instance, cluster_uuid
+            )

         )
 
         # sync local dir
         )
 
         # sync local dir

-        self.fs.sync(from_path=cluster_id)
+        self.fs.sync(from_path=cluster_uuid)

 
         # look for instance to obtain namespace
         instance_info = await self.get_instance_info(cluster_uuid, kdu_instance)
 
         # look for instance to obtain namespace
         instance_info = await self.get_instance_info(cluster_uuid, kdu_instance)


@@ -839,11 +858,11 @@ class K8sHelmBaseConnector(K8sConnector):
             return True
         # init env, paths
         paths, env = self._init_paths_env(
             return True
         # init env, paths
         paths, env = self._init_paths_env(

-            cluster_name=cluster_id, create_if_not_exist=True
+            cluster_name=cluster_uuid, create_if_not_exist=True

         )
 
         # sync local dir
         )
 
         # sync local dir

-        self.fs.sync(from_path=cluster_id)
+        self.fs.sync(from_path=cluster_uuid)

 
         command = self._get_uninstall_command(
             kdu_instance, instance_info["namespace"], paths["kube_config"]
 
         command = self._get_uninstall_command(
             kdu_instance, instance_info["namespace"], paths["kube_config"]


@@ -853,7 +872,7 @@ class K8sHelmBaseConnector(K8sConnector):
         )
 
         # sync fs
         )
 
         # sync fs

-        self.fs.reverse_sync(from_path=cluster_id)
+        self.fs.reverse_sync(from_path=cluster_uuid)

 
         return self._output_to_table(output)
 
 
         return self._output_to_table(output)
 


@@ -865,17 +884,16 @@ class K8sHelmBaseConnector(K8sConnector):
         :return:
         """
 
         :return:
         """
 

-        _, cluster_id = self._get_namespace_cluster_id(cluster_uuid)
-        self.log.debug("list releases for cluster {}".format(cluster_id))
+        self.log.debug("list releases for cluster {}".format(cluster_uuid))

 
         # sync local dir
 
         # sync local dir

-        self.fs.sync(from_path=cluster_id)
+        self.fs.sync(from_path=cluster_uuid)

 
         # execute internal command
 
         # execute internal command

-        result = await self._instances_list(cluster_id)
+        result = await self._instances_list(cluster_uuid)

 
         # sync fs
 
         # sync fs

-        self.fs.reverse_sync(from_path=cluster_id)
+        self.fs.reverse_sync(from_path=cluster_uuid)

 
         return result
 
 
         return result
 


@@ -933,7 +951,6 @@ class K8sHelmBaseConnector(K8sConnector):
         - `external_ip` List of external ips (in case they are available)
         """
 
         - `external_ip` List of external ips (in case they are available)
         """
 

-        _, cluster_id = self._get_namespace_cluster_id(cluster_uuid)

         self.log.debug(
             "get_services: cluster_uuid: {}, kdu_instance: {}".format(
                 cluster_uuid, kdu_instance
         self.log.debug(
             "get_services: cluster_uuid: {}, kdu_instance: {}".format(
                 cluster_uuid, kdu_instance


@@ -942,24 +959,24 @@ class K8sHelmBaseConnector(K8sConnector):
 
         # init env, paths
         paths, env = self._init_paths_env(
 
         # init env, paths
         paths, env = self._init_paths_env(

-            cluster_name=cluster_id, create_if_not_exist=True
+            cluster_name=cluster_uuid, create_if_not_exist=True

         )
 
         # sync local dir
         )
 
         # sync local dir

-        self.fs.sync(from_path=cluster_id)
+        self.fs.sync(from_path=cluster_uuid)

 
         # get list of services names for kdu
         service_names = await self._get_services(
 
         # get list of services names for kdu
         service_names = await self._get_services(

-            cluster_id, kdu_instance, namespace, paths["kube_config"]
+            cluster_uuid, kdu_instance, namespace, paths["kube_config"]

         )
 
         service_list = []
         for service in service_names:
         )
 
         service_list = []
         for service in service_names:

-            service = await self._get_service(cluster_id, service, namespace)
+            service = await self._get_service(cluster_uuid, service, namespace)

             service_list.append(service)
 
         # sync fs
             service_list.append(service)
 
         # sync fs

-        self.fs.reverse_sync(from_path=cluster_id)
+        self.fs.reverse_sync(from_path=cluster_uuid)

 
         return service_list
 
 
         return service_list
 


@@ -973,19 +990,19 @@ class K8sHelmBaseConnector(K8sConnector):
             )
         )
 
             )
         )
 

-        _, cluster_id = self._get_namespace_cluster_id(cluster_uuid)
-

         # sync local dir
         # sync local dir

-        self.fs.sync(from_path=cluster_id)
+        self.fs.sync(from_path=cluster_uuid)

 
 

-        service = await self._get_service(cluster_id, service_name, namespace)
+        service = await self._get_service(cluster_uuid, service_name, namespace)

 
         # sync fs
 
         # sync fs

-        self.fs.reverse_sync(from_path=cluster_id)
+        self.fs.reverse_sync(from_path=cluster_uuid)

 
         return service
 
 
         return service
 

-    async def status_kdu(self, cluster_uuid: str, kdu_instance: str, **kwargs) -> str:
+    async def status_kdu(
+        self, cluster_uuid: str, kdu_instance: str, yaml_format: str = False, **kwargs
+    ) -> 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
         """
         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


@@ -995,6 +1012,8 @@ class K8sHelmBaseConnector(K8sConnector):
         :param cluster_uuid: UUID of a K8s cluster known by OSM
         :param kdu_instance: unique name for the KDU instance
         :param kwargs: Additional parameters (None yet)
         :param cluster_uuid: UUID of a K8s cluster known by OSM
         :param kdu_instance: unique name for the KDU instance
         :param kwargs: Additional parameters (None yet)

+        :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:
         :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:


@@ -1015,13 +1034,11 @@ class K8sHelmBaseConnector(K8sConnector):
             )
         )
 
             )
         )
 

-        _, cluster_id = self._get_namespace_cluster_id(cluster_uuid)
-

         # sync local dir
         # sync local dir

-        self.fs.sync(from_path=cluster_id)
+        self.fs.sync(from_path=cluster_uuid)

 
         # get instance: needed to obtain namespace
 
         # get instance: needed to obtain namespace

-        instances = await self._instances_list(cluster_id=cluster_id)
+        instances = await self._instances_list(cluster_id=cluster_uuid)

         for instance in instances:
             if instance.get("name") == kdu_instance:
                 break
         for instance in instances:
             if instance.get("name") == kdu_instance:
                 break


@@ -1029,20 +1046,20 @@ class K8sHelmBaseConnector(K8sConnector):
             # instance does not exist
             raise K8sException(
                 "Instance name: {} not found in cluster: {}".format(
             # instance does not exist
             raise K8sException(
                 "Instance name: {} not found in cluster: {}".format(

-                    kdu_instance, cluster_id
+                    kdu_instance, cluster_uuid

                 )
             )
 
         status = await self._status_kdu(
                 )
             )
 
         status = await self._status_kdu(

-            cluster_id=cluster_id,
+            cluster_id=cluster_uuid,

             kdu_instance=kdu_instance,
             namespace=instance["namespace"],
             kdu_instance=kdu_instance,
             namespace=instance["namespace"],

+            yaml_format=yaml_format,

             show_error_log=True,
             show_error_log=True,

-            return_text=True,

         )
 
         # sync fs
         )
 
         # sync fs

-        self.fs.reverse_sync(from_path=cluster_id)
+        self.fs.reverse_sync(from_path=cluster_uuid)

 
         return status
 
 
         return status
 


@@ -1113,9 +1130,19 @@ class K8sHelmBaseConnector(K8sConnector):
 
                         # add repo
                         self.log.debug("add repo {}".format(db_repo["name"]))
 
                         # add repo
                         self.log.debug("add repo {}".format(db_repo["name"]))

-                        await self.repo_add(
-                            cluster_uuid, db_repo["name"], db_repo["url"]
-                        )
+                        if "ca_cert" in db_repo:
+                            await self.repo_add(
+                                cluster_uuid,
+                                db_repo["name"],
+                                db_repo["url"],
+                                cert=db_repo["ca_cert"],
+                            )
+                        else:
+                            await self.repo_add(
+                                cluster_uuid,
+                                db_repo["name"],
+                                db_repo["url"],
+                            )

                         added_repo_dict[repo_id] = db_repo["name"]
                 except Exception as e:
                     raise K8sException(
                         added_repo_dict[repo_id] = db_repo["name"]
                 except Exception as e:
                     raise K8sException(


@@ -1195,9 +1222,9 @@ class K8sHelmBaseConnector(K8sConnector):
         cluster_id: str,
         kdu_instance: str,
         namespace: str = None,
         cluster_id: str,
         kdu_instance: str,
         namespace: str = None,

+        yaml_format: bool = False,

         show_error_log: bool = False,
         show_error_log: bool = False,

-        return_text: bool = False,
-    ):
+    ) -> Union[str, dict]:

         """
         Implements the helm version dependent method to obtain status of a helm instance
         """
         """
         Implements the helm version dependent method to obtain status of a helm instance
         """


@@ -1761,8 +1788,8 @@ class K8sHelmBaseConnector(K8sConnector):
                 detailed_status = await self._status_kdu(
                     cluster_id=cluster_id,
                     kdu_instance=kdu_instance,
                 detailed_status = await self._status_kdu(
                     cluster_id=cluster_id,
                     kdu_instance=kdu_instance,

+                    yaml_format=False,

                     namespace=namespace,
                     namespace=namespace,

-                    return_text=False,

                 )
                 status = detailed_status.get("info").get("description")
                 self.log.debug("KDU {} STATUS: {}.".format(kdu_instance, status))
                 )
                 status = detailed_status.get("info").get("description")
                 self.log.debug("KDU {} STATUS: {}.".format(kdu_instance, status))