X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=n2vc%2Fk8s_juju_conn.py;h=f8ed0e0155cca930d744fdb677e943f0c0011fe7;hb=HEAD;hp=6744015b5dfe80d5f7363459e36112b1eeff733c;hpb=8070c3c8260010f052ee9fe546c85bed4aa6b2eb;p=osm%2FN2VC.git

diff --git a/n2vc/k8s_juju_conn.py b/n2vc/k8s_juju_conn.py
index 6744015..c197221 100644
--- a/n2vc/k8s_juju_conn.py
+++ b/n2vc/k8s_juju_conn.py
@@ -51,7 +51,6 @@ class K8sJujuConnector(K8sConnector):
         kubectl_command: str = "/usr/bin/kubectl",
         juju_command: str = "/usr/bin/juju",
         log: object = None,
-        loop: object = None,
         on_update_db=None,
     ):
         """
@@ -60,24 +59,17 @@ class K8sJujuConnector(K8sConnector):
         :param kubectl_command: path to kubectl executable
         :param helm_command: path to helm executable
         :param log: logger
-        :param: loop: Asyncio loop
         """
 
         # parent class
-        K8sConnector.__init__(
-            self,
-            db,
-            log=log,
-            on_update_db=on_update_db,
-        )
+        K8sConnector.__init__(self, db, log=log, on_update_db=on_update_db)
 
         self.fs = fs
-        self.loop = loop or asyncio.get_event_loop()
         self.log.debug("Initializing K8S Juju connector")
 
         db_uri = EnvironConfig(prefixes=["OSMLCM_", "OSMMON_"]).get("database_uri")
         self._store = MotorStore(db_uri)
-        self.loading_libjuju = asyncio.Lock(loop=self.loop)
+        self.loading_libjuju = asyncio.Lock()
         self.uninstall_locks = {}
 
         self.log.debug("K8S Juju connector initialized")
@@ -125,44 +117,27 @@ class K8sJujuConnector(K8sConnector):
         cleanup_data = []
         try:
             self.log.debug("Initializing K8s cluster for juju")
-            kubectl.create_cluster_role(
-                name=metadata_name,
-                labels=labels,
-            )
+            kubectl.create_cluster_role(name=metadata_name, labels=labels)
             self.log.debug("Cluster role created")
             cleanup_data.append(
-                {
-                    "delete": kubectl.delete_cluster_role,
-                    "args": (metadata_name,),
-                }
+                {"delete": kubectl.delete_cluster_role, "args": (metadata_name,)}
             )
 
-            kubectl.create_service_account(
-                name=metadata_name,
-                labels=labels,
-            )
+            kubectl.create_service_account(name=metadata_name, labels=labels)
             self.log.debug("Service account created")
             cleanup_data.append(
-                {
-                    "delete": kubectl.delete_service_account,
-                    "args": (metadata_name,),
-                }
+                {"delete": kubectl.delete_service_account, "args": (metadata_name,)}
             )
 
-            kubectl.create_cluster_role_binding(
-                name=metadata_name,
-                labels=labels,
-            )
+            kubectl.create_cluster_role_binding(name=metadata_name, labels=labels)
             self.log.debug("Role binding created")
             cleanup_data.append(
                 {
-                    "delete": kubectl.delete_service_account,
+                    "delete": kubectl.delete_cluster_role_binding,
                     "args": (metadata_name,),
                 }
             )
-            token, client_cert_data = await kubectl.get_secret_data(
-                metadata_name,
-            )
+            token, client_cert_data = await kubectl.get_secret_data(metadata_name)
 
             default_storage_class = kubectl.get_default_storage_class()
             self.log.debug("Default storage class: {}".format(default_storage_class))
@@ -204,10 +179,7 @@ class K8sJujuConnector(K8sConnector):
     async def repo_list(self):
         raise MethodNotImplemented()
 
-    async def repo_remove(
-        self,
-        name: str,
-    ):
+    async def repo_remove(self, name: str):
         raise MethodNotImplemented()
 
     async def synchronize_repos(self, cluster_uuid: str, name: str):
@@ -327,12 +299,16 @@ class K8sJujuConnector(K8sConnector):
             os.chdir(new_workdir)
             bundle = "local:{}".format(kdu_model)
 
-        self.log.debug("Checking for model named {}".format(kdu_instance))
+        # default namespace to kdu_instance
+        if not namespace:
+            namespace = kdu_instance
+
+        self.log.debug("Checking for model named {}".format(namespace))
 
         # Create the new model
