n2vc/k8s_juju_conn.py

   1 # Copyright 2019 Canonical Ltd.
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #     http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 #     Unless required by applicable law or agreed to in writing, software
  10 #     distributed under the License is distributed on an "AS IS" BASIS,
  11 #     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 #     See the License for the specific language governing permissions and
  13 #     limitations under the License.
  14
  15 import asyncio
  16 from typing import Union
  17 import os
  18 import uuid
  19 import yaml
  20 import tempfile
  21 import binascii
  22
  23 from n2vc.config import EnvironConfig
  24 from n2vc.definitions import RelationEndpoint
  25 from n2vc.exceptions import K8sException
  26 from n2vc.k8s_conn import K8sConnector
  27 from n2vc.kubectl import Kubectl
  28 from .exceptions import MethodNotImplemented
  29 from n2vc.libjuju import Libjuju
  30 from n2vc.utils import obj_to_dict, obj_to_yaml
  31 from n2vc.store import MotorStore
  32 from n2vc.vca.cloud import Cloud
  33 from n2vc.vca.connection import get_connection
  34
  35
  36 RBAC_LABEL_KEY_NAME = "rbac-id"
  37 RBAC_STACK_PREFIX = "juju-credential"
  38
  39
  40 def generate_rbac_id():
  41     return binascii.hexlify(os.urandom(4)).decode()
  42
  43
  44 class K8sJujuConnector(K8sConnector):
  45     libjuju = None
  46
  47     def __init__(
  48         self,
  49         fs: object,
  50         db: object,
  51         kubectl_command: str = "/usr/bin/kubectl",
  52         juju_command: str = "/usr/bin/juju",
  53         log: object = None,
  54         loop: object = None,
  55         on_update_db=None,
  56     ):
  57         """
  58         :param fs: file system for kubernetes and helm configuration
  59         :param db: Database object
  60         :param kubectl_command: path to kubectl executable
  61         :param helm_command: path to helm executable
  62         :param log: logger
  63         :param: loop: Asyncio loop
  64         """
  65
  66         # parent class
  67         K8sConnector.__init__(
  68             self,
  69             db,
  70             log=log,
  71             on_update_db=on_update_db,
  72         )
  73
  74         self.fs = fs
  75         self.loop = loop or asyncio.get_event_loop()
  76         self.log.debug("Initializing K8S Juju connector")
  77
  78         db_uri = EnvironConfig(prefixes=["OSMLCM_", "OSMMON_"]).get("database_uri")
  79         self._store = MotorStore(db_uri)
  80         self.loading_libjuju = asyncio.Lock(loop=self.loop)
  81
  82         self.log.debug("K8S Juju connector initialized")
  83         # TODO: Remove these commented lines:
  84         # self.authenticated = False
  85         # self.models = {}
  86         # self.juju_secret = ""
  87
  88     """Initialization"""
  89
  90     async def init_env(
  91         self,
  92         k8s_creds: str,
  93         namespace: str = "kube-system",
  94         reuse_cluster_uuid: str = None,
  95         **kwargs,
  96     ) -> (str, bool):
  97         """
  98         It prepares a given K8s cluster environment to run Juju bundles.
  99
 100         :param k8s_creds: credentials to access a given K8s cluster, i.e. a valid
 101             '.kube/config'
 102         :param namespace: optional namespace to be used for juju. By default,
 103             'kube-system' will be used
 104         :param reuse_cluster_uuid: existing cluster uuid for reuse
 105         :param: kwargs: Additional parameters
 106             vca_id (str): VCA ID
 107
 108         :return: uuid of the K8s cluster and True if connector has installed some
 109             software in the cluster
 110             (on error, an exception will be raised)
 111         """
 112         libjuju = await self._get_libjuju(kwargs.get("vca_id"))
 113
 114         cluster_uuid = reuse_cluster_uuid or str(uuid.uuid4())
 115         kubectl = self._get_kubectl(k8s_creds)
 116
 117         # CREATING RESOURCES IN K8S
 118         rbac_id = generate_rbac_id()
 119         metadata_name = "{}-{}".format(RBAC_STACK_PREFIX, rbac_id)
 120         labels = {RBAC_STACK_PREFIX: rbac_id}
 121
 122         # Create cleanup dictionary to clean up created resources
 123         # if it fails in the middle of the process
 124         cleanup_data = []
 125         try:
 126             kubectl.create_cluster_role(
 127                 name=metadata_name,
 128                 labels=labels,
 129             )
 130             cleanup_data.append(
 131                 {
 132                     "delete": kubectl.delete_cluster_role,
 133                     "args": (metadata_name,),
 134                 }
 135             )
 136
 137             kubectl.create_service_account(
 138                 name=metadata_name,
 139                 labels=labels,
 140             )
 141             cleanup_data.append(
 142                 {
 143                     "delete": kubectl.delete_service_account,
 144                     "args": (metadata_name,),
 145                 }
 146             )
 147
 148             kubectl.create_cluster_role_binding(
 149                 name=metadata_name,
 150                 labels=labels,
 151             )
 152             cleanup_data.append(
 153                 {
 154                     "delete": kubectl.delete_service_account,
 155                     "args": (metadata_name,),
 156                 }
 157             )
 158             token, client_cert_data = await kubectl.get_secret_data(
 159                 metadata_name,
 160             )
 161
 162             default_storage_class = kubectl.get_default_storage_class()
 163             await libjuju.add_k8s(
 164                 name=cluster_uuid,
 165                 rbac_id=rbac_id,
 166                 token=token,
 167                 client_cert_data=client_cert_data,
 168                 configuration=kubectl.configuration,
 169                 storage_class=default_storage_class,
 170                 credential_name=self._get_credential_name(cluster_uuid),
 171             )
 172             return cluster_uuid, True
 173         except Exception as e:
 174             self.log.error("Error initializing k8scluster: {}".format(e))
 175             if len(cleanup_data) > 0:
 176                 self.log.debug("Cleaning up created resources in k8s cluster...")
 177                 for item in cleanup_data:
 178                     delete_function = item["delete"]
 179                     delete_args = item["args"]
 180                     delete_function(*delete_args)
 181                 self.log.debug("Cleanup finished")
 182             raise e
 183
 184     """Repo Management"""
 185
 186     async def repo_add(
 187         self,
 188         name: str,
 189         url: str,
 190         _type: str = "charm",
 191     ):
 192         raise MethodNotImplemented()
 193
 194     async def repo_list(self):
 195         raise MethodNotImplemented()
 196
 197     async def repo_remove(
 198         self,
 199         name: str,
 200     ):
 201         raise MethodNotImplemented()
 202
 203     async def synchronize_repos(self, cluster_uuid: str, name: str):
 204         """
 205         Returns None as currently add_repo is not implemented
 206         """
 207         return None
 208
 209     """Reset"""
 210
 211     async def reset(
 212         self,
 213         cluster_uuid: str,
 214         force: bool = False,
 215         uninstall_sw: bool = False,
 216         **kwargs,
 217     ) -> bool:
 218         """Reset a cluster
 219
 220         Resets the Kubernetes cluster by removing the model that represents it.
 221
 222         :param cluster_uuid str: The UUID of the cluster to reset
 223         :param force: Force reset
 224         :param uninstall_sw: Boolean to uninstall sw
 225         :param: kwargs: Additional parameters
 226             vca_id (str): VCA ID
 227
 228         :return: Returns True if successful or raises an exception.
 229         """
 230
 231         try:
 232             self.log.debug("[reset] Removing k8s cloud")
 233             libjuju = await self._get_libjuju(kwargs.get("vca_id"))
 234
 235             cloud = Cloud(cluster_uuid, self._get_credential_name(cluster_uuid))
 236
 237             cloud_creds = await libjuju.get_cloud_credentials(cloud)
 238
 239             await libjuju.remove_cloud(cluster_uuid)
 240
 241             credentials = self.get_credentials(cluster_uuid=cluster_uuid)
 242
 243             kubectl = self._get_kubectl(credentials)
 244
 245             delete_functions = [
 246                 kubectl.delete_cluster_role_binding,
 247                 kubectl.delete_service_account,
 248                 kubectl.delete_cluster_role,
 249             ]
 250
 251             credential_attrs = cloud_creds[0].result["attrs"]
 252             if RBAC_LABEL_KEY_NAME in credential_attrs:
 253                 rbac_id = credential_attrs[RBAC_LABEL_KEY_NAME]
 254                 metadata_name = "{}-{}".format(RBAC_STACK_PREFIX, rbac_id)
 255                 for delete_func in delete_functions:
 256                     try:
 257                         delete_func(metadata_name)
 258                     except Exception as e:
 259                         self.log.warning("Cannot remove resource in K8s {}".format(e))
 260
 261         except Exception as e:
 262             self.log.debug("Caught exception during reset: {}".format(e))
 263             raise e
 264         return True
 265
 266     """Deployment"""
 267
 268     async def install(
 269         self,
 270         cluster_uuid: str,
 271         kdu_model: str,
 272         kdu_instance: str,
 273         atomic: bool = True,
 274         timeout: float = 1800,
 275         params: dict = None,
 276         db_dict: dict = None,
 277         kdu_name: str = None,
 278         namespace: str = None,
 279         **kwargs,
 280     ) -> bool:
 281         """Install a bundle
 282
 283         :param cluster_uuid str: The UUID of the cluster to install to
 284         :param kdu_model str: The name or path of a bundle to install
 285         :param kdu_instance: Kdu instance name
 286         :param atomic bool: If set, waits until the model is active and resets
 287                             the cluster on failure.
 288         :param timeout int: The time, in seconds, to wait for the install
 289                             to finish
 290         :param params dict: Key-value pairs of instantiation parameters
 291         :param kdu_name: Name of the KDU instance to be installed
 292         :param namespace: K8s namespace to use for the KDU instance
 293         :param kwargs: Additional parameters
 294             vca_id (str): VCA ID
 295
 296         :return: If successful, returns ?
 297         """
 298         libjuju = await self._get_libjuju(kwargs.get("vca_id"))
 299         bundle = kdu_model
 300
 301         if not db_dict:
 302             raise K8sException("db_dict must be set")
 303         if not bundle:
 304             raise K8sException("bundle must be set")
 305
 306         if bundle.startswith("cs:"):
 307             # For Juju Bundles provided by the Charm Store
 308             pass
 309         elif bundle.startswith("ch:"):
 310             # For Juju Bundles provided by the Charm Hub (this only works for juju version >= 2.9)
 311             pass
 312         elif bundle.startswith("http"):
 313             # Download the file
 314             pass
 315         else:
 316             new_workdir = kdu_model.strip(kdu_model.split("/")[-1])
 317             os.chdir(new_workdir)
 318             bundle = "local:{}".format(kdu_model)
 319
 320         self.log.debug("Checking for model named {}".format(kdu_instance))
 321
 322         # Create the new model
 323         self.log.debug("Adding model: {}".format(kdu_instance))
 324         cloud = Cloud(cluster_uuid, self._get_credential_name(cluster_uuid))
 325         await libjuju.add_model(kdu_instance, cloud)
 326
 327         # if model:
 328         # TODO: Instantiation parameters
 329
 330         """
 331         "Juju bundle that models the KDU, in any of the following ways:
 332             - <juju-repo>/<juju-bundle>
 333             - <juju-bundle folder under k8s_models folder in the package>
 334             - <juju-bundle tgz file (w/ or w/o extension) under k8s_models folder
 335                 in the package>
 336             - <URL_where_to_fetch_juju_bundle>
 337         """
 338         try:
 339             previous_workdir = os.getcwd()
 340         except FileNotFoundError:
 341             previous_workdir = "/app/storage"
 342
 343         self.log.debug("[install] deploying {}".format(bundle))
 344         await libjuju.deploy(
 345             bundle, model_name=kdu_instance, wait=atomic, timeout=timeout
 346         )
 347         os.chdir(previous_workdir)
 348         if self.on_update_db:
 349             await self.on_update_db(
 350                 cluster_uuid,
 351                 kdu_instance,
 352                 filter=db_dict["filter"],
 353                 vca_id=kwargs.get("vca_id"),
 354             )
 355         return True
 356
 357     async def scale(
 358         self,
 359         kdu_instance: str,
 360         scale: int,
 361         resource_name: str,
 362         total_timeout: float = 1800,
 363         **kwargs,
 364     ) -> bool:
 365         """Scale an application in a model
 366
 367         :param: kdu_instance str:        KDU instance name
 368         :param: scale int:               Scale to which to set this application
 369         :param: resource_name str:       Resource name (Application name)
 370         :param: timeout float:           The time, in seconds, to wait for the install
 371                                          to finish
 372         :param kwargs:                   Additional parameters
 373                                             vca_id (str): VCA ID
 374
 375         :return: If successful, returns True
 376         """
 377
 378         try:
 379             libjuju = await self._get_libjuju(kwargs.get("vca_id"))
 380             await libjuju.scale_application(
 381                 model_name=kdu_instance,
 382                 application_name=resource_name,
 383                 scale=scale,
 384                 total_timeout=total_timeout,
 385             )
 386         except Exception as e:
 387             error_msg = "Error scaling application {} in kdu instance {}: {}".format(
 388                 resource_name, kdu_instance, e
 389             )
 390             self.log.error(error_msg)
 391             raise K8sException(message=error_msg)
 392         return True
 393
 394     async def get_scale_count(
 395         self,
 396         resource_name: str,
 397         kdu_instance: str,
 398         **kwargs,
 399     ) -> int:
 400         """Get an application scale count
 401
 402         :param: resource_name str:       Resource name (Application name)
 403         :param: kdu_instance str:        KDU instance name
 404         :param kwargs:                   Additional parameters
 405                                             vca_id (str): VCA ID
 406         :return: Return application instance count
 407         """
 408         try:
 409             libjuju = await self._get_libjuju(kwargs.get("vca_id"))
 410             status = await libjuju.get_model_status(kdu_instance)
 411             return len(status.applications[resource_name].units)
 412         except Exception as e:
 413             error_msg = "Error getting scale count from application {} in kdu instance {}: {}".format(
 414                 resource_name, kdu_instance, e
 415             )
 416             self.log.error(error_msg)
 417             raise K8sException(message=error_msg)
 418
 419     async def instances_list(self, cluster_uuid: str) -> list:
 420         """
 421         returns a list of deployed releases in a cluster
 422
 423         :param cluster_uuid: the cluster
 424         :return:
 425         """
 426         return []
 427
 428     async def upgrade(
 429         self,
 430         cluster_uuid: str,
 431         kdu_instance: str,
 432         kdu_model: str = None,
 433         params: dict = None,
 434     ) -> str:
 435         """Upgrade a model
 436
 437         :param cluster_uuid str: The UUID of the cluster to upgrade
 438         :param kdu_instance str: The unique name of the KDU instance
 439         :param kdu_model str: The name or path of the bundle to upgrade to
 440         :param params dict: Key-value pairs of instantiation parameters
 441
 442         :return: If successful, reference to the new revision number of the
 443                  KDU instance.
 444         """
 445
 446         # TODO: Loop through the bundle and upgrade each charm individually
 447
 448         """
 449         The API doesn't have a concept of bundle upgrades, because there are
 450         many possible changes: charm revision, disk, number of units, etc.
 451
 452         As such, we are only supporting a limited subset of upgrades. We'll
 453         upgrade the charm revision but leave storage and scale untouched.
 454
 455         Scale changes should happen through OSM constructs, and changes to
 456         storage would require a redeployment of the service, at least in this
 457         initial release.
 458         """
 459         raise MethodNotImplemented()
 460
 461     """Rollback"""
 462
 463     async def rollback(
 464         self,
 465         cluster_uuid: str,
 466         kdu_instance: str,
 467         revision: int = 0,
 468     ) -> str:
 469         """Rollback a model
 470
 471         :param cluster_uuid str: The UUID of the cluster to rollback
 472         :param kdu_instance str: The unique name of the KDU instance
 473         :param revision int: The revision to revert to. If omitted, rolls back
 474                              the previous upgrade.
 475
 476         :return: If successful, returns the revision of active KDU instance,
 477                  or raises an exception
 478         """
 479         raise MethodNotImplemented()
 480
 481     """Deletion"""
 482
 483     async def uninstall(
 484         self,
 485         cluster_uuid: str,
 486         kdu_instance: str,
 487         **kwargs,
 488     ) -> bool:
 489         """Uninstall a KDU instance
 490
 491         :param cluster_uuid str: The UUID of the cluster
 492         :param kdu_instance str: The unique name of the KDU instance
 493         :param kwargs: Additional parameters
 494             vca_id (str): VCA ID
 495
 496         :return: Returns True if successful, or raises an exception
 497         """
 498
 499         self.log.debug("[uninstall] Destroying model")
 500         libjuju = await self._get_libjuju(kwargs.get("vca_id"))
 501
 502         await libjuju.destroy_model(kdu_instance, total_timeout=3600)
 503
 504         # self.log.debug("[uninstall] Model destroyed and disconnecting")
 505         # await controller.disconnect()
 506
 507         return True
 508         # TODO: Remove these commented lines
 509         # if not self.authenticated:
 510         #     self.log.debug("[uninstall] Connecting to controller")
 511         #     await self.login(cluster_uuid)
 512
 513     async def exec_primitive(
 514         self,
 515         cluster_uuid: str = None,
 516         kdu_instance: str = None,
 517         primitive_name: str = None,
 518         timeout: float = 300,
 519         params: dict = None,
 520         db_dict: dict = None,
 521         **kwargs,
 522     ) -> str:
 523         """Exec primitive (Juju action)
 524
 525         :param cluster_uuid str: The UUID of the cluster
 526         :param kdu_instance str: The unique name of the KDU instance
 527         :param primitive_name: Name of action that will be executed
 528         :param timeout: Timeout for action execution
 529         :param params: Dictionary of all the parameters needed for the action
 530         :param db_dict: Dictionary for any additional data
 531         :param kwargs: Additional parameters
 532             vca_id (str): VCA ID
 533
 534         :return: Returns the output of the action
 535         """
 536         libjuju = await self._get_libjuju(kwargs.get("vca_id"))
 537
 538         if not params or "application-name" not in params:
 539             raise K8sException(
 540                 "Missing application-name argument, \
 541                                 argument needed for K8s actions"
 542             )
 543         try:
 544             self.log.debug(
 545                 "[exec_primitive] Getting model "
 546                 "kdu_instance: {}".format(kdu_instance)
 547             )
 548             application_name = params["application-name"]
 549             actions = await libjuju.get_actions(application_name, kdu_instance)
 550             if primitive_name not in actions:
 551                 raise K8sException("Primitive {} not found".format(primitive_name))
 552             output, status = await libjuju.execute_action(
 553                 application_name, kdu_instance, primitive_name, **params
 554             )
 555
 556             if status != "completed":
 557                 raise K8sException(
 558                     "status is not completed: {} output: {}".format(status, output)
 559                 )
 560             if self.on_update_db:
 561                 await self.on_update_db(
 562                     cluster_uuid, kdu_instance, filter=db_dict["filter"]
 563                 )
 564
 565             return output
 566
 567         except Exception as e:
 568             error_msg = "Error executing primitive {}: {}".format(primitive_name, e)
 569             self.log.error(error_msg)
 570             raise K8sException(message=error_msg)
 571
 572     """Introspection"""
 573
 574     async def inspect_kdu(
 575         self,
 576         kdu_model: str,
 577     ) -> dict:
 578         """Inspect a KDU
 579
 580         Inspects a bundle and returns a dictionary of config parameters and
 581         their default values.
 582
 583         :param kdu_model str: The name or path of the bundle to inspect.
 584
 585         :return: If successful, returns a dictionary of available parameters
 586                  and their default values.
 587         """
 588
 589         kdu = {}
 590         if not os.path.exists(kdu_model):
 591             raise K8sException("file {} not found".format(kdu_model))
 592
 593         with open(kdu_model, "r") as f:
 594             bundle = yaml.safe_load(f.read())
 595
 596             """
 597             {
 598                 'description': 'Test bundle',
 599                 'bundle': 'kubernetes',
 600                 'applications': {
 601                     'mariadb-k8s': {
 602                         'charm': 'cs:~charmed-osm/mariadb-k8s-20',
 603                         'scale': 1,
 604                         'options': {
 605                             'password': 'manopw',
 606                             'root_password': 'osm4u',
 607                             'user': 'mano'
 608                         },
 609                         'series': 'kubernetes'
 610                     }
 611                 }
 612             }
 613             """
 614             # TODO: This should be returned in an agreed-upon format
 615             kdu = bundle["applications"]
 616
 617         return kdu
 618
 619     async def help_kdu(
 620         self,
 621         kdu_model: str,
 622     ) -> str:
 623         """View the README
 624
 625         If available, returns the README of the bundle.
 626
 627         :param kdu_model str: The name or path of a bundle
 628
 629         :return: If found, returns the contents of the README.
 630         """
 631         readme = None
 632
 633         files = ["README", "README.txt", "README.md"]
 634         path = os.path.dirname(kdu_model)
 635         for file in os.listdir(path):
 636             if file in files:
 637                 with open(file, "r") as f:
 638                     readme = f.read()
 639                     break
 640
 641         return readme
 642
 643     async def status_kdu(
 644         self,
 645         cluster_uuid: str,
 646         kdu_instance: str,
 647         complete_status: bool = False,
 648         yaml_format: bool = False,
 649         **kwargs,
 650     ) -> Union[str, dict]:
 651         """Get the status of the KDU
 652
 653         Get the current status of the KDU instance.
 654
 655         :param cluster_uuid str: The UUID of the cluster
 656         :param kdu_instance str: The unique id of the KDU instance
 657         :param complete_status: To get the complete_status of the KDU
 658         :param yaml_format: To get the status in proper format for NSR record
 659         :param: kwargs: Additional parameters
 660             vca_id (str): VCA ID
 661
 662         :return: Returns a dictionary containing namespace, state, resources,
 663                  and deployment_time and returns complete_status if complete_status is True
 664         """
 665         libjuju = await self._get_libjuju(kwargs.get("vca_id"))
 666         status = {}
 667
 668         model_status = await libjuju.get_model_status(kdu_instance)
 669
 670         if not complete_status:
 671             for name in model_status.applications:
 672                 application = model_status.applications[name]
 673                 status[name] = {"status": application["status"]["status"]}
 674         else:
 675             if yaml_format:
 676                 return obj_to_yaml(model_status)
 677             else:
 678                 return obj_to_dict(model_status)
 679
 680         return status
 681
 682     async def add_relation(
 683         self,
 684         provider: RelationEndpoint,
 685         requirer: RelationEndpoint,
 686     ):
 687         """
 688         Add relation between two charmed endpoints
 689
 690         :param: provider: Provider relation endpoint
 691         :param: requirer: Requirer relation endpoint
 692         """
 693         self.log.debug(f"adding new relation between {provider} and {requirer}")
 694         cross_model_relation = (
 695             provider.model_name != requirer.model_name
 696             or requirer.vca_id != requirer.vca_id
 697         )
 698         try:
 699             if cross_model_relation:
 700                 # Cross-model relation
 701                 provider_libjuju = await self._get_libjuju(provider.vca_id)
 702                 requirer_libjuju = await self._get_libjuju(requirer.vca_id)
 703                 offer = await provider_libjuju.offer(provider)
 704                 if offer:
 705                     saas_name = await requirer_libjuju.consume(
 706                         requirer.model_name, offer, provider_libjuju
 707                     )
 708                     await requirer_libjuju.add_relation(
 709                         requirer.model_name,
 710                         requirer.endpoint,
 711                         saas_name,
 712                     )
 713             else:
 714                 # Standard relation
 715                 vca_id = provider.vca_id
 716                 model = provider.model_name
 717                 libjuju = await self._get_libjuju(vca_id)
 718                 # add juju relations between two applications
 719                 await libjuju.add_relation(
 720                     model_name=model,
 721                     endpoint_1=provider.endpoint,
 722                     endpoint_2=requirer.endpoint,
 723                 )
 724         except Exception as e:
 725             message = f"Error adding relation between {provider} and {requirer}: {e}"
 726             self.log.error(message)
 727             raise Exception(message=message)
 728
 729     async def update_vca_status(self, vcastatus: dict, kdu_instance: str, **kwargs):
 730         """
 731         Add all configs, actions, executed actions of all applications in a model to vcastatus dict
 732
 733         :param vcastatus dict: dict containing vcastatus
 734         :param kdu_instance str: The unique id of the KDU instance
 735         :param: kwargs: Additional parameters
 736             vca_id (str): VCA ID
 737
 738         :return: None
 739         """
 740         libjuju = await self._get_libjuju(kwargs.get("vca_id"))
 741         try:
 742             for model_name in vcastatus:
 743                 # Adding executed actions
 744                 vcastatus[model_name][
 745                     "executedActions"
 746                 ] = await libjuju.get_executed_actions(kdu_instance)
 747
 748                 for application in vcastatus[model_name]["applications"]:
 749                     # Adding application actions
 750                     vcastatus[model_name]["applications"][application][
 751                         "actions"
 752                     ] = await libjuju.get_actions(application, kdu_instance)
 753                     # Adding application configs
 754                     vcastatus[model_name]["applications"][application][
 755                         "configs"
 756                     ] = await libjuju.get_application_configs(kdu_instance, application)
 757
 758         except Exception as e:
 759             self.log.debug("Error in updating vca status: {}".format(str(e)))
 760
 761     async def get_services(
 762         self, cluster_uuid: str, kdu_instance: str, namespace: str
 763     ) -> list:
 764         """Return a list of services of a kdu_instance"""
 765
 766         credentials = self.get_credentials(cluster_uuid=cluster_uuid)
 767         kubectl = self._get_kubectl(credentials)
 768         return kubectl.get_services(
 769             field_selector="metadata.namespace={}".format(kdu_instance)
 770         )
 771
 772     async def get_service(
 773         self, cluster_uuid: str, service_name: str, namespace: str
 774     ) -> object:
 775         """Return data for a specific service inside a namespace"""
 776
 777         credentials = self.get_credentials(cluster_uuid=cluster_uuid)
 778         kubectl = self._get_kubectl(credentials)
 779         return kubectl.get_services(
 780             field_selector="metadata.name={},metadata.namespace={}".format(
 781                 service_name, namespace
 782             )
 783         )[0]
 784
 785     def get_credentials(self, cluster_uuid: str) -> str:
 786         """
 787         Get Cluster Kubeconfig
 788         """
 789         k8scluster = self.db.get_one(
 790             "k8sclusters", q_filter={"_id": cluster_uuid}, fail_on_empty=False
 791         )
 792
 793         self.db.encrypt_decrypt_fields(
 794             k8scluster.get("credentials"),
 795             "decrypt",
 796             ["password", "secret"],
 797             schema_version=k8scluster["schema_version"],
 798             salt=k8scluster["_id"],
 799         )
 800
 801         return yaml.safe_dump(k8scluster.get("credentials"))
 802
 803     def _get_credential_name(self, cluster_uuid: str) -> str:
 804         """
 805         Get credential name for a k8s cloud
 806
 807         We cannot use the cluster_uuid for the credential name directly,
 808         because it cannot start with a number, it must start with a letter.
 809         Therefore, the k8s cloud credential name will be "cred-" followed
 810         by the cluster uuid.
 811
 812         :param: cluster_uuid:   Cluster UUID of the kubernetes cloud (=cloud_name)
 813
 814         :return:                Name to use for the credential name.
 815         """
 816         return "cred-{}".format(cluster_uuid)
 817
 818     def get_namespace(
 819         self,
 820         cluster_uuid: str,
 821     ) -> str:
 822         """Get the namespace UUID
 823         Gets the namespace's unique name
 824
 825         :param cluster_uuid str: The UUID of the cluster
 826         :returns: The namespace UUID, or raises an exception
 827         """
 828         pass
 829
 830     @staticmethod
 831     def generate_kdu_instance_name(**kwargs):
 832         db_dict = kwargs.get("db_dict")
 833         kdu_name = kwargs.get("kdu_name", None)
 834         if kdu_name:
 835             kdu_instance = "{}-{}".format(kdu_name, db_dict["filter"]["_id"])
 836         else:
 837             kdu_instance = db_dict["filter"]["_id"]
 838         return kdu_instance
 839
 840     async def _get_libjuju(self, vca_id: str = None) -> Libjuju:
 841         """
 842         Get libjuju object
 843
 844         :param: vca_id: VCA ID
 845                         If None, get a libjuju object with a Connection to the default VCA
 846                         Else, geta libjuju object with a Connection to the specified VCA
 847         """
 848         if not vca_id:
 849             while self.loading_libjuju.locked():
 850                 await asyncio.sleep(0.1)
 851             if not self.libjuju:
 852                 async with self.loading_libjuju:
 853                     vca_connection = await get_connection(self._store)
 854                     self.libjuju = Libjuju(vca_connection, loop=self.loop, log=self.log)
 855             return self.libjuju
 856         else:
 857             vca_connection = await get_connection(self._store, vca_id)
 858             return Libjuju(
 859                 vca_connection,
 860                 loop=self.loop,
 861                 log=self.log,
 862                 n2vc=self,
 863             )
 864
 865     def _get_kubectl(self, credentials: str) -> Kubectl:
 866         """
 867         Get Kubectl object
 868
 869         :param: kubeconfig_credentials: Kubeconfig credentials
 870         """
 871         kubecfg = tempfile.NamedTemporaryFile()
 872         with open(kubecfg.name, "w") as kubecfg_file:
 873             kubecfg_file.write(credentials)
 874         return Kubectl(config_file=kubecfg.name)