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 concurrent
  16 from .exceptions import NotImplemented
  17
  18 import juju
  19 # from juju.bundle import BundleHandler
  20 from juju.controller import Controller
  21 from juju.model import Model
  22 from juju.errors import JujuAPIError, JujuError
  23
  24 import logging
  25
  26 from n2vc.k8s_conn import K8sConnector
  27
  28 import os
  29 # import re
  30 # import ssl
  31 import subprocess
  32 # from .vnf import N2VC
  33
  34 import uuid
  35 import yaml
  36
  37
  38 class K8sJujuConnector(K8sConnector):
  39     def __init__(
  40             self,
  41             fs,
  42             kubectl_command='/usr/bin/kubectl',
  43             log=None
  44     ):
  45         """
  46
  47         :param kubectl_command: path to kubectl executable
  48         :param helm_command: path to helm executable
  49         :param fs: file system for kubernetes and helm configuration
  50         :param log: logger
  51         """
  52
  53         # parent class
  54         K8sConnector.__init__(
  55             self,
  56             kubectl_command=kubectl_command,
  57             fs=fs,
  58             log=log,
  59         )
  60
  61         self.info('Initializing K8S Juju connector')
  62
  63         self.authenticated = False
  64         self.models = {}
  65         self.log = logging.getLogger(__name__)
  66         self.info('K8S Juju connector initialized')
  67
  68     """Initialization"""
  69     async def init_env(
  70         self,
  71         k8s_creds: dict,
  72         namespace: str = 'kube-system',
  73         reuse_cluster_uuid: str = None,
  74     ) -> str:
  75         """Initialize a Kubernetes environment
  76
  77         :param k8s_creds dict: A dictionary containing the Kubernetes cluster
  78         configuration
  79         :param namespace str: The Kubernetes namespace to initialize
  80
  81         :return: UUID of the k8s context or raises an exception
  82         """
  83
  84         """Bootstrapping
  85
  86         Bootstrapping cannot be done, by design, through the API. We need to
  87         use the CLI tools.
  88         """
  89         # TODO: The path may change
  90         jujudir = "/snap/bin"
  91
  92         self.k8scli = "{}/juju".format(jujudir)
  93
  94         """
  95         WIP: Workflow
  96
  97         1. Has the environment already been bootstrapped?
  98         - Check the database to see if we have a record for this env
  99
 100         2. If this is a new env, create it
 101         - Add the k8s cloud to Juju
 102         - Bootstrap
 103         - Record it in the database
 104
 105         3. Connect to the Juju controller for this cloud
 106
 107         """
 108         # cluster_uuid = reuse_cluster_uuid
 109         # if not cluster_uuid:
 110         #     cluster_uuid = str(uuid4())
 111
 112         ##################################################
 113         # TODO: Pull info from db based on the namespace #
 114         ##################################################
 115
 116         if not reuse_cluster_uuid:
 117             # This is a new cluster, so bootstrap it
 118
 119             cluster_uuid = str(uuid.uuid4())
 120
 121             # Add k8s cloud to Juju (unless it's microk8s)
 122
 123             # Does the kubeconfig contain microk8s?
 124             microk8s = self.is_microk8s_by_credentials(k8s_creds)
 125
 126             if not microk8s:
 127                 # Name the new k8s cloud
 128                 k8s_cloud = "{}-k8s".format(namespace)
 129
 130                 await self.add_k8s(k8s_cloud, k8s_creds)
 131
 132                 # Bootstrap Juju controller
 133                 self.bootstrap(k8s_cloud, cluster_uuid)
 134             else:
 135                 # k8s_cloud = 'microk8s-test'
 136                 k8s_cloud = "{}-k8s".format(namespace)
 137
 138                 await self.add_k8s(k8s_cloud, k8s_creds)
 139
 140                 await self.bootstrap(k8s_cloud, cluster_uuid)
 141
 142             # Get the controller information
 143
 144             # Parse ~/.local/share/juju/controllers.yaml
 145             # controllers.testing.api-endpoints|ca-cert|uuid
 146             with open(os.path.expanduser(
 147                 "~/.local/share/juju/controllers.yaml"
 148             )) as f:
 149                 controllers = yaml.load(f, Loader=yaml.Loader)
 150                 controller = controllers['controllers'][cluster_uuid]
 151                 endpoints = controller['api-endpoints']
 152                 self.juju_endpoint = endpoints[0]
 153                 self.juju_ca_cert = controller['ca-cert']
 154
 155             # Parse ~/.local/share/juju/accounts
 156             # controllers.testing.user|password
 157             with open(os.path.expanduser(
 158                 "~/.local/share/juju/accounts.yaml"
 159             )) as f:
 160                 controllers = yaml.load(f, Loader=yaml.Loader)
 161                 controller = controllers['controllers'][cluster_uuid]
 162
 163                 self.juju_user = controller['user']
 164                 self.juju_secret = controller['password']
 165
 166             print("user: {}".format(self.juju_user))
 167             print("secret: {}".format(self.juju_secret))
 168             print("endpoint: {}".format(self.juju_endpoint))
 169             print("ca-cert: {}".format(self.juju_ca_cert))
 170
 171             # raise Exception("EOL")
 172
 173             self.juju_public_key = None
 174
 175             config = {
 176                 'endpoint': self.juju_endpoint,
 177                 'username': self.juju_user,
 178                 'secret': self.juju_secret,
 179                 'cacert': self.juju_ca_cert,
 180                 'namespace': namespace,
 181                 'microk8s': microk8s,
 182             }
 183
 184             # Store the cluster configuration so it
 185             # can be used for subsequent calls
 186             await self.set_config(cluster_uuid, config)
 187
 188         else:
 189             # This is an existing cluster, so get its config
 190             cluster_uuid = reuse_cluster_uuid
 191
 192             config = self.get_config(cluster_uuid)
 193
 194             self.juju_endpoint = config['endpoint']
 195             self.juju_user = config['username']
 196             self.juju_secret = config['secret']
 197             self.juju_ca_cert = config['cacert']
 198             self.juju_public_key = None
 199
 200         # Login to the k8s cluster
 201         if not self.authenticated:
 202             await self.login()
 203
 204         # We're creating a new cluster
 205         print("Getting model {}".format(self.get_namespace(cluster_uuid)))
 206         model = await self.get_model(self.get_namespace(cluster_uuid))
 207
 208         # Disconnect from the model
 209         if model and model.is_connected():
 210             await model.disconnect()
 211
 212         return cluster_uuid
 213
 214     """Repo Management"""
 215     async def repo_add(
 216         self,
 217         name: str,
 218         url: str,
 219         type: str = "charm",
 220     ):
 221         raise NotImplemented()
 222
 223     async def repo_list(self):
 224         raise NotImplemented()
 225
 226     async def repo_remove(
 227         self,
 228         name: str,
 229     ):
 230         raise NotImplemented()
 231
 232     """Reset"""
 233     async def reset(
 234         self,
 235         cluster_uuid: str,
 236     ) -> bool:
 237         """Reset a cluster
 238
 239         Resets the Kubernetes cluster by removing the model that represents it.
 240
 241         :param cluster_uuid str: The UUID of the cluster to reset
 242         :return: Returns True if successful or raises an exception.
 243         """
 244
 245         try:
 246             if not self.authenticated:
 247                 await self.login()
 248
 249             if self.controller.is_connected():
 250                 # Destroy the model
 251                 namespace = self.get_namespace(cluster_uuid)
 252                 if await self.has_model(namespace):
 253                     print("[reset] Destroying model")
 254                     await self.controller.destroy_model(
 255                         namespace,
 256                         destroy_storage=True
 257                     )
 258
 259                 # Disconnect from the controller
 260                 print("[reset] Disconnecting controller")
 261                 await self.controller.disconnect()
 262
 263                 # Destroy the controller (via CLI)
 264                 print("[reset] Destroying controller")
 265                 await self.destroy_controller(cluster_uuid)
 266
 267                 """Remove the k8s cloud
 268
 269                 Only remove the k8s cloud if it's not a microk8s cloud,
 270                 since microk8s is a built-in cloud type.
 271                 """
 272                 # microk8s = self.is_microk8s_by_cluster_uuid(cluster_uuid)
 273                 # if not microk8s:
 274                 print("[reset] Removing k8s cloud")
 275                 namespace = self.get_namespace(cluster_uuid)
 276                 k8s_cloud = "{}-k8s".format(namespace)
 277                 await self.remove_cloud(k8s_cloud)
 278
 279         except Exception as ex:
 280             print("Caught exception during reset: {}".format(ex))
 281
 282     """Deployment"""
 283     async def install(
 284         self,
 285         cluster_uuid: str,
 286         kdu_model: str,
 287         atomic: bool = True,
 288         timeout: int = None,
 289         params: dict = None,
 290     ) -> str:
 291         """Install a bundle
 292
 293         :param cluster_uuid str: The UUID of the cluster to install to
 294         :param kdu_model str: The name or path of a bundle to install
 295         :param atomic bool: If set, waits until the model is active and resets
 296                             the cluster on failure.
 297         :param timeout int: The time, in seconds, to wait for the install
 298                             to finish
 299         :param params dict: Key-value pairs of instantiation parameters
 300
 301         :return: If successful, returns ?
 302         """
 303
 304         if not self.authenticated:
 305             print("[install] Logging in to the controller")
 306             await self.login()
 307
 308         ##
 309         # Get or create the model, based on the namespace the cluster was
 310         # instantiated with.
 311         namespace = self.get_namespace(cluster_uuid)
 312         model = await self.get_model(namespace)
 313         if not model:
 314             # Create the new model
 315             model = await self.add_model(namespace)
 316
 317         if model:
 318             # TODO: Instantiation parameters
 319
 320             print("[install] deploying {}".format(kdu_model))
 321             await model.deploy(kdu_model)
 322
 323             # Get the application
 324             if atomic:
 325                 # applications = model.applications
 326                 print("[install] Applications: {}".format(model.applications))
 327                 for name in model.applications:
 328                     print("[install] Waiting for {} to settle".format(name))
 329                     application = model.applications[name]
 330                     try:
 331                         # It's not enough to wait for all units to be active;
 332                         # the application status needs to be active as well.
 333                         print("Waiting for all units to be active...")
 334                         await model.block_until(
 335                             lambda: all(
 336                                 unit.agent_status == 'idle'
 337                                 and application.status in ['active', 'unknown']
 338                                 and unit.workload_status in [
 339                                     'active', 'unknown'
 340                                 ] for unit in application.units
 341                             ),
 342                             timeout=timeout
 343                         )
 344                         print("All units active.")
 345
 346                     except concurrent.futures._base.TimeoutError:
 347                         print("[install] Timeout exceeded; resetting cluster")
 348                         await self.reset(cluster_uuid)
 349                         return False
 350
 351             # Wait for the application to be active
 352             if model.is_connected():
 353                 print("[install] Disconnecting model")
 354                 await model.disconnect()
 355
 356             return True
 357         raise Exception("Unable to install")
 358
 359     async def instances_list(
 360             self,
 361             cluster_uuid: str
 362     ) -> list:
 363         """
 364         returns a list of deployed releases in a cluster
 365
 366         :param cluster_uuid: the cluster
 367         :return:
 368         """
 369         return []
 370
 371     async def upgrade(
 372         self,
 373         cluster_uuid: str,
 374         kdu_instance: str,
 375         kdu_model: str = None,
 376         params: dict = None,
 377     ) -> str:
 378         """Upgrade a model
 379
 380         :param cluster_uuid str: The UUID of the cluster to upgrade
 381         :param kdu_instance str: The unique name of the KDU instance
 382         :param kdu_model str: The name or path of the bundle to upgrade to
 383         :param params dict: Key-value pairs of instantiation parameters
 384
 385         :return: If successful, reference to the new revision number of the
 386                  KDU instance.
 387         """
 388
 389         # TODO: Loop through the bundle and upgrade each charm individually
 390
 391         """
 392         The API doesn't have a concept of bundle upgrades, because there are
 393         many possible changes: charm revision, disk, number of units, etc.
 394
 395         As such, we are only supporting a limited subset of upgrades. We'll
 396         upgrade the charm revision but leave storage and scale untouched.
 397
 398         Scale changes should happen through OSM constructs, and changes to
 399         storage would require a redeployment of the service, at least in this
 400         initial release.
 401         """
 402         namespace = self.get_namespace(cluster_uuid)
 403         model = await self.get_model(namespace)
 404
 405         with open(kdu_model, 'r') as f:
 406             bundle = yaml.load(f, Loader=yaml.FullLoader)
 407
 408             """
 409             {
 410                 'description': 'Test bundle',
 411                 'bundle': 'kubernetes',
 412                 'applications': {
 413                     'mariadb-k8s': {
 414                         'charm': 'cs:~charmed-osm/mariadb-k8s-20',
 415                         'scale': 1,
 416                         'options': {
 417                             'password': 'manopw',
 418                             'root_password': 'osm4u',
 419                             'user': 'mano'
 420                         },
 421                         'series': 'kubernetes'
 422                     }
 423                 }
 424             }
 425             """
 426             # TODO: This should be returned in an agreed-upon format
 427             for name in bundle['applications']:
 428                 print(model.applications)
 429                 application = model.applications[name]
 430                 print(application)
 431
 432                 path = bundle['applications'][name]['charm']
 433
 434                 try:
 435                     await application.upgrade_charm(switch=path)
 436                 except juju.errors.JujuError as ex:
 437                     if 'already running charm' in str(ex):
 438                         # We're already running this version
 439                         pass
 440
 441         await model.disconnect()
 442
 443         return True
 444         raise NotImplemented()
 445
 446     """Rollback"""
 447     async def rollback(
 448         self,
 449         cluster_uuid: str,
 450         kdu_instance: str,
 451         revision: int = 0,
 452     ) -> str:
 453         """Rollback a model
 454
 455         :param cluster_uuid str: The UUID of the cluster to rollback
 456         :param kdu_instance str: The unique name of the KDU instance
 457         :param revision int: The revision to revert to. If omitted, rolls back
 458                              the previous upgrade.
 459
 460         :return: If successful, returns the revision of active KDU instance,
 461                  or raises an exception
 462         """
 463         raise NotImplemented()
 464
 465     """Deletion"""
 466     async def uninstall(
 467         self,
 468         cluster_uuid: str,
 469         kdu_instance: str,
 470     ) -> bool:
 471         """Uninstall a KDU instance
 472
 473         :param cluster_uuid str: The UUID of the cluster to uninstall
 474         :param kdu_instance str: The unique name of the KDU instance
 475
 476         :return: Returns True if successful, or raises an exception
 477         """
 478         removed = False
 479
 480         # Remove an application from the model
 481         model = await self.get_model(self.get_namespace(cluster_uuid))
 482
 483         if model:
 484             # Get the application
 485             if kdu_instance not in model.applications:
 486                 # TODO: Raise a named exception
 487                 raise Exception("Application not found.")
 488
 489             application = model.applications[kdu_instance]
 490
 491             # Destroy the application
 492             await application.destroy()
 493
 494             # TODO: Verify removal
 495
 496             removed = True
 497         return removed
 498
 499     """Introspection"""
 500     async def inspect_kdu(
 501         self,
 502         kdu_model: str,
 503     ) -> dict:
 504         """Inspect a KDU
 505
 506         Inspects a bundle and returns a dictionary of config parameters and
 507         their default values.
 508
 509         :param kdu_model str: The name or path of the bundle to inspect.
 510
 511         :return: If successful, returns a dictionary of available parameters
 512                  and their default values.
 513         """
 514
 515         kdu = {}
 516         with open(kdu_model, 'r') as f:
 517             bundle = yaml.load(f, Loader=yaml.FullLoader)
 518
 519             """
 520             {
 521                 'description': 'Test bundle',
 522                 'bundle': 'kubernetes',
 523                 'applications': {
 524                     'mariadb-k8s': {
 525                         'charm': 'cs:~charmed-osm/mariadb-k8s-20',
 526                         'scale': 1,
 527                         'options': {
 528                             'password': 'manopw',
 529                             'root_password': 'osm4u',
 530                             'user': 'mano'
 531                         },
 532                         'series': 'kubernetes'
 533                     }
 534                 }
 535             }
 536             """
 537             # TODO: This should be returned in an agreed-upon format
 538             kdu = bundle['applications']
 539
 540         return kdu
 541
 542     async def help_kdu(
 543         self,
 544         kdu_model: str,
 545     ) -> str:
 546         """View the README
 547
 548         If available, returns the README of the bundle.
 549
 550         :param kdu_model str: The name or path of a bundle
 551
 552         :return: If found, returns the contents of the README.
 553         """
 554         readme = None
 555
 556         files = ['README', 'README.txt', 'README.md']
 557         path = os.path.dirname(kdu_model)
 558         for file in os.listdir(path):
 559             if file in files:
 560                 with open(file, 'r') as f:
 561                     readme = f.read()
 562                     break
 563
 564         return readme
 565
 566     async def status_kdu(
 567         self,
 568         cluster_uuid: str,
 569         kdu_instance: str,
 570     ) -> dict:
 571         """Get the status of the KDU
 572
 573         Get the current status of the KDU instance.
 574
 575         :param cluster_uuid str: The UUID of the cluster
 576         :param kdu_instance str: The unique id of the KDU instance
 577
 578         :return: Returns a dictionary containing namespace, state, resources,
 579                  and deployment_time.
 580         """
 581         status = {}
 582
 583         model = await self.get_model(self.get_namespace(cluster_uuid))
 584
 585         # model = await self.get_model_by_uuid(cluster_uuid)
 586         if model:
 587             model_status = await model.get_status()
 588             status = model_status.applications
 589
 590             for name in model_status.applications:
 591                 application = model_status.applications[name]
 592                 status[name] = {
 593                     'status': application['status']['status']
 594                 }
 595
 596             if model.is_connected():
 597                 await model.disconnect()
 598
 599         return status
 600
 601     # Private methods
 602     async def add_k8s(
 603         self,
 604         cloud_name: str,
 605         credentials: dict,
 606     ) -> bool:
 607         """Add a k8s cloud to Juju
 608
 609         Adds a Kubernetes cloud to Juju, so it can be bootstrapped with a
 610         Juju Controller.
 611
 612         :param cloud_name str: The name of the cloud to add.
 613         :param credentials dict: A dictionary representing the output of
 614             `kubectl config view --raw`.
 615
 616         :returns: True if successful, otherwise raises an exception.
 617         """
 618         cmd = [self.k8scli, "add-k8s", "--local", cloud_name]
 619
 620         p = subprocess.run(
 621             cmd,
 622             stdout=subprocess.PIPE,
 623             stderr=subprocess.PIPE,
 624             input=yaml.dump(credentials, Dumper=yaml.Dumper),
 625             encoding='ascii'
 626         )
 627         retcode = p.returncode
 628
 629         if retcode > 0:
 630             raise Exception(p.stderr)
 631         return True
 632
 633     async def add_model(
 634         self,
 635         model_name: str
 636     ) -> juju.model.Model:
 637         """Adds a model to the controller
 638
 639         Adds a new model to the Juju controller
 640
 641         :param model_name str: The name of the model to add.
 642         :returns: The juju.model.Model object of the new model upon success or
 643                   raises an exception.
 644         """
 645         if not self.authenticated:
 646             await self.login()
 647
 648         model = await self.controller.add_model(
 649             model_name,
 650             config={'authorized-keys': self.juju_public_key}
 651         )
 652         return model
 653
 654     async def bootstrap(
 655         self,
 656         cloud_name: str,
 657         cluster_uuid: str
 658     ) -> bool:
 659         """Bootstrap a Kubernetes controller
 660
 661         Bootstrap a Juju controller inside the Kubernetes cluster
 662
 663         :param cloud_name str: The name of the cloud.
 664         :param cluster_uuid str: The UUID of the cluster to bootstrap.
 665         :returns: True upon success or raises an exception.
 666         """
 667         cmd = [self.k8scli, "bootstrap", cloud_name, cluster_uuid]
 668         print("Bootstrapping controller {} in cloud {}".format(
 669             cluster_uuid, cloud_name
 670         ))
 671
 672         p = subprocess.run(
 673             cmd,
 674             stdout=subprocess.PIPE,
 675             stderr=subprocess.PIPE,
 676             encoding='ascii'
 677         )
 678         retcode = p.returncode
 679
 680         if retcode > 0:
 681             #
 682             if 'already exists' not in p.stderr:
 683                 raise Exception(p.stderr)
 684
 685         return True
 686
 687     async def destroy_controller(
 688         self,
 689         cluster_uuid: str
 690     ) -> bool:
 691         """Destroy a Kubernetes controller
 692
 693         Destroy an existing Kubernetes controller.
 694
 695         :param cluster_uuid str: The UUID of the cluster to bootstrap.
 696         :returns: True upon success or raises an exception.
 697         """
 698         cmd = [
 699             self.k8scli,
 700             "destroy-controller",
 701             "--destroy-all-models",
 702             "--destroy-storage",
 703             "-y",
 704             cluster_uuid
 705         ]
 706
 707         p = subprocess.run(
 708             cmd,
 709             stdout=subprocess.PIPE,
 710             stderr=subprocess.PIPE,
 711             encoding='ascii'
 712         )
 713         retcode = p.returncode
 714
 715         if retcode > 0:
 716             #
 717             if 'already exists' not in p.stderr:
 718                 raise Exception(p.stderr)
 719
 720     def get_config(
 721         self,
 722         cluster_uuid: str,
 723     ) -> dict:
 724         """Get the cluster configuration
 725
 726         Gets the configuration of the cluster
 727
 728         :param cluster_uuid str: The UUID of the cluster.
 729         :return: A dict upon success, or raises an exception.
 730         """
 731         cluster_config = "{}/{}.yaml".format(self.fs.path, cluster_uuid)
 732         if os.path.exists(cluster_config):
 733             with open(cluster_config, 'r') as f:
 734                 config = yaml.load(f.read(), Loader=yaml.FullLoader)
 735                 return config
 736         else:
 737             raise Exception(
 738                 "Unable to locate configuration for cluster {}".format(
 739                     cluster_uuid
 740                 )
 741             )
 742
 743     async def get_model(
 744         self,
 745         model_name: str,
 746     ) -> juju.model.Model:
 747         """Get a model from the Juju Controller.
 748
 749         Note: Model objects returned must call disconnected() before it goes
 750         out of scope.
 751
 752         :param model_name str: The name of the model to get
 753         :return The juju.model.Model object if found, or None.
 754         """
 755         if not self.authenticated:
 756             await self.login()
 757
 758         model = None
 759         models = await self.controller.list_models()
 760
 761         if model_name in models:
 762             model = await self.controller.get_model(
 763                 model_name
 764             )
 765         return model
 766
 767     def get_namespace(
 768         self,
 769         cluster_uuid: str,
 770     ) -> str:
 771         """Get the namespace UUID
 772         Gets the namespace's unique name
 773
 774         :param cluster_uuid str: The UUID of the cluster
 775         :returns: The namespace UUID, or raises an exception
 776         """
 777         config = self.get_config(cluster_uuid)
 778
 779         # Make sure the name is in the config
 780         if 'namespace' not in config:
 781             raise Exception("Namespace not found.")
 782
 783         # TODO: We want to make sure this is unique to the cluster, in case
 784         # the cluster is being reused.
 785         # Consider pre/appending the cluster id to the namespace string
 786         return config['namespace']
 787
 788     async def has_model(
 789         self,
 790         model_name: str
 791     ) -> bool:
 792         """Check if a model exists in the controller
 793
 794         Checks to see if a model exists in the connected Juju controller.
 795
 796         :param model_name str: The name of the model
 797         :return: A boolean indicating if the model exists
 798         """
 799         models = await self.controller.list_models()
 800
 801         if model_name in models:
 802             return True
 803         return False
 804
 805     def is_microk8s_by_cluster_uuid(
 806         self,
 807         cluster_uuid: str,
 808     ) -> bool:
 809         """Check if a cluster is micro8s
 810
 811         Checks if a cluster is running microk8s
 812
 813         :param cluster_uuid str: The UUID of the cluster
 814         :returns: A boolean if the cluster is running microk8s
 815         """
 816         config = self.get_config(cluster_uuid)
 817         return config['microk8s']
 818
 819     def is_microk8s_by_credentials(
 820         self,
 821         credentials: dict,
 822     ) -> bool:
 823         """Check if a cluster is micro8s
 824
 825         Checks if a cluster is running microk8s
 826
 827         :param credentials dict: A dictionary containing the k8s credentials
 828         :returns: A boolean if the cluster is running microk8s
 829         """
 830         for context in credentials['contexts']:
 831             if 'microk8s' in context['name']:
 832                 return True
 833
 834         return False
 835
 836     async def login(self):
 837         """Login to the Juju controller."""
 838
 839         if self.authenticated:
 840             return
 841
 842         self.connecting = True
 843
 844         self.controller = Controller()
 845
 846         if self.juju_secret:
 847             self.log.debug(
 848                 "Connecting to controller... ws://{} as {}/{}".format(
 849                     self.juju_endpoint,
 850                     self.juju_user,
 851                     self.juju_secret,
 852                 )
 853             )
 854             try:
 855                 await self.controller.connect(
 856                     endpoint=self.juju_endpoint,
 857                     username=self.juju_user,
 858                     password=self.juju_secret,
 859                     cacert=self.juju_ca_cert,
 860                 )
 861                 self.authenticated = True
 862                 self.log.debug("JujuApi: Logged into controller")
 863             except Exception as ex:
 864                 print(ex)
 865                 self.log.debug("Caught exception: {}".format(ex))
 866                 pass
 867         else:
 868             self.log.fatal("VCA credentials not configured.")
 869             self.authenticated = False
 870
 871     async def logout(self):
 872         """Logout of the Juju controller."""
 873         print("[logout]")
 874         if not self.authenticated:
 875             return False
 876
 877         for model in self.models:
 878             print("Logging out of model {}".format(model))
 879             await self.models[model].disconnect()
 880
 881         if self.controller:
 882             self.log.debug("Disconnecting controller {}".format(
 883                 self.controller
 884             ))
 885             await self.controller.disconnect()
 886             self.controller = None
 887
 888         self.authenticated = False
 889
 890     async def remove_cloud(
 891         self,
 892         cloud_name: str,
 893     ) -> bool:
 894         """Remove a k8s cloud from Juju
 895
 896         Removes a Kubernetes cloud from Juju.
 897
 898         :param cloud_name str: The name of the cloud to add.
 899
 900         :returns: True if successful, otherwise raises an exception.
 901         """
 902
 903         # Remove the bootstrapped controller
 904         cmd = [self.k8scli, "remove-k8s", "--client", cloud_name]
 905         p = subprocess.run(
 906             cmd,
 907             stdout=subprocess.PIPE,
 908             stderr=subprocess.PIPE,
 909             encoding='ascii'
 910         )
 911         retcode = p.returncode
 912
 913         if retcode > 0:
 914             raise Exception(p.stderr)
 915
 916         # Remove the cloud from the local config
 917         cmd = [self.k8scli, "remove-cloud", "--client", cloud_name]
 918         p = subprocess.run(
 919             cmd,
 920             stdout=subprocess.PIPE,
 921             stderr=subprocess.PIPE,
 922             encoding='ascii'
 923         )
 924         retcode = p.returncode
 925
 926         if retcode > 0:
 927             raise Exception(p.stderr)
 928
 929
 930         return True
 931
 932     async def set_config(
 933         self,
 934         cluster_uuid: str,
 935         config: dict,
 936     ) -> bool:
 937         """Save the cluster configuration
 938
 939         Saves the cluster information to the file store
 940
 941         :param cluster_uuid str: The UUID of the cluster
 942         :param config dict: A dictionary containing the cluster configuration
 943         :returns: Boolean upon success or raises an exception.
 944         """
 945
 946         cluster_config = "{}/{}.yaml".format(self.fs.path, cluster_uuid)
 947         if not os.path.exists(cluster_config):
 948             print("Writing config to {}".format(cluster_config))
 949             with open(cluster_config, 'w') as f:
 950                 f.write(yaml.dump(config, Dumper=yaml.Dumper))
 951
 952         return True