-        self.log.debug("Adding model: {}".format(kdu_instance))
+        self.log.debug("Adding model: {}".format(namespace))
         cloud = Cloud(cluster_uuid, self._get_credential_name(cluster_uuid))
-        await libjuju.add_model(kdu_instance, cloud)
+        await libjuju.add_model(namespace, cloud)
 
         # if model:
         # TODO: Instantiation parameters
@@ -351,10 +327,17 @@ class K8sJujuConnector(K8sConnector):
             previous_workdir = "/app/storage"
 
         self.log.debug("[install] deploying {}".format(bundle))
+        instantiation_params = params.get("overlay") if params else None
         await libjuju.deploy(
-            bundle, model_name=kdu_instance, wait=atomic, timeout=timeout
+            bundle,
+            model_name=namespace,
+            wait=atomic,
+            timeout=timeout,
+            instantiation_params=instantiation_params,
         )
         os.chdir(previous_workdir)
+
+        # update information in the database (first, the VCA status, and then, the namespace)
         if self.on_update_db:
             await self.on_update_db(
                 cluster_uuid,
@@ -362,6 +345,13 @@ class K8sJujuConnector(K8sConnector):
                 filter=db_dict["filter"],
                 vca_id=kwargs.get("vca_id"),
             )
+
+        self.db.set_one(
+            table="nsrs",
+            q_filter={"_admin.deployed.K8s.kdu-instance": kdu_instance},
+            update_dict={"_admin.deployed.K8s.$.namespace": namespace},
+        )
+
         return True
 
     async def scale(
@@ -370,6 +360,7 @@ class K8sJujuConnector(K8sConnector):
         scale: int,
         resource_name: str,
         total_timeout: float = 1800,
+        namespace: str = None,
         **kwargs,
     ) -> bool:
         """Scale an application in a model
@@ -379,50 +370,56 @@ class K8sJujuConnector(K8sConnector):
         :param: resource_name str:       The application name in the Juju Bundle
         :param: timeout float:           The time, in seconds, to wait for the install
                                          to finish
+        :param namespace str: The namespace (model) where the Bundle was deployed
         :param kwargs:                   Additional parameters
                                             vca_id (str): VCA ID
 
         :return: If successful, returns True
         """
 
+        model_name = self._obtain_namespace(
+            kdu_instance=kdu_instance, namespace=namespace
+        )
         try:
             libjuju = await self._get_libjuju(kwargs.get("vca_id"))
             await libjuju.scale_application(
-                model_name=kdu_instance,
+                model_name=model_name,
                 application_name=resource_name,
                 scale=scale,
                 total_timeout=total_timeout,
             )
         except Exception as e:
