n2vc/vnf.py

   1 import asyncio
   2 import logging
   3 import os
   4 import os.path
   5 import re
   6 import ssl
   7 import sys
   8 # import time
   9
  10 # FIXME: this should load the juju inside or modules without having to
  11 # explicitly install it. Check why it's not working.
  12 # Load our subtree of the juju library
  13 path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
  14 path = os.path.join(path, "modules/libjuju/")
  15 if path not in sys.path:
  16     sys.path.insert(1, path)
  17
  18 from juju.controller import Controller
  19 from juju.model import ModelObserver
  20
  21
  22 # We might need this to connect to the websocket securely, but test and verify.
  23 try:
  24     ssl._create_default_https_context = ssl._create_unverified_context
  25 except AttributeError:
  26     # Legacy Python doesn't verify by default (see pep-0476)
  27     #   https://www.python.org/dev/peps/pep-0476/
  28     pass
  29
  30
  31 # Custom exceptions
  32 class JujuCharmNotFound(Exception):
  33     """The Charm can't be found or is not readable."""
  34
  35
  36 class JujuApplicationExists(Exception):
  37     """The Application already exists."""
  38
  39
  40 class N2VCPrimitiveExecutionFailed(Exception):
  41     """Something failed while attempting to execute a primitive."""
  42
  43
  44 # Quiet the debug logging
  45 logging.getLogger('websockets.protocol').setLevel(logging.INFO)
  46 logging.getLogger('juju.client.connection').setLevel(logging.WARN)
  47 logging.getLogger('juju.model').setLevel(logging.WARN)
  48 logging.getLogger('juju.machine').setLevel(logging.WARN)
  49
  50
  51 class VCAMonitor(ModelObserver):
  52     """Monitor state changes within the Juju Model."""
  53     log = None
  54     ns_name = None
  55     applications = {}
  56
  57     def __init__(self, ns_name):
  58         self.log = logging.getLogger(__name__)
  59
  60         self.ns_name = ns_name
  61
  62     def AddApplication(self, application_name, callback, *callback_args):
  63         if application_name not in self.applications:
  64             self.applications[application_name] = {
  65                 'callback': callback,
  66                 'callback_args': callback_args
  67             }
  68
  69     def RemoveApplication(self, application_name):
  70         if application_name in self.applications:
  71             del self.applications[application_name]
  72
  73     async def on_change(self, delta, old, new, model):
  74         """React to changes in the Juju model."""
  75
  76         if delta.entity == "unit":
  77             # Ignore change events from other applications
  78             if delta.data['application'] not in self.applications.keys():
  79                 return
  80
  81             try:
  82
  83                 application_name = delta.data['application']
  84
  85                 callback = self.applications[application_name]['callback']
  86                 callback_args = \
  87                     self.applications[application_name]['callback_args']
  88
  89                 if old and new:
  90                     old_status = old.workload_status
  91                     new_status = new.workload_status
  92
  93                     if old_status == new_status:
  94                         """The workload status may fluctuate around certain
  95                         events, so wait until the status has stabilized before
  96                         triggering the callback."""
  97                         if callback:
  98                             callback(
  99                                 self.ns_name,
 100                                 delta.data['application'],
 101                                 new_status,
 102                                 new.workload_status_message,
 103                                 *callback_args)
 104
 105                 if old and not new:
 106                     # This is a charm being removed
 107                     if callback:
 108                         callback(
 109                             self.ns_name,
 110                             delta.data['application'],
 111                             "removed",
 112                             "",
 113                             *callback_args)
 114             except Exception as e:
 115                 self.log.debug("[1] notify_callback exception: {}".format(e))
 116
 117         elif delta.entity == "action":
 118             # TODO: Decide how we want to notify the user of actions
 119
 120             # uuid = delta.data['id']     # The Action's unique id
 121             # msg = delta.data['message'] # The output of the action
 122             #
 123             # if delta.data['status'] == "pending":
 124             #     # The action is queued
 125             #     pass
 126             # elif delta.data['status'] == "completed""
 127             #     # The action was successful
 128             #     pass
 129             # elif delta.data['status'] == "failed":
 130             #     # The action failed.
 131             #     pass
 132
 133             pass
 134
 135 ########
 136 # TODO
 137 #
 138 # Create unique models per network service
 139 # Document all public functions
 140
 141
 142 class N2VC:
 143     def __init__(self,
 144                  log=None,
 145                  server='127.0.0.1',
 146                  port=17070,
 147                  user='admin',
 148                  secret=None,
 149                  artifacts=None,
 150                  loop=None,
 151                  ):
 152         """Initialize N2VC
 153
 154         :param vcaconfig dict A dictionary containing the VCA configuration
 155
 156         :param artifacts str The directory where charms required by a vnfd are
 157             stored.
 158
 159         :Example:
 160         n2vc = N2VC(vcaconfig={
 161             'secret': 'MzI3MDJhOTYxYmM0YzRjNTJiYmY1Yzdm',
 162             'user': 'admin',
 163             'ip-address': '10.44.127.137',
 164             'port': 17070,
 165             'artifacts': '/path/to/charms'
 166         })
 167         """
 168
 169         # Initialize instance-level variables
 170         self.api = None
 171         self.log = None
 172         self.controller = None
 173         self.connecting = False
 174         self.authenticated = False
 175
 176         self.models = {}
 177         self.default_model = None
 178
 179         # Model Observers
 180         self.monitors = {}
 181
 182         # VCA config
 183         self.hostname = ""
 184         self.port = 17070
 185         self.username = ""
 186         self.secret = ""
 187
 188         if log:
 189             self.log = log
 190         else:
 191             self.log = logging.getLogger(__name__)
 192
 193         # Quiet websocket traffic
 194         logging.getLogger('websockets.protocol').setLevel(logging.INFO)
 195         logging.getLogger('juju.client.connection').setLevel(logging.WARN)
 196         logging.getLogger('model').setLevel(logging.WARN)
 197         # logging.getLogger('websockets.protocol').setLevel(logging.DEBUG)
 198
 199         self.log.debug('JujuApi: instantiated')
 200
 201         self.server = server
 202         self.port = port
 203
 204         self.secret = secret
 205         if user.startswith('user-'):
 206             self.user = user
 207         else:
 208             self.user = 'user-{}'.format(user)
 209
 210         self.endpoint = '%s:%d' % (server, int(port))
 211
 212         self.artifacts = artifacts
 213
 214         self.loop = loop or asyncio.get_event_loop()
 215
 216     def __del__(self):
 217         """Close any open connections."""
 218         yield self.logout()
 219
 220     def notify_callback(self, model_name, application_name, status, message,
 221                         callback=None, *callback_args):
 222         try:
 223             if callback:
 224                 callback(
 225                     model_name,
 226                     application_name,
 227                     status, message,
 228                     *callback_args,
 229                 )
 230         except Exception as e:
 231             self.log.error("[0] notify_callback exception {}".format(e))
 232             raise e
 233         return True
 234
 235     # Public methods
 236     async def CreateNetworkService(self, nsd):
 237         """Create a new model to encapsulate this network service.
 238
 239         Create a new model in the Juju controller to encapsulate the
 240         charms associated with a network service.
 241
 242         You can pass either the nsd record or the id of the network
 243         service, but this method will fail without one of them.
 244         """
 245         if not self.authenticated:
 246             await self.login()
 247
 248         # Ideally, we will create a unique model per network service.
 249         # This change will require all components, i.e., LCM and SO, to use
 250         # N2VC for 100% compatibility. If we adopt unique models for the LCM,
 251         # services deployed via LCM would't be manageable via SO and vice versa
 252
 253         return self.default_model
 254
 255     async def DeployCharms(self, model_name, application_name, vnfd,
 256                            charm_path, params={}, machine_spec={},
 257                            callback=None, *callback_args):
 258         """Deploy one or more charms associated with a VNF.
 259
 260         Deploy the charm(s) referenced in a VNF Descriptor.
 261
 262         :param str model_name: The name of the network service.
 263         :param str application_name: The name of the application
 264         :param dict vnfd: The name of the application
 265         :param str charm_path: The path to the Juju charm
 266         :param dict params: A dictionary of runtime parameters
 267           Examples::
 268           {
 269             'rw_mgmt_ip': '1.2.3.4',
 270             # Pass the initial-config-primitives section of the vnf or vdu
 271             'initial-config-primitives': {...}
 272           }
 273         :param dict machine_spec: A dictionary describing the machine to
 274         install to
 275           Examples::
 276           {
 277             'hostname': '1.2.3.4',
 278             'username': 'ubuntu',
 279           }
 280         :param obj callback: A callback function to receive status changes.
 281         :param tuple callback_args: A list of arguments to be passed to the
 282         callback
 283         """
 284
 285         ########################################################
 286         # Verify the path to the charm exists and is readable. #
 287         ########################################################
 288         if not os.path.exists(charm_path):
 289             self.log.debug("Charm path doesn't exist: {}".format(charm_path))
 290             self.notify_callback(
 291                 model_name,
 292                 application_name,
 293                 "failed",
 294                 callback,
 295                 *callback_args,
 296             )
 297             raise JujuCharmNotFound("No artifacts configured.")
 298
 299         ################################
 300         # Login to the Juju controller #
 301         ################################
 302         if not self.authenticated:
 303             self.log.debug("Authenticating with Juju")
 304             await self.login()
 305
 306         ##########################################
 307         # Get the model for this network service #
 308         ##########################################
 309         # TODO: In a point release, we will use a model per deployed network
 310         # service. In the meantime, we will always use the 'default' model.
 311         model_name = 'default'
 312         model = await self.get_model(model_name)
 313
 314         ########################################
 315         # Verify the application doesn't exist #
 316         ########################################
 317         app = await self.get_application(model, application_name)
 318         if app:
 319             raise JujuApplicationExists("Can't deploy application \"{}\" to model \"{}\" because it already exists.".format(application_name, model_name))
 320
 321         ################################################################
 322         # Register this application with the model-level event monitor #
 323         ################################################################
 324         if callback:
 325             self.monitors[model_name].AddApplication(
 326                 application_name,
 327                 callback,
 328                 *callback_args
 329             )
 330
 331         ########################################################
 332         # Check for specific machine placement (native charms) #
 333         ########################################################
 334         to = ""
 335         if machine_spec.keys():
 336             # TODO: This needs to be tested.
 337             # if all(k in machine_spec for k in ['hostname', 'username']):
 338             #     # Enlist the existing machine in Juju
 339             #     machine = await self.model.add_machine(spec='ssh:%@%'.format(
 340             #         specs['host'],
 341             #         specs['user'],
 342             #     ))
 343             #     to = machine.id
 344             pass
 345
 346         #######################################
 347         # Get the initial charm configuration #
 348         #######################################
 349
 350         rw_mgmt_ip = None
 351         if 'rw_mgmt_ip' in params:
 352             rw_mgmt_ip = params['rw_mgmt_ip']
 353
 354         # initial_config = {}
 355         # self.log.debug(type(params))
 356         # self.log.debug("Params: {}".format(params))
 357         if 'initial-config-primitive' not in params:
 358             params['initial-config-primitive'] = {}
 359
 360         initial_config = self._get_config_from_dict(
 361             params['initial-config-primitive'],
 362             {'<rw_mgmt_ip>': rw_mgmt_ip}
 363         )
 364
 365         self.log.debug("JujuApi: Deploying charm ({}) from {}".format(
 366             application_name,
 367             charm_path,
 368             to=to,
 369         ))
 370
 371         ########################################################
 372         # Deploy the charm and apply the initial configuration #
 373         ########################################################
 374         app = await model.deploy(
 375             # We expect charm_path to be either the path to the charm on disk
 376             # or in the format of cs:series/name
 377             charm_path,
 378             # This is the formatted, unique name for this charm
 379             application_name=application_name,
 380             # Proxy charms should use the current LTS. This will need to be
 381             # changed for native charms.
 382             series='xenial',
 383             # Apply the initial 'config' primitive during deployment
 384             config=initial_config,
 385             # TBD: Where to deploy the charm to.
 386             to=None,
 387         )
 388
 389         # #######################################
 390         # # Execute initial config primitive(s) #
 391         # #######################################
 392         await self.ExecuteInitialPrimitives(
 393             model_name,
 394             application_name,
 395             params,
 396         )
 397
 398         # primitives = {}
 399         #
 400         # # Build a sequential list of the primitives to execute
 401         # for primitive in params['initial-config-primitive']:
 402         #     try:
 403         #         if primitive['name'] == 'config':
 404         #             # This is applied when the Application is deployed
 405         #             pass
 406         #         else:
 407         #             seq = primitive['seq']
 408         #
 409         #             params = {}
 410         #             if 'parameter' in primitive:
 411         #                 params = primitive['parameter']
 412         #
 413         #             primitives[seq] = {
 414         #                 'name': primitive['name'],
 415         #                 'parameters': self._map_primitive_parameters(
 416         #                     params,
 417         #                     {'<rw_mgmt_ip>': rw_mgmt_ip}
 418         #                 ),
 419         #             }
 420         #
 421         #             for primitive in sorted(primitives):
 422         #                 await self.ExecutePrimitive(
 423         #                     model_name,
 424         #                     application_name,
 425         #                     primitives[primitive]['name'],
 426         #                     callback,
 427         #                     callback_args,
 428         #                     **primitives[primitive]['parameters'],
 429         #                 )
 430         #     except N2VCPrimitiveExecutionFailed as e:
 431         #         self.log.debug(
 432         #             "[N2VC] Exception executing primitive: {}".format(e)
 433         #         )
 434         #         raise
 435
 436     async def GetPrimitiveStatus(self, model_name, uuid):
 437         """Get the status of an executed Primitive.
 438
 439         The status of an executed Primitive will be one of three values:
 440         - completed
 441         - failed
 442         - running
 443         """
 444         status = None
 445         try:
 446             if not self.authenticated:
 447                 await self.login()
 448
 449             # FIXME: This is hard-coded until model-per-ns is added
 450             model_name = 'default'
 451
 452             model = await self.get_model(model_name)
 453
 454             results = await model.get_action_status(uuid)
 455
 456             if uuid in results:
 457                 status = results[uuid]
 458
 459         except Exception as e:
 460             self.log.debug(
 461                 "Caught exception while getting primitive status: {}".format(e)
 462             )
 463             raise N2VCPrimitiveExecutionFailed(e)
 464
 465         return status
 466
 467     async def GetPrimitiveOutput(self, model_name, uuid):
 468         """Get the output of an executed Primitive.
 469
 470         Note: this only returns output for a successfully executed primitive.
 471         """
 472         results = None
 473         try:
 474             if not self.authenticated:
 475                 await self.login()
 476
 477             # FIXME: This is hard-coded until model-per-ns is added
 478             model_name = 'default'
 479
 480             model = await self.get_model(model_name)
 481             results = await model.get_action_output(uuid, 60)
 482         except Exception as e:
 483             self.log.debug(
 484                 "Caught exception while getting primitive status: {}".format(e)
 485             )
 486             raise N2VCPrimitiveExecutionFailed(e)
 487
 488         return results
 489
 490     async def ExecuteInitialPrimitives(self, model_name, application_name,
 491                                        params, callback=None, *callback_args):
 492         """Execute multiple primitives.
 493
 494         Execute multiple primitives as declared in initial-config-primitive.
 495         This is useful in cases where the primitives initially failed -- for
 496         example, if the charm is a proxy but the proxy hasn't been configured
 497         yet.
 498         """
 499         uuids = []
 500         primitives = {}
 501
 502         # Build a sequential list of the primitives to execute
 503         for primitive in params['initial-config-primitive']:
 504             try:
 505                 if primitive['name'] == 'config':
 506                     pass
 507                 else:
 508                     seq = primitive['seq']
 509
 510                     params = {}
 511                     if 'parameter' in primitive:
 512                         params = primitive['parameter']
 513
 514                     primitives[seq] = {
 515                         'name': primitive['name'],
 516                         'parameters': self._map_primitive_parameters(
 517                             params,
 518                             {'<rw_mgmt_ip>': None}
 519                         ),
 520                     }
 521
 522                     for primitive in sorted(primitives):
 523                         uuids.append(
 524                             await self.ExecutePrimitive(
 525                                 model_name,
 526                                 application_name,
 527                                 primitives[primitive]['name'],
 528                                 callback,
 529                                 callback_args,
 530                                 **primitives[primitive]['parameters'],
 531                             )
 532                         )
 533             except N2VCPrimitiveExecutionFailed as e:
 534                 self.log.debug(
 535                     "[N2VC] Exception executing primitive: {}".format(e)
 536                 )
 537                 raise
 538         return uuids
 539
 540     async def ExecutePrimitive(self, model_name, application_name, primitive,
 541                                callback, *callback_args, **params):
 542         """Execute a primitive of a charm for Day 1 or Day 2 configuration.
 543
 544         Execute a primitive defined in the VNF descriptor.
 545
 546         :param str model_name: The name of the network service.
 547         :param str application_name: The name of the application
 548         :param str primitive: The name of the primitive to execute.
 549         :param obj callback: A callback function to receive status changes.
 550         :param tuple callback_args: A list of arguments to be passed to the
 551          callback function.
 552         :param dict params: A dictionary of key=value pairs representing the
 553          primitive's parameters
 554           Examples::
 555           {
 556             'rw_mgmt_ip': '1.2.3.4',
 557             # Pass the initial-config-primitives section of the vnf or vdu
 558             'initial-config-primitives': {...}
 559           }
 560         """
 561         self.log.debug("Executing {}".format(primitive))
 562         uuid = None
 563         try:
 564             if not self.authenticated:
 565                 await self.login()
 566
 567             # FIXME: This is hard-coded until model-per-ns is added
 568             model_name = 'default'
 569
 570             model = await self.get_model(model_name)
 571
 572             if primitive == 'config':
 573                 # config is special, and expecting params to be a dictionary
 574                 await self.set_config(
 575                     model,
 576                     application_name,
 577                     params['params'],
 578                 )
 579             else:
 580                 app = await self.get_application(model, application_name)
 581                 if app:
 582                     # Run against the first (and probably only) unit in the app
 583                     unit = app.units[0]
 584                     if unit:
 585                         action = await unit.run_action(primitive, **params)
 586                         uuid = action.id
 587         except Exception as e:
 588             self.log.debug(
 589                 "Caught exception while executing primitive: {}".format(e)
 590             )
 591             raise N2VCPrimitiveExecutionFailed(e)
 592         return uuid
 593
 594     async def RemoveCharms(self, model_name, application_name, callback=None,
 595                            *callback_args):
 596         """Remove a charm from the VCA.
 597
 598         Remove a charm referenced in a VNF Descriptor.
 599
 600         :param str model_name: The name of the network service.
 601         :param str application_name: The name of the application
 602         :param obj callback: A callback function to receive status changes.
 603         :param tuple callback_args: A list of arguments to be passed to the
 604          callback function.
 605         """
 606         try:
 607             if not self.authenticated:
 608                 await self.login()
 609
 610             model = await self.get_model(model_name)
 611             app = await self.get_application(model, application_name)
 612             if app:
 613                 # Remove this application from event monitoring
 614                 self.monitors[model_name].RemoveApplication(application_name)
 615
 616                 # self.notify_callback(model_name, application_name, "removing", callback, *callback_args)
 617                 self.log.debug(
 618                     "Removing the application {}".format(application_name)
 619                 )
 620                 await app.remove()
 621
 622                 # Notify the callback that this charm has been removed.
 623                 self.notify_callback(
 624                     model_name,
 625                     application_name,
 626                     "removed",
 627                     callback,
 628                     *callback_args,
 629                 )
 630
 631         except Exception as e:
 632             print("Caught exception: {}".format(e))
 633             self.log.debug(e)
 634             raise e
 635
 636     async def DestroyNetworkService(self, nsd):
 637         raise NotImplementedError()
 638
 639     async def GetMetrics(self, model_name, application_name):
 640         """Get the metrics collected by the VCA.
 641
 642         :param model_name The name of the model
 643         :param application_name The name of the application
 644         """
 645         metrics = {}
 646         model = await self.get_model(model_name)
 647         app = await self.get_application(model, application_name)
 648         if app:
 649             metrics = await app.get_metrics()
 650
 651         return metrics
 652
 653     # Non-public methods
 654     async def add_relation(self, a, b, via=None):
 655         """
 656         Add a relation between two application endpoints.
 657
 658         :param a An application endpoint
 659         :param b An application endpoint
 660         :param via The egress subnet(s) for outbound traffic, e.g.,
 661             (192.168.0.0/16,10.0.0.0/8)
 662         """
 663         if not self.authenticated:
 664             await self.login()
 665
 666         m = await self.get_model()
 667         try:
 668             m.add_relation(a, b, via)
 669         finally:
 670             await m.disconnect()
 671
 672     # async def apply_config(self, config, application):
 673     #     """Apply a configuration to the application."""
 674     #     print("JujuApi: Applying configuration to {}.".format(
 675     #         application
 676     #     ))
 677     #     return await self.set_config(application=application, config=config)
 678
 679     def _get_config_from_dict(self, config_primitive, values):
 680         """Transform the yang config primitive to dict.
 681
 682         Expected result:
 683
 684             config = {
 685                 'config':
 686             }
 687         """
 688         config = {}
 689         for primitive in config_primitive:
 690             if primitive['name'] == 'config':
 691                 # config = self._map_primitive_parameters()
 692                 for parameter in primitive['parameter']:
 693                     param = str(parameter['name'])
 694                     if parameter['value'] == "<rw_mgmt_ip>":
 695                         config[param] = str(values[parameter['value']])
 696                     else:
 697                         config[param] = str(parameter['value'])
 698
 699         return config
 700
 701     def _map_primitive_parameters(self, parameters, values):
 702         params = {}
 703         for parameter in parameters:
 704             param = str(parameter['name'])
 705
 706             # Typecast parameter value, if present
 707             if 'data-type' in parameter:
 708                 paramtype = str(parameter['data-type']).lower()
 709                 value = None
 710
 711                 if paramtype == "integer":
 712                     value = int(parameter['value'])
 713                 elif paramtype == "boolean":
 714                     value = bool(parameter['value'])
 715                 else:
 716                     value = str(parameter['value'])
 717
 718             if parameter['value'] == "<rw_mgmt_ip>":
 719                 params[param] = str(values[parameter['value']])
 720             else:
 721                 params[param] = value
 722         return params
 723
 724     def _get_config_from_yang(self, config_primitive, values):
 725         """Transform the yang config primitive to dict."""
 726         config = {}
 727         for primitive in config_primitive.values():
 728             if primitive['name'] == 'config':
 729                 for parameter in primitive['parameter'].values():
 730                     param = str(parameter['name'])
 731                     if parameter['value'] == "<rw_mgmt_ip>":
 732                         config[param] = str(values[parameter['value']])
 733                     else:
 734                         config[param] = str(parameter['value'])
 735
 736         return config
 737
 738     @staticmethod
 739     def FormatApplicationName(self, *args):
 740         """
 741         Generate a Juju-compatible Application name
 742
 743         :param args tuple: Positional arguments to be used to construct the
 744         application name.
 745
 746         Limitations::
 747         - Only accepts characters a-z and non-consequitive dashes (-)
 748         - Application name should not exceed 50 characters
 749
 750         Examples::
 751
 752             FormatApplicationName("ping_pong_ns", "ping_vnf", "a")
 753         """
 754
 755         appname = ""
 756         for c in "-".join(list(args)):
 757             if c.isdigit():
 758                 c = chr(97 + int(c))
 759             elif not c.isalpha():
 760                 c = "-"
 761             appname += c
 762         return re.sub('\-+', '-', appname.lower())
 763
 764     # def format_application_name(self, nsd_name, vnfr_name, member_vnf_index=0):
 765     #     """Format the name of the application
 766     #
 767     #     Limitations:
 768     #     - Only accepts characters a-z and non-consequitive dashes (-)
 769     #     - Application name should not exceed 50 characters
 770     #     """
 771     #     name = "{}-{}-{}".format(nsd_name, vnfr_name, member_vnf_index)
 772     #     new_name = ''
 773     #     for c in name:
 774     #         if c.isdigit():
 775     #             c = chr(97 + int(c))
 776     #         elif not c.isalpha():
 777     #             c = "-"
 778     #         new_name += c
 779     #     return re.sub('\-+', '-', new_name.lower())
 780
 781     def format_model_name(self, name):
 782         """Format the name of model.
 783
 784         Model names may only contain lowercase letters, digits and hyphens
 785         """
 786
 787         return name.replace('_', '-').lower()
 788
 789     async def get_application(self, model, application):
 790         """Get the deployed application."""
 791         if not self.authenticated:
 792             await self.login()
 793
 794         app = None
 795         if application and model:
 796             if model.applications:
 797                 if application in model.applications:
 798                     app = model.applications[application]
 799
 800         return app
 801
 802     async def get_model(self, model_name='default'):
 803         """Get a model from the Juju Controller.
 804
 805         Note: Model objects returned must call disconnected() before it goes
 806         out of scope."""
 807         if not self.authenticated:
 808             await self.login()
 809
 810         if model_name not in self.models:
 811             self.models[model_name] = await self.controller.get_model(
 812                 model_name,
 813             )
 814
 815             # Create an observer for this model
 816             self.monitors[model_name] = VCAMonitor(model_name)
 817             self.models[model_name].add_observer(self.monitors[model_name])
 818
 819         return self.models[model_name]
 820
 821     async def login(self):
 822         """Login to the Juju controller."""
 823
 824         if self.authenticated:
 825             return
 826
 827         self.connecting = True
 828
 829         self.log.debug("JujuApi: Logging into controller")
 830
 831         cacert = None
 832         self.controller = Controller(loop=self.loop)
 833
 834         if self.secret:
 835             self.log.debug(
 836                 "Connecting to controller... ws://{}:{} as {}/{}".format(
 837                     self.endpoint,
 838                     self.port,
 839                     self.user,
 840                     self.secret,
 841                 )
 842             )
 843             await self.controller.connect(
 844                 endpoint=self.endpoint,
 845                 username=self.user,
 846                 password=self.secret,
 847                 cacert=cacert,
 848             )
 849         else:
 850             # current_controller no longer exists
 851             # self.log.debug("Connecting to current controller...")
 852             # await self.controller.connect_current()
 853             # await self.controller.connect(
 854             #     endpoint=self.endpoint,
 855             #     username=self.user,
 856             #     cacert=cacert,
 857             # )
 858             self.log.fatal("VCA credentials not configured.")
 859
 860         self.authenticated = True
 861         self.log.debug("JujuApi: Logged into controller")
 862
 863         # self.default_model = await self.controller.get_model("default")
 864
 865     async def logout(self):
 866         """Logout of the Juju controller."""
 867         if not self.authenticated:
 868             return
 869
 870         try:
 871             if self.default_model:
 872                 self.log.debug("Disconnecting model {}".format(
 873                     self.default_model
 874                 ))
 875                 await self.default_model.disconnect()
 876                 self.default_model = None
 877
 878             for model in self.models:
 879                 await self.models[model].disconnect()
 880                 model = None
 881
 882             if self.controller:
 883                 self.log.debug("Disconnecting controller {}".format(
 884                     self.controller
 885                 ))
 886                 await self.controller.disconnect()
 887                 self.controller = None
 888
 889             self.authenticated = False
 890         except Exception as e:
 891             self.log.fatal(
 892                 "Fatal error logging out of Juju Controller: {}".format(e)
 893             )
 894             raise e
 895
 896     # async def remove_application(self, name):
 897     #     """Remove the application."""
 898     #     if not self.authenticated:
 899     #         await self.login()
 900     #
 901     #     app = await self.get_application(name)
 902     #     if app:
 903     #         self.log.debug("JujuApi: Destroying application {}".format(
 904     #             name,
 905     #         ))
 906     #
 907     #         await app.destroy()
 908
 909     async def remove_relation(self, a, b):
 910         """
 911         Remove a relation between two application endpoints
 912
 913         :param a An application endpoint
 914         :param b An application endpoint
 915         """
 916         if not self.authenticated:
 917             await self.login()
 918
 919         m = await self.get_model()
 920         try:
 921             m.remove_relation(a, b)
 922         finally:
 923             await m.disconnect()
 924
 925     async def resolve_error(self, application=None):
 926         """Resolve units in error state."""
 927         if not self.authenticated:
 928             await self.login()
 929
 930         app = await self.get_application(self.default_model, application)
 931         if app:
 932             self.log.debug(
 933                 "JujuApi: Resolving errors for application {}".format(
 934                     application,
 935                 )
 936             )
 937
 938             for unit in app.units:
 939                 app.resolved(retry=True)
 940
 941     async def run_action(self, application, action_name, **params):
 942         """Execute an action and return an Action object."""
 943         if not self.authenticated:
 944             await self.login()
 945         result = {
 946             'status': '',
 947             'action': {
 948                 'tag': None,
 949                 'results': None,
 950             }
 951         }
 952         app = await self.get_application(self.default_model, application)
 953         if app:
 954             # We currently only have one unit per application
 955             # so use the first unit available.
 956             unit = app.units[0]
 957
 958             self.log.debug(
 959                 "JujuApi: Running Action {} against Application {}".format(
 960                     action_name,
 961                     application,
 962                 )
 963             )
 964
 965             action = await unit.run_action(action_name, **params)
 966
 967             # Wait for the action to complete
 968             await action.wait()
 969
 970             result['status'] = action.status
 971             result['action']['tag'] = action.data['id']
 972             result['action']['results'] = action.results
 973
 974         return result
 975
 976     async def set_config(self, model_name, application, config):
 977         """Apply a configuration to the application."""
 978         if not self.authenticated:
 979             await self.login()
 980
 981         app = await self.get_application(model_name, application)
 982         if app:
 983             self.log.debug("JujuApi: Setting config for Application {}".format(
 984                 application,
 985             ))
 986             await app.set_config(config)
 987
 988             # Verify the config is set
 989             newconf = await app.get_config()
 990             for key in config:
 991                 if config[key] != newconf[key]['value']:
 992                     self.log.debug("JujuApi: Config not set! Key {} Value {} doesn't match {}".format(key, config[key], newconf[key]))
 993
 994     # async def set_parameter(self, parameter, value, application=None):
 995     #     """Set a config parameter for a service."""
 996     #     if not self.authenticated:
 997     #         await self.login()
 998     #
 999     #     self.log.debug("JujuApi: Setting {}={} for Application {}".format(
1000     #         parameter,
1001     #         value,
1002     #         application,
1003     #     ))
1004     #     return await self.apply_config(
1005     #         {parameter: value},
1006     #         application=application,
1007         # )
1008
1009     async def wait_for_application(self, model_name, application_name,
1010                                    timeout=300):
1011         """Wait for an application to become active."""
1012         if not self.authenticated:
1013             await self.login()
1014
1015         # TODO: In a point release, we will use a model per deployed network
1016         # service. In the meantime, we will always use the 'default' model.
1017         model_name = 'default'
1018         model = await self.get_model(model_name)
1019
1020         app = await self.get_application(model, application_name)
1021         self.log.debug("Application: {}".format(app))
1022         # app = await self.get_application(model_name, application_name)
1023         if app:
1024             self.log.debug(
1025                 "JujuApi: Waiting {} seconds for Application {}".format(
1026                     timeout,
1027                     application_name,
1028                 )
1029             )
1030
1031             await model.block_until(
1032                 lambda: all(
1033                     unit.agent_status == 'idle' and unit.workload_status in
1034                     ['active', 'unknown'] for unit in app.units
1035                 ),
1036                 timeout=timeout
1037             )