-            error_msg = "Error scaling application {} in kdu instance {}: {}".format(
-                resource_name, kdu_instance, e
+            error_msg = "Error scaling application {} of the model {} of the kdu instance {}: {}".format(
+                resource_name, model_name, kdu_instance, e
             )
             self.log.error(error_msg)
             raise K8sException(message=error_msg)
         return True
 
     async def get_scale_count(
-        self,
-        resource_name: str,
-        kdu_instance: str,
-        **kwargs,
+        self, resource_name: str, kdu_instance: str, namespace: str = None, **kwargs
     ) -> int:
         """Get an application scale count
 
         :param: resource_name str:       The application name in the Juju Bundle
         :param: kdu_instance str:        KDU instance name
+        :param namespace str: The namespace (model) where the Bundle was deployed
         :param kwargs:                   Additional parameters
                                             vca_id (str): VCA ID
         :return: Return application instance count
         """
 
+        model_name = self._obtain_namespace(
+            kdu_instance=kdu_instance, namespace=namespace
+        )
         try:
             libjuju = await self._get_libjuju(kwargs.get("vca_id"))
-            status = await libjuju.get_model_status(kdu_instance)
+            status = await libjuju.get_model_status(model_name=model_name)
             return len(status.applications[resource_name].units)
         except Exception as e:
-            error_msg = "Error getting scale count from application {} in kdu instance {}: {}".format(
-                resource_name, kdu_instance, e
+            error_msg = (
+                f"Error getting scale count from application {resource_name} of the model {model_name} of "
+                f"the kdu instance {kdu_instance}: {e}"
             )
             self.log.error(error_msg)
             raise K8sException(message=error_msg)
@@ -472,10 +469,7 @@ class K8sJujuConnector(K8sConnector):
     """Rollback"""
 
     async def rollback(
-        self,
-        cluster_uuid: str,
-        kdu_instance: str,
-        revision: int = 0,
+        self, cluster_uuid: str, kdu_instance: str, revision: int = 0
     ) -> str:
         """Rollback a model
 
@@ -492,45 +486,46 @@ class K8sJujuConnector(K8sConnector):
     """Deletion"""
 
     async def uninstall(
-        self,
-        cluster_uuid: str,
-        kdu_instance: str,
-        **kwargs,
+        self, cluster_uuid: str, kdu_instance: str, namespace: str = None, **kwargs
     ) -> bool:
         """Uninstall a KDU instance
 
         :param cluster_uuid str: The UUID of the cluster
         :param kdu_instance str: The unique name of the KDU instance
+        :param namespace str: The namespace (model) where the Bundle was deployed
         :param kwargs: Additional parameters
             vca_id (str): VCA ID
 
         :return: Returns True if successful, or raises an exception
         """
+        model_name = self._obtain_namespace(
+            kdu_instance=kdu_instance, namespace=namespace
+        )
 
-        self.log.debug("[uninstall] Destroying model")
+        self.log.debug(f"[uninstall] Destroying model: {model_name}")
 
         will_not_delete = False
-        if kdu_instance not in self.uninstall_locks:
-            self.uninstall_locks[kdu_instance] = asyncio.Lock(loop=self.loop)
-        delete_lock = self.uninstall_locks[kdu_instance]
+        if model_name not in self.uninstall_locks:
+            self.uninstall_locks[model_name] = asyncio.Lock()
+        delete_lock = self.uninstall_locks[model_name]
 
         while delete_lock.locked():
             will_not_delete = True
             await asyncio.sleep(0.1)
 
         if will_not_delete:
-            self.log.info("Model {} deleted by another worker.".format(kdu_instance))
+            self.log.info("Model {} deleted by another worker.".format(model_name))
             return True
 
         try:
             async with delete_lock:
                 libjuju = await self._get_libjuju(kwargs.get("vca_id"))
 
-                await libjuju.destroy_model(kdu_instance, total_timeout=3600)
+                await libjuju.destroy_model(model_name, total_timeout=3600)
         finally:
-            self.uninstall_locks.pop(kdu_instance)
+            self.uninstall_locks.pop(model_name)
 
-        self.log.debug(f"[uninstall] Model {kdu_instance} destroyed")
+        self.log.debug(f"[uninstall] Model {model_name} destroyed")
         return True
 
     async def upgrade_charm(
@@ -565,6 +560,7 @@ class K8sJujuConnector(K8sConnector):
         timeout: float = 300,
         params: dict = None,
         db_dict: dict = None,
+        namespace: str = None,
         **kwargs,
     ) -> str:
         """Exec primitive (Juju action)
@@ -575,6 +571,7 @@ class K8sJujuConnector(K8sConnector):
         :param timeout: Timeout for action execution
         :param params: Dictionary of all the parameters needed for the action
         :param db_dict: Dictionary for any additional data
+        :param namespace str: The namespace (model) where the Bundle was deployed
         :param kwargs: Additional parameters
             vca_id (str): VCA ID
 
@@ -582,6 +579,10 @@ class K8sJujuConnector(K8sConnector):
         """
         libjuju = await self._get_libjuju(kwargs.get("vca_id"))
 
+        namespace = self._obtain_namespace(
+            kdu_instance=kdu_instance, namespace=namespace
+        )
+
         if not params or "application-name" not in params:
             raise K8sException(
                 "Missing application-name argument, \
@@ -590,14 +591,19 @@ class K8sJujuConnector(K8sConnector):
         try:
             self.log.debug(
                 "[exec_primitive] Getting model "
-                "kdu_instance: {}".format(kdu_instance)
+                "{} for the kdu_instance: {}".format(namespace, kdu_instance)
             )
             application_name = params["application-name"]
-            actions = await libjuju.get_actions(application_name, kdu_instance)
+            actions = await libjuju.get_actions(
+                application_name=application_name, model_name=namespace
+            )
             if primitive_name not in actions:
                 raise K8sException("Primitive {} not found".format(primitive_name))
             output, status = await libjuju.execute_action(
-                application_name, kdu_instance, primitive_name, **params
+                application_name=application_name,
+                model_name=namespace,
+                action_name=primitive_name,
+                **params,
             )
 
             if status != "completed":
@@ -606,7 +612,9 @@ class K8sJujuConnector(K8sConnector):
                 )
             if self.on_update_db:
                 await self.on_update_db(
-                    cluster_uuid, kdu_instance, filter=db_dict["filter"]
+                    cluster_uuid=cluster_uuid,
+                    kdu_instance=kdu_instance,
+                    filter=db_dict["filter"],
                 )
 
             return output
@@ -618,10 +626,7 @@ class K8sJujuConnector(K8sConnector):
 
     """Introspection"""
 
-    async def inspect_kdu(
-        self,
-        kdu_model: str,
-    ) -> dict:
+    async def inspect_kdu(self, kdu_model: str) -> dict:
         """Inspect a KDU
 
         Inspects a bundle and returns a dictionary of config parameters and
@@ -663,17 +668,14 @@ class K8sJujuConnector(K8sConnector):
 
         return kdu
 
-    async def help_kdu(
-        self,
-        kdu_model: str,
-    ) -> str:
+    async def help_kdu(self, kdu_model: str) -> str:
         """View the README
 
-        If available, returns the README of the bundle.
+                If available, returns the README of the bundle.
 
-        :param kdu_model str: The name or path of a bundle
-
-        :return: If found, returns the contents of the README.
+                :param kdu_model str: The name or path of a bundle
+        f
+                :return: If found, returns the contents of the README.
         """
         readme = None
 
@@ -693,6 +695,7 @@ class K8sJujuConnector(K8sConnector):
         kdu_instance: str,
         complete_status: bool = False,
         yaml_format: bool = False,
+        namespace: str = None,
         **kwargs,
     ) -> Union[str, dict]:
         """Get the status of the KDU
@@ -703,6 +706,7 @@ class K8sJujuConnector(K8sConnector):
         :param kdu_instance str: The unique id of the KDU instance
         :param complete_status: To get the complete_status of the KDU
         :param yaml_format: To get the status in proper format for NSR record
+        :param namespace str: The namespace (model) where the Bundle was deployed
         :param: kwargs: Additional parameters
             vca_id (str): VCA ID
 
@@ -712,7 +716,10 @@ class K8sJujuConnector(K8sConnector):
         libjuju = await self._get_libjuju(kwargs.get("vca_id"))
         status = {}
 
-        model_status = await libjuju.get_model_status(kdu_instance)
+        model_name = self._obtain_namespace(
+            kdu_instance=kdu_instance, namespace=namespace
+        )
+        model_status = await libjuju.get_model_status(model_name=model_name)
 
         if not complete_status:
             for name in model_status.applications:
@@ -727,9 +734,7 @@ class K8sJujuConnector(K8sConnector):
         return status
 
     async def add_relation(
-        self,
-        provider: RelationEndpoint,
-        requirer: RelationEndpoint,
+        self, provider: RelationEndpoint, requirer: RelationEndpoint
     ):
         """
         Add relation between two charmed endpoints
@@ -740,7 +745,7 @@ class K8sJujuConnector(K8sConnector):
         self.log.debug(f"adding new relation between {provider} and {requirer}")
         cross_model_relation = (
             provider.model_name != requirer.model_name
-            or requirer.vca_id != requirer.vca_id
+            or provider.vca_id != requirer.vca_id
         )
         try:
             if cross_model_relation:
@@ -753,9 +758,7 @@ class K8sJujuConnector(K8sConnector):
                         requirer.model_name, offer, provider_libjuju
                     )
                     await requirer_libjuju.add_relation(
-                        requirer.model_name,
-                        requirer.endpoint,
-                        saas_name,
+                        requirer.model_name, requirer.endpoint, saas_name
                     )
             else:
                 # Standard relation
@@ -773,34 +776,44 @@ class K8sJujuConnector(K8sConnector):
             self.log.error(message)
             raise Exception(message=message)
 
-    async def update_vca_status(self, vcastatus: dict, kdu_instance: str, **kwargs):
+    async def update_vca_status(
+        self, vcastatus: dict, kdu_instance: str, namespace: str = None, **kwargs
+    ):
         """
         Add all configs, actions, executed actions of all applications in a model to vcastatus dict
 
         :param vcastatus dict: dict containing vcastatus
         :param kdu_instance str: The unique id of the KDU instance
+        :param namespace str: The namespace (model) where the Bundle was deployed
         :param: kwargs: Additional parameters
             vca_id (str): VCA ID
 
         :return: None
         """
+
+        model_name = self._obtain_namespace(
+            kdu_instance=kdu_instance, namespace=namespace
+        )
+
         libjuju = await self._get_libjuju(kwargs.get("vca_id"))
         try:
-            for model_name in vcastatus:
+            for vca_model_name in vcastatus:
                 # Adding executed actions
-                vcastatus[model_name][
+                vcastatus[vca_model_name][
                     "executedActions"
-                ] = await libjuju.get_executed_actions(kdu_instance)
+                ] = await libjuju.get_executed_actions(model_name=model_name)
 
-                for application in vcastatus[model_name]["applications"]:
+                for application in vcastatus[vca_model_name]["applications"]:
                     # Adding application actions
-                    vcastatus[model_name]["applications"][application][
+                    vcastatus[vca_model_name]["applications"][application][
                         "actions"
-                    ] = await libjuju.get_actions(application, kdu_instance)
+                    ] = {}
                     # Adding application configs
-                    vcastatus[model_name]["applications"][application][
+                    vcastatus[vca_model_name]["applications"][application][
                         "configs"
-                    ] = await libjuju.get_application_configs(kdu_instance, application)
+                    ] = await libjuju.get_application_configs(
+                        model_name=model_name, application_name=application
+                    )
 
         except Exception as e:
             self.log.debug("Error in updating vca status: {}".format(str(e)))
@@ -810,10 +823,14 @@ class K8sJujuConnector(K8sConnector):
     ) -> list:
         """Return a list of services of a kdu_instance"""
 
+        namespace = self._obtain_namespace(
+            kdu_instance=kdu_instance, namespace=namespace
+        )
+
         credentials = self.get_credentials(cluster_uuid=cluster_uuid)
         kubectl = self._get_kubectl(credentials)
         return kubectl.get_services(
-            field_selector="metadata.namespace={}".format(kdu_instance)
+            field_selector="metadata.namespace={}".format(namespace)
         )
 
     async def get_service(
@@ -862,10 +879,7 @@ class K8sJujuConnector(K8sConnector):
         """
         return "cred-{}".format(cluster_uuid)
 
-    def get_namespace(
-        self,
-        cluster_uuid: str,
-    ) -> str:
+    def get_namespace(self, cluster_uuid: str) -> str:
         """Get the namespace UUID
         Gets the namespace's unique name
 
@@ -898,16 +912,11 @@ class K8sJujuConnector(K8sConnector):
             if not self.libjuju:
                 async with self.loading_libjuju:
                     vca_connection = await get_connection(self._store)
-                    self.libjuju = Libjuju(vca_connection, loop=self.loop, log=self.log)
+                    self.libjuju = Libjuju(vca_connection, log=self.log)
             return self.libjuju
         else:
             vca_connection = await get_connection(self._store, vca_id)
-            return Libjuju(
-                vca_connection,
-                loop=self.loop,
-                log=self.log,
-                n2vc=self,
-            )
+            return Libjuju(vca_connection, log=self.log, n2vc=self)
 
     def _get_kubectl(self, credentials: str) -> Kubectl:
         """
@@ -919,3 +928,34 @@ class K8sJujuConnector(K8sConnector):
         with open(kubecfg.name, "w") as kubecfg_file:
             kubecfg_file.write(credentials)
         return Kubectl(config_file=kubecfg.name)
+
+    def _obtain_namespace(self, kdu_instance: str, namespace: str = None) -> str:
+        """
+        Obtain the namespace/model name to use in the instantiation of a Juju Bundle in K8s. The default namespace is
+        the kdu_instance name. However, if the user passes the namespace where he wants to deploy the bundle,
+        that namespace will be used.
+
+        :param kdu_instance: the default KDU instance name
+        :param namespace: the namespace passed by the User
+        """
+
+        # deault the namespace/model name to the kdu_instance name TODO -> this should be the real return... But
+        #  once the namespace is not passed in most methods, I had to do this in another way. But I think this should
+        #  be the procedure in the future return namespace if namespace else kdu_instance
+
+        # TODO -> has referred above, this should be avoided in the future, this is temporary, in order to avoid
+        #  compatibility issues
+        return (
+            namespace
+            if namespace
+            else self._obtain_namespace_from_db(kdu_instance=kdu_instance)
+        )
+
+    def _obtain_namespace_from_db(self, kdu_instance: str) -> str:
+        db_nsrs = self.db.get_one(
+            table="nsrs", q_filter={"_admin.deployed.K8s.kdu-instance": kdu_instance}
+        )
+        for k8s in db_nsrs["_admin"]["deployed"]["K8s"]:
+            if k8s.get("kdu-instance") == kdu_instance:
+                return k8s.get("namespace")
+        return ""