n2vc/vnf.py

   1 import asyncio
   2 import logging
   3 import os
   4 import os.path
   5 import re
   6 import shlex
   7 import ssl
   8 import subprocess
   9 import sys
  10 # import time
  11
  12 # FIXME: this should load the juju inside or modules without having to
  13 # explicitly install it. Check why it's not working.
  14 # Load our subtree of the juju library
  15 path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
  16 path = os.path.join(path, "modules/libjuju/")
  17 if path not in sys.path:
  18     sys.path.insert(1, path)
  19
  20 from juju.controller import Controller
  21 from juju.model import ModelObserver
  22 from juju.errors import JujuAPIError, JujuError
  23
  24 # We might need this to connect to the websocket securely, but test and verify.
  25 try:
  26     ssl._create_default_https_context = ssl._create_unverified_context
  27 except AttributeError:
  28     # Legacy Python doesn't verify by default (see pep-0476)
  29     #   https://www.python.org/dev/peps/pep-0476/
  30     pass
  31
  32
  33 # Custom exceptions
  34 class JujuCharmNotFound(Exception):
  35     """The Charm can't be found or is not readable."""
  36
  37
  38 class JujuApplicationExists(Exception):
  39     """The Application already exists."""
  40
  41
  42 class N2VCPrimitiveExecutionFailed(Exception):
  43     """Something failed while attempting to execute a primitive."""
  44
  45
  46 class NetworkServiceDoesNotExist(Exception):
  47     """The Network Service being acted against does not exist."""
  48
  49
  50 # Quiet the debug logging
  51 logging.getLogger('websockets.protocol').setLevel(logging.INFO)
  52 logging.getLogger('juju.client.connection').setLevel(logging.WARN)
  53 logging.getLogger('juju.model').setLevel(logging.WARN)
  54 logging.getLogger('juju.machine').setLevel(logging.WARN)
  55
  56
  57 class VCAMonitor(ModelObserver):
  58     """Monitor state changes within the Juju Model."""
  59     log = None
  60
  61     def __init__(self, ns_name):
  62         self.log = logging.getLogger(__name__)
  63
  64         self.ns_name = ns_name
  65         self.applications = {}
  66
  67     def AddApplication(self, application_name, callback, *callback_args):
  68         if application_name not in self.applications:
  69             self.applications[application_name] = {
  70                 'callback': callback,
  71                 'callback_args': callback_args
  72             }
  73
  74     def RemoveApplication(self, application_name):
  75         if application_name in self.applications:
  76             del self.applications[application_name]
  77
  78     async def on_change(self, delta, old, new, model):
  79         """React to changes in the Juju model."""
  80
  81         if delta.entity == "unit":
  82             # Ignore change events from other applications
  83             if delta.data['application'] not in self.applications.keys():
  84                 return
  85
  86             try:
  87
  88                 application_name = delta.data['application']
  89
  90                 callback = self.applications[application_name]['callback']
  91                 callback_args = \
  92                     self.applications[application_name]['callback_args']
  93
  94                 if old and new:
  95                     # Fire off a callback with the application state
  96                     if callback:
  97                         callback(
  98                             self.ns_name,
  99                             delta.data['application'],
 100                             new.workload_status,
 101                             new.workload_status_message,
 102                             *callback_args)
 103
 104                 if old and not new:
 105                     # This is a charm being removed
 106                     if callback:
 107                         callback(
 108                             self.ns_name,
 109                             delta.data['application'],
 110                             "removed",
 111                             "",
 112                             *callback_args)
 113             except Exception as e:
 114                 self.log.debug("[1] notify_callback exception: {}".format(e))
 115
 116         elif delta.entity == "action":
 117             # TODO: Decide how we want to notify the user of actions
 118
 119             # uuid = delta.data['id']     # The Action's unique id
 120             # msg = delta.data['message'] # The output of the action
 121             #
 122             # if delta.data['status'] == "pending":
 123             #     # The action is queued
 124             #     pass
 125             # elif delta.data['status'] == "completed""
 126             #     # The action was successful
 127             #     pass
 128             # elif delta.data['status'] == "failed":
 129             #     # The action failed.
 130             #     pass
 131
 132             pass
 133
 134 ########
 135 # TODO
 136 #
 137 # Create unique models per network service
 138 # Document all public functions
 139
 140
 141 class N2VC:
 142     def __init__(self,
 143                  log=None,
 144                  server='127.0.0.1',
 145                  port=17070,
 146                  user='admin',
 147                  secret=None,
 148                  artifacts=None,
 149                  loop=None,
 150                  juju_public_key=None,
 151                  ca_cert=None,
 152                  ):
 153         """Initialize N2VC
 154         :param log obj: The logging object to log to
 155         :param server str: The IP Address or Hostname of the Juju controller
 156         :param port int: The port of the Juju Controller
 157         :param user str: The Juju username to authenticate with
 158         :param secret str: The Juju password to authenticate with
 159         :param artifacts str: The directory where charms required by a vnfd are
 160             stored.
 161         :param loop obj: The loop to use.
 162         :param juju_public_key str: The contents of the Juju public SSH key
 163         :param ca_cert str: The CA certificate to use to authenticate
 164
 165
 166         :Example:
 167         client = n2vc.vnf.N2VC(
 168             log=log,
 169             server='10.1.1.28',
 170             port=17070,
 171             user='admin',
 172             secret='admin',
 173             artifacts='/app/storage/myvnf/charms',
 174             loop=loop,
 175             juju_public_key='<contents of the juju public key>',
 176             ca_cert='<contents of CA certificate>',
 177         )
 178         """
 179
 180         # Initialize instance-level variables
 181         self.api = None
 182         self.log = None
 183         self.controller = None
 184         self.connecting = False
 185         self.authenticated = False
 186
 187         # For debugging
 188         self.refcount = {
 189             'controller': 0,
 190             'model': 0,
 191         }
 192
 193         self.models = {}
 194
 195         # Model Observers
 196         self.monitors = {}
 197
 198         # VCA config
 199         self.hostname = ""
 200         self.port = 17070
 201         self.username = ""
 202         self.secret = ""
 203
 204         self.juju_public_key = juju_public_key
 205         if juju_public_key:
 206             self._create_juju_public_key(juju_public_key)
 207
 208         self.ca_cert = ca_cert
 209
 210         if log:
 211             self.log = log
 212         else:
 213             self.log = logging.getLogger(__name__)
 214
 215         # Quiet websocket traffic
 216         logging.getLogger('websockets.protocol').setLevel(logging.INFO)
 217         logging.getLogger('juju.client.connection').setLevel(logging.WARN)
 218         logging.getLogger('model').setLevel(logging.WARN)
 219         # logging.getLogger('websockets.protocol').setLevel(logging.DEBUG)
 220
 221         self.log.debug('JujuApi: instantiated')
 222
 223         self.server = server
 224         self.port = port
 225
 226         self.secret = secret
 227         if user.startswith('user-'):
 228             self.user = user
 229         else:
 230             self.user = 'user-{}'.format(user)
 231
 232         self.endpoint = '%s:%d' % (server, int(port))
 233
 234         self.artifacts = artifacts
 235
 236         self.loop = loop or asyncio.get_event_loop()
 237
 238     def __del__(self):
 239         """Close any open connections."""
 240         yield self.logout()
 241
 242     def _create_juju_public_key(self, public_key):
 243         """Recreate the Juju public key on disk.
 244
 245         Certain libjuju commands expect to be run from the same machine as Juju
 246          is bootstrapped to. This method will write the public key to disk in
 247          that location: ~/.local/share/juju/ssh/juju_id_rsa.pub
 248         """
 249         # Make sure that we have a public key before writing to disk
 250         if public_key is None or len(public_key) == 0:
 251             if 'OSM_VCA_PUBKEY' in os.environ:
 252                 public_key = os.getenv('OSM_VCA_PUBKEY', '')
 253                 if len(public_key == 0):
 254                     return
 255             else:
 256                 return
 257
 258         path = "{}/.local/share/juju/ssh".format(
 259             os.path.expanduser('~'),
 260         )
 261         if not os.path.exists(path):
 262             os.makedirs(path)
 263
 264             with open('{}/juju_id_rsa.pub'.format(path), 'w') as f:
 265                 f.write(public_key)
 266
 267     def notify_callback(self, model_name, application_name, status, message,
 268                         callback=None, *callback_args):
 269         try:
 270             if callback:
 271                 callback(
 272                     model_name,
 273                     application_name,
 274                     status, message,
 275                     *callback_args,
 276                 )
 277         except Exception as e:
 278             self.log.error("[0] notify_callback exception {}".format(e))
 279             raise e
 280         return True
 281
 282     # Public methods
 283     async def Relate(self, model_name, vnfd):
 284         """Create a relation between the charm-enabled VDUs in a VNF.
 285
 286         The Relation mapping has two parts: the id of the vdu owning the endpoint, and the name of the endpoint.
 287
 288         vdu:
 289             ...
 290             relation:
 291             -   provides: dataVM:db
 292                 requires: mgmtVM:app
 293
 294         This tells N2VC that the charm referred to by the dataVM vdu offers a relation named 'db', and the mgmtVM vdu has an 'app' endpoint that should be connected to a database.
 295
 296         :param str ns_name: The name of the network service.
 297         :param dict vnfd: The parsed yaml VNF descriptor.
 298         """
 299
 300         # Currently, the call to Relate() is made automatically after the
 301         # deployment of each charm; if the relation depends on a charm that
 302         # hasn't been deployed yet, the call will fail silently. This will
 303         # prevent an API breakage, with the intent of making this an explicitly
 304         # required call in a more object-oriented refactor of the N2VC API.
 305
 306         configs = []
 307         vnf_config = vnfd.get("vnf-configuration")
 308         if vnf_config:
 309             juju = vnf_config['juju']
 310             if juju:
 311                 configs.append(vnf_config)
 312
 313         for vdu in vnfd['vdu']:
 314             vdu_config = vdu.get('vdu-configuration')
 315             if vdu_config:
 316                 juju = vdu_config['juju']
 317                 if juju:
 318                     configs.append(vdu_config)
 319
 320         def _get_application_name(name):
 321             """Get the application name that's mapped to a vnf/vdu."""
 322             vnf_member_index = 0
 323             vnf_name = vnfd['name']
 324
 325             for vdu in vnfd.get('vdu'):
 326                 # Compare the named portion of the relation to the vdu's id
 327                 if vdu['id'] == name:
 328                     application_name = self.FormatApplicationName(
 329                         model_name,
 330                         vnf_name,
 331                         str(vnf_member_index),
 332                     )
 333                     return application_name
 334                 else:
 335                     vnf_member_index += 1
 336
 337             return None
 338
 339         # Loop through relations
 340         for cfg in configs:
 341             if 'juju' in cfg:
 342                 if 'relation' in juju:
 343                     for rel in juju['relation']:
 344                         try:
 345
 346                             # get the application name for the provides
 347                             (name, endpoint) = rel['provides'].split(':')
 348                             application_name = _get_application_name(name)
 349
 350                             provides = "{}:{}".format(
 351                                 application_name,
 352                                 endpoint
 353                             )
 354
 355                             # get the application name for thr requires
 356                             (name, endpoint) = rel['requires'].split(':')
 357                             application_name = _get_application_name(name)
 358
 359                             requires = "{}:{}".format(
 360                                 application_name,
 361                                 endpoint
 362                             )
 363                             self.log.debug("Relation: {} <-> {}".format(
 364                                 provides,
 365                                 requires
 366                             ))
 367                             await self.add_relation(
 368                                 model_name,
 369                                 provides,
 370                                 requires,
 371                             )
 372                         except Exception as e:
 373                             self.log.debug("Exception: {}".format(e))
 374
 375         return
 376
 377     async def DeployCharms(self, model_name, application_name, vnfd,
 378                            charm_path, params={}, machine_spec={},
 379                            callback=None, *callback_args):
 380         """Deploy one or more charms associated with a VNF.
 381
 382         Deploy the charm(s) referenced in a VNF Descriptor.
 383
 384         :param str model_name: The name or unique id of the network service.
 385         :param str application_name: The name of the application
 386         :param dict vnfd: The name of the application
 387         :param str charm_path: The path to the Juju charm
 388         :param dict params: A dictionary of runtime parameters
 389           Examples::
 390           {
 391             'rw_mgmt_ip': '1.2.3.4',
 392             # Pass the initial-config-primitives section of the vnf or vdu
 393             'initial-config-primitives': {...}
 394             'user_values': dictionary with the day-1 parameters provided at instantiation time. It will replace values
 395                 inside < >. rw_mgmt_ip will be included here also
 396           }
 397         :param dict machine_spec: A dictionary describing the machine to
 398         install to
 399           Examples::
 400           {
 401             'hostname': '1.2.3.4',
 402             'username': 'ubuntu',
 403           }
 404         :param obj callback: A callback function to receive status changes.
 405         :param tuple callback_args: A list of arguments to be passed to the
 406         callback
 407         """
 408
 409         ########################################################
 410         # Verify the path to the charm exists and is readable. #
 411         ########################################################
 412         if not os.path.exists(charm_path):
 413             self.log.debug("Charm path doesn't exist: {}".format(charm_path))
 414             self.notify_callback(
 415                 model_name,
 416                 application_name,
 417                 "failed",
 418                 callback,
 419                 *callback_args,
 420             )
 421             raise JujuCharmNotFound("No artifacts configured.")
 422
 423         ################################
 424         # Login to the Juju controller #
 425         ################################
 426         if not self.authenticated:
 427             self.log.debug("Authenticating with Juju")
 428             await self.login()
 429
 430         ##########################################
 431         # Get the model for this network service #
 432         ##########################################
 433         model = await self.get_model(model_name)
 434
 435         ########################################
 436         # Verify the application doesn't exist #
 437         ########################################
 438         app = await self.get_application(model, application_name)
 439         if app:
 440             raise JujuApplicationExists("Can't deploy application \"{}\" to model \"{}\" because it already exists.".format(application_name, model_name))
 441
 442         ################################################################
 443         # Register this application with the model-level event monitor #
 444         ################################################################
 445         if callback:
 446             self.log.debug("JujuApi: Registering callback for {}".format(
 447                 application_name,
 448             ))
 449             await self.Subscribe(model_name, application_name, callback, *callback_args)
 450
 451         ########################################################
 452         # Check for specific machine placement (native charms) #
 453         ########################################################
 454         to = ""
 455         if machine_spec.keys():
 456             if all(k in machine_spec for k in ['host', 'user']):
 457                 # Enlist an existing machine as a Juju unit
 458                 machine = await model.add_machine(spec='ssh:{}@{}:{}'.format(
 459                     machine_spec['username'],
 460                     machine_spec['hostname'],
 461                     self.GetPrivateKeyPath(),
 462                 ))
 463                 to = machine.id
 464
 465         #######################################
 466         # Get the initial charm configuration #
 467         #######################################
 468
 469         rw_mgmt_ip = None
 470         if 'rw_mgmt_ip' in params:
 471             rw_mgmt_ip = params['rw_mgmt_ip']
 472
 473         if 'initial-config-primitive' not in params:
 474             params['initial-config-primitive'] = {}
 475
 476         initial_config = self._get_config_from_dict(
 477             params['initial-config-primitive'],
 478             {'<rw_mgmt_ip>': rw_mgmt_ip}
 479         )
 480
 481         self.log.debug("JujuApi: Deploying charm ({}/{}) from {}".format(
 482             model_name,
 483             application_name,
 484             charm_path,
 485             to=to,
 486         ))
 487
 488         ########################################################
 489         # Deploy the charm and apply the initial configuration #
 490         ########################################################
 491         app = await model.deploy(
 492             # We expect charm_path to be either the path to the charm on disk
 493             # or in the format of cs:series/name
 494             charm_path,
 495             # This is the formatted, unique name for this charm
 496             application_name=application_name,
 497             # Proxy charms should use the current LTS. This will need to be
 498             # changed for native charms.
 499             series='xenial',
 500             # Apply the initial 'config' primitive during deployment
 501             config=initial_config,
 502             # Where to deploy the charm to.
 503             to=to,
 504         )
 505
 506         # Map the vdu id<->app name,
 507         #
 508         await self.Relate(model_name, vnfd)
 509
 510         # #######################################
 511         # # Execute initial config primitive(s) #
 512         # #######################################
 513         uuids = await self.ExecuteInitialPrimitives(
 514             model_name,
 515             application_name,
 516             params,
 517         )
 518         return uuids
 519
 520         # primitives = {}
 521         #
 522         # # Build a sequential list of the primitives to execute
 523         # for primitive in params['initial-config-primitive']:
 524         #     try:
 525         #         if primitive['name'] == 'config':
 526         #             # This is applied when the Application is deployed
 527         #             pass
 528         #         else:
 529         #             seq = primitive['seq']
 530         #
 531         #             params = {}
 532         #             if 'parameter' in primitive:
 533         #                 params = primitive['parameter']
 534         #
 535         #             primitives[seq] = {
 536         #                 'name': primitive['name'],
 537         #                 'parameters': self._map_primitive_parameters(
 538         #                     params,
 539         #                     {'<rw_mgmt_ip>': rw_mgmt_ip}
 540         #                 ),
 541         #             }
 542         #
 543         #             for primitive in sorted(primitives):
 544         #                 await self.ExecutePrimitive(
 545         #                     model_name,
 546         #                     application_name,
 547         #                     primitives[primitive]['name'],
 548         #                     callback,
 549         #                     callback_args,
 550         #                     **primitives[primitive]['parameters'],
 551         #                 )
 552         #     except N2VCPrimitiveExecutionFailed as e:
 553         #         self.log.debug(
 554         #             "[N2VC] Exception executing primitive: {}".format(e)
 555         #         )
 556         #         raise
 557
 558     async def GetPrimitiveStatus(self, model_name, uuid):
 559         """Get the status of an executed Primitive.
 560
 561         The status of an executed Primitive will be one of three values:
 562         - completed
 563         - failed
 564         - running
 565         """
 566         status = None
 567         try:
 568             if not self.authenticated:
 569                 await self.login()
 570
 571             model = await self.get_model(model_name)
 572
 573             results = await model.get_action_status(uuid)
 574
 575             if uuid in results:
 576                 status = results[uuid]
 577
 578         except Exception as e:
 579             self.log.debug(
 580                 "Caught exception while getting primitive status: {}".format(e)
 581             )
 582             raise N2VCPrimitiveExecutionFailed(e)
 583
 584         return status
 585
 586     async def GetPrimitiveOutput(self, model_name, uuid):
 587         """Get the output of an executed Primitive.
 588
 589         Note: this only returns output for a successfully executed primitive.
 590         """
 591         results = None
 592         try:
 593             if not self.authenticated:
 594                 await self.login()
 595
 596             model = await self.get_model(model_name)
 597             results = await model.get_action_output(uuid, 60)
 598         except Exception as e:
 599             self.log.debug(
 600                 "Caught exception while getting primitive status: {}".format(e)
 601             )
 602             raise N2VCPrimitiveExecutionFailed(e)
 603
 604         return results
 605
 606     # async def ProvisionMachine(self, model_name, hostname, username):
 607     #     """Provision machine for usage with Juju.
 608     #
 609     #     Provisions a previously instantiated machine for use with Juju.
 610     #     """
 611     #     try:
 612     #         if not self.authenticated:
 613     #             await self.login()
 614     #
 615     #         # FIXME: This is hard-coded until model-per-ns is added
 616     #         model_name = 'default'
 617     #
 618     #         model = await self.get_model(model_name)
 619     #         model.add_machine(spec={})
 620     #
 621     #         machine = await model.add_machine(spec='ssh:{}@{}:{}'.format(
 622     #             "ubuntu",
 623     #             host['address'],
 624     #             private_key_path,
 625     #         ))
 626     #         return machine.id
 627     #
 628     #     except Exception as e:
 629     #         self.log.debug(
 630     #             "Caught exception while getting primitive status: {}".format(e)
 631     #         )
 632     #         raise N2VCPrimitiveExecutionFailed(e)
 633
 634     def GetPrivateKeyPath(self):
 635         homedir = os.environ['HOME']
 636         sshdir = "{}/.ssh".format(homedir)
 637         private_key_path = "{}/id_n2vc_rsa".format(sshdir)
 638         return private_key_path
 639
 640     async def GetPublicKey(self):
 641         """Get the N2VC SSH public key.abs
 642
 643         Returns the SSH public key, to be injected into virtual machines to
 644         be managed by the VCA.
 645
 646         The first time this is run, a ssh keypair will be created. The public
 647         key is injected into a VM so that we can provision the machine with
 648         Juju, after which Juju will communicate with the VM directly via the
 649         juju agent.
 650         """
 651         public_key = ""
 652
 653         # Find the path to where we expect our key to live.
 654         homedir = os.environ['HOME']
 655         sshdir = "{}/.ssh".format(homedir)
 656         if not os.path.exists(sshdir):
 657             os.mkdir(sshdir)
 658
 659         private_key_path = "{}/id_n2vc_rsa".format(sshdir)
 660         public_key_path = "{}.pub".format(private_key_path)
 661
 662         # If we don't have a key generated, generate it.
 663         if not os.path.exists(private_key_path):
 664             cmd = "ssh-keygen -t {} -b {} -N '' -f {}".format(
 665                 "rsa",
 666                 "4096",
 667                 private_key_path
 668             )
 669             subprocess.check_output(shlex.split(cmd))
 670
 671         # Read the public key
 672         with open(public_key_path, "r") as f:
 673             public_key = f.readline()
 674
 675         return public_key
 676
 677     async def ExecuteInitialPrimitives(self, model_name, application_name,
 678                                        params, callback=None, *callback_args):
 679         """Execute multiple primitives.
 680
 681         Execute multiple primitives as declared in initial-config-primitive.
 682         This is useful in cases where the primitives initially failed -- for
 683         example, if the charm is a proxy but the proxy hasn't been configured
 684         yet.
 685         """
 686         uuids = []
 687         primitives = {}
 688
 689         # Build a sequential list of the primitives to execute
 690         for primitive in params['initial-config-primitive']:
 691             try:
 692                 if primitive['name'] == 'config':
 693                     pass
 694                 else:
 695                     seq = primitive['seq']
 696
 697                     params_ = {}
 698                     if 'parameter' in primitive:
 699                         params_ = primitive['parameter']
 700
 701                     user_values = params.get("user_values", {})
 702                     if 'rw_mgmt_ip' not in user_values:
 703                         user_values['rw_mgmt_ip'] = None
 704                         # just for backward compatibility, because it will be provided always by modern version of LCM
 705
 706                     primitives[seq] = {
 707                         'name': primitive['name'],
 708                         'parameters': self._map_primitive_parameters(
 709                             params_,
 710                             user_values
 711                         ),
 712                     }
 713
 714                     for primitive in sorted(primitives):
 715                         uuids.append(
 716                             await self.ExecutePrimitive(
 717                                 model_name,
 718                                 application_name,
 719                                 primitives[primitive]['name'],
 720                                 callback,
 721                                 callback_args,
 722                                 **primitives[primitive]['parameters'],
 723                             )
 724                         )
 725             except N2VCPrimitiveExecutionFailed as e:
 726                 self.log.debug(
 727                     "[N2VC] Exception executing primitive: {}".format(e)
 728                 )
 729                 raise
 730         return uuids
 731
 732     async def ExecutePrimitive(self, model_name, application_name, primitive,
 733                                callback, *callback_args, **params):
 734         """Execute a primitive of a charm for Day 1 or Day 2 configuration.
 735
 736         Execute a primitive defined in the VNF descriptor.
 737
 738         :param str model_name: The name or unique id of the network service.
 739         :param str application_name: The name of the application
 740         :param str primitive: The name of the primitive to execute.
 741         :param obj callback: A callback function to receive status changes.
 742         :param tuple callback_args: A list of arguments to be passed to the
 743          callback function.
 744         :param dict params: A dictionary of key=value pairs representing the
 745          primitive's parameters
 746           Examples::
 747           {
 748             'rw_mgmt_ip': '1.2.3.4',
 749             # Pass the initial-config-primitives section of the vnf or vdu
 750             'initial-config-primitives': {...}
 751           }
 752         """
 753         self.log.debug("Executing primitive={} params={}".format(primitive, params))
 754         uuid = None
 755         try:
 756             if not self.authenticated:
 757                 await self.login()
 758
 759             model = await self.get_model(model_name)
 760
 761             if primitive == 'config':
 762                 # config is special, and expecting params to be a dictionary
 763                 await self.set_config(
 764                     model,
 765                     application_name,
 766                     params['params'],
 767                 )
 768             else:
 769                 app = await self.get_application(model, application_name)
 770                 if app:
 771                     # Run against the first (and probably only) unit in the app
 772                     unit = app.units[0]
 773                     if unit:
 774                         action = await unit.run_action(primitive, **params)
 775                         uuid = action.id
 776         except Exception as e:
 777             self.log.debug(
 778                 "Caught exception while executing primitive: {}".format(e)
 779             )
 780             raise N2VCPrimitiveExecutionFailed(e)
 781         return uuid
 782
 783     async def RemoveCharms(self, model_name, application_name, callback=None,
 784                            *callback_args):
 785         """Remove a charm from the VCA.
 786
 787         Remove a charm referenced in a VNF Descriptor.
 788
 789         :param str model_name: The name of the network service.
 790         :param str application_name: The name of the application
 791         :param obj callback: A callback function to receive status changes.
 792         :param tuple callback_args: A list of arguments to be passed to the
 793          callback function.
 794         """
 795         try:
 796             if not self.authenticated:
 797                 await self.login()
 798
 799             model = await self.get_model(model_name)
 800             app = await self.get_application(model, application_name)
 801             if app:
 802                 # Remove this application from event monitoring
 803                 await self.Unsubscribe(model_name, application_name)
 804
 805                 # self.notify_callback(model_name, application_name, "removing", callback, *callback_args)
 806                 self.log.debug(
 807                     "Removing the application {}".format(application_name)
 808                 )
 809                 await app.remove()
 810
 811                 await self.disconnect_model(self.monitors[model_name])
 812
 813                 self.notify_callback(
 814                     model_name,
 815                     application_name,
 816                     "removed",
 817                     "Removing charm {}".format(application_name),
 818                     callback,
 819                     *callback_args,
 820                 )
 821
 822         except Exception as e:
 823             print("Caught exception: {}".format(e))
 824             self.log.debug(e)
 825             raise e
 826
 827     async def CreateNetworkService(self, ns_uuid):
 828         """Create a new Juju model for the Network Service.
 829
 830         Creates a new Model in the Juju Controller.
 831
 832         :param str ns_uuid: A unique id representing an instaance of a
 833             Network Service.
 834
 835         :returns: True if the model was created. Raises JujuError on failure.
 836         """
 837         if not self.authenticated:
 838             await self.login()
 839
 840         models = await self.controller.list_models()
 841         if ns_uuid not in models:
 842             try:
 843                 self.models[ns_uuid] = await self.controller.add_model(
 844                     ns_uuid
 845                 )
 846             except JujuError as e:
 847                 if "already exists" not in e.message:
 848                     raise e
 849
 850             # Create an observer for this model
 851             await self.create_model_monitor(ns_uuid)
 852
 853         return True
 854
 855     async def DestroyNetworkService(self, ns_uuid):
 856         """Destroy a Network Service.
 857
 858         Destroy the Network Service and any deployed charms.
 859
 860         :param ns_uuid The unique id of the Network Service
 861
 862         :returns: True if the model was created. Raises JujuError on failure.
 863         """
 864
 865         # Do not delete the default model. The default model was used by all
 866         # Network Services, prior to the implementation of a model per NS.
 867         if ns_uuid.lower() == "default":
 868             return False
 869
 870         if not self.authenticated:
 871             self.log.debug("Authenticating with Juju")
 872             await self.login()
 873
 874         # Disconnect from the Model
 875         if ns_uuid in self.models:
 876             await self.disconnect_model(self.models[ns_uuid])
 877
 878         try:
 879             await self.controller.destroy_models(ns_uuid)
 880         except JujuError:
 881             raise NetworkServiceDoesNotExist(
 882                 "The Network Service '{}' does not exist".format(ns_uuid)
 883             )
 884
 885         return True
 886
 887     async def GetMetrics(self, model_name, application_name):
 888         """Get the metrics collected by the VCA.
 889
 890         :param model_name The name or unique id of the network service
 891         :param application_name The name of the application
 892         """
 893         metrics = {}
 894         model = await self.get_model(model_name)
 895         app = await self.get_application(model, application_name)
 896         if app:
 897             metrics = await app.get_metrics()
 898
 899         return metrics
 900
 901     async def HasApplication(self, model_name, application_name):
 902         model = await self.get_model(model_name)
 903         app = await self.get_application(model, application_name)
 904         if app:
 905             return True
 906         return False
 907
 908     async def Subscribe(self, ns_name, application_name, callback, *callback_args):
 909         """Subscribe to callbacks for an application.
 910
 911         :param ns_name str: The name of the Network Service
 912         :param application_name str: The name of the application
 913         :param callback obj: The callback method
 914         :param callback_args list: The list of arguments to append to calls to
 915             the callback method
 916         """
 917         self.monitors[ns_name].AddApplication(
 918             application_name,
 919             callback,
 920             *callback_args
 921         )
 922
 923     async def Unsubscribe(self, ns_name, application_name):
 924         """Unsubscribe to callbacks for an application.
 925
 926         Unsubscribes the caller from notifications from a deployed application.
 927
 928         :param ns_name str: The name of the Network Service
 929         :param application_name str: The name of the application
 930         """
 931         self.monitors[ns_name].RemoveApplication(
 932             application_name,
 933         )
 934
 935     # Non-public methods
 936     async def add_relation(self, model_name, relation1, relation2):
 937         """
 938         Add a relation between two application endpoints.
 939
 940         :param str model_name: The name or unique id of the network service
 941         :param str relation1: '<application>[:<relation_name>]'
 942         :param str relation2: '<application>[:<relation_name>]'
 943         """
 944
 945         if not self.authenticated:
 946             await self.login()
 947
 948         m = await self.get_model(model_name)
 949         try:
 950             await m.add_relation(relation1, relation2)
 951         except JujuAPIError as e:
 952             # If one of the applications in the relationship doesn't exist,
 953             # or the relation has already been added, let the operation fail
 954             # silently.
 955             if 'not found' in e.message:
 956                 return
 957             if 'already exists' in e.message:
 958                 return
 959
 960             raise e
 961
 962     # async def apply_config(self, config, application):
 963     #     """Apply a configuration to the application."""
 964     #     print("JujuApi: Applying configuration to {}.".format(
 965     #         application
 966     #     ))
 967     #     return await self.set_config(application=application, config=config)
 968
 969     def _get_config_from_dict(self, config_primitive, values):
 970         """Transform the yang config primitive to dict.
 971
 972         Expected result:
 973
 974             config = {
 975                 'config':
 976             }
 977         """
 978         config = {}
 979         for primitive in config_primitive:
 980             if primitive['name'] == 'config':
 981                 # config = self._map_primitive_parameters()
 982                 for parameter in primitive['parameter']:
 983                     param = str(parameter['name'])
 984                     if parameter['value'] == "<rw_mgmt_ip>":
 985                         config[param] = str(values[parameter['value']])
 986                     else:
 987                         config[param] = str(parameter['value'])
 988
 989         return config
 990
 991     def _map_primitive_parameters(self, parameters, user_values):
 992         params = {}
 993         for parameter in parameters:
 994             param = str(parameter['name'])
 995             value = parameter.get('value')
 996
 997             # map parameters inside a < >; e.g. <rw_mgmt_ip>. with the provided user_values.
 998             # Must exist at user_values except if there is a default value
 999             if isinstance(value, str) and value.startswith("<") and value.endswith(">"):
1000                 if parameter['value'][1:-1] in user_values:
1001                     value = user_values[parameter['value'][1:-1]]
1002                 elif 'default-value' in parameter:
1003                     value = parameter['default-value']
1004                 else:
1005                     raise KeyError("parameter {}='{}' not supplied ".format(param, value))
1006
1007             # If there's no value, use the default-value (if set)
1008             if value is None and 'default-value' in parameter:
1009                 value = parameter['default-value']
1010
1011             # Typecast parameter value, if present
1012             paramtype = "string"
1013             try:
1014                 if 'data-type' in parameter:
1015                     paramtype = str(parameter['data-type']).lower()
1016
1017                     if paramtype == "integer":
1018                         value = int(value)
1019                     elif paramtype == "boolean":
1020                         value = bool(value)
1021                     else:
1022                         value = str(value)
1023                 else:
1024                     # If there's no data-type, assume the value is a string
1025                     value = str(value)
1026             except ValueError:
1027                 raise ValueError("parameter {}='{}' cannot be converted to type {}".format(param, value, paramtype))
1028
1029             params[param] = value
1030         return params
1031
1032     def _get_config_from_yang(self, config_primitive, values):
1033         """Transform the yang config primitive to dict."""
1034         config = {}
1035         for primitive in config_primitive.values():
1036             if primitive['name'] == 'config':
1037                 for parameter in primitive['parameter'].values():
1038                     param = str(parameter['name'])
1039                     if parameter['value'] == "<rw_mgmt_ip>":
1040                         config[param] = str(values[parameter['value']])
1041                     else:
1042                         config[param] = str(parameter['value'])
1043
1044         return config
1045
1046     def FormatApplicationName(self, *args):
1047         """
1048         Generate a Juju-compatible Application name
1049
1050         :param args tuple: Positional arguments to be used to construct the
1051         application name.
1052
1053         Limitations::
1054         - Only accepts characters a-z and non-consequitive dashes (-)
1055         - Application name should not exceed 50 characters
1056
1057         Examples::
1058
1059             FormatApplicationName("ping_pong_ns", "ping_vnf", "a")
1060         """
1061         appname = ""
1062         for c in "-".join(list(args)):
1063             if c.isdigit():
1064                 c = chr(97 + int(c))
1065             elif not c.isalpha():
1066                 c = "-"
1067             appname += c
1068         return re.sub('-+', '-', appname.lower())
1069
1070     # def format_application_name(self, nsd_name, vnfr_name, member_vnf_index=0):
1071     #     """Format the name of the application
1072     #
1073     #     Limitations:
1074     #     - Only accepts characters a-z and non-consequitive dashes (-)
1075     #     - Application name should not exceed 50 characters
1076     #     """
1077     #     name = "{}-{}-{}".format(nsd_name, vnfr_name, member_vnf_index)
1078     #     new_name = ''
1079     #     for c in name:
1080     #         if c.isdigit():
1081     #             c = chr(97 + int(c))
1082     #         elif not c.isalpha():
1083     #             c = "-"
1084     #         new_name += c
1085     #     return re.sub('\-+', '-', new_name.lower())
1086
1087     def format_model_name(self, name):
1088         """Format the name of model.
1089
1090         Model names may only contain lowercase letters, digits and hyphens
1091         """
1092
1093         return name.replace('_', '-').lower()
1094
1095     async def get_application(self, model, application):
1096         """Get the deployed application."""
1097         if not self.authenticated:
1098             await self.login()
1099
1100         app = None
1101         if application and model:
1102             if model.applications:
1103                 if application in model.applications:
1104                     app = model.applications[application]
1105
1106         return app
1107
1108     async def get_model(self, model_name):
1109         """Get a model from the Juju Controller.
1110
1111         Note: Model objects returned must call disconnected() before it goes
1112         out of scope."""
1113         if not self.authenticated:
1114             await self.login()
1115
1116         if model_name not in self.models:
1117             # Get the models in the controller
1118             models = await self.controller.list_models()
1119
1120             if model_name not in models:
1121                 try:
1122                     self.models[model_name] = await self.controller.add_model(
1123                         model_name
1124                     )
1125                 except JujuError as e:
1126                     if "already exists" not in e.message:
1127                         raise e
1128             else:
1129                 self.models[model_name] = await self.controller.get_model(
1130                     model_name
1131                 )
1132
1133             self.refcount['model'] += 1
1134
1135             # Create an observer for this model
1136             await self.create_model_monitor(model_name)
1137
1138         return self.models[model_name]
1139
1140     async def create_model_monitor(self, model_name):
1141         """Create a monitor for the model, if none exists."""
1142         if not self.authenticated:
1143             await self.login()
1144
1145         if model_name not in self.monitors:
1146             self.monitors[model_name] = VCAMonitor(model_name)
1147             self.models[model_name].add_observer(self.monitors[model_name])
1148
1149         return True
1150
1151     async def login(self):
1152         """Login to the Juju controller."""
1153
1154         if self.authenticated:
1155             return
1156
1157         self.connecting = True
1158
1159         self.log.debug("JujuApi: Logging into controller")
1160
1161         self.controller = Controller(loop=self.loop)
1162
1163         if self.secret:
1164             self.log.debug(
1165                 "Connecting to controller... ws://{}:{} as {}/{}".format(
1166                     self.endpoint,
1167                     self.port,
1168                     self.user,
1169                     self.secret,
1170                 )
1171             )
1172             await self.controller.connect(
1173                 endpoint=self.endpoint,
1174                 username=self.user,
1175                 password=self.secret,
1176                 cacert=self.ca_cert,
1177             )
1178             self.refcount['controller'] += 1
1179         else:
1180             # current_controller no longer exists
1181             # self.log.debug("Connecting to current controller...")
1182             # await self.controller.connect_current()
1183             # await self.controller.connect(
1184             #     endpoint=self.endpoint,
1185             #     username=self.user,
1186             #     cacert=cacert,
1187             # )
1188             self.log.fatal("VCA credentials not configured.")
1189
1190         self.authenticated = True
1191         self.log.debug("JujuApi: Logged into controller")
1192
1193     async def logout(self):
1194         """Logout of the Juju controller."""
1195         if not self.authenticated:
1196             return False
1197
1198         try:
1199             for model in self.models:
1200                 await self.disconnect_model(model)
1201
1202             if self.controller:
1203                 self.log.debug("Disconnecting controller {}".format(
1204                     self.controller
1205                 ))
1206                 await self.controller.disconnect()
1207                 self.refcount['controller'] -= 1
1208                 self.controller = None
1209
1210             self.authenticated = False
1211
1212             self.log.debug(self.refcount)
1213
1214         except Exception as e:
1215             self.log.fatal(
1216                 "Fatal error logging out of Juju Controller: {}".format(e)
1217             )
1218             raise e
1219         return True
1220
1221     async def disconnect_model(self, model):
1222         self.log.debug("Disconnecting model {}".format(model))
1223         if model in self.models:
1224             print("Disconnecting model")
1225             await self.models[model].disconnect()
1226             self.refcount['model'] -= 1
1227             self.models[model] = None
1228
1229     # async def remove_application(self, name):
1230     #     """Remove the application."""
1231     #     if not self.authenticated:
1232     #         await self.login()
1233     #
1234     #     app = await self.get_application(name)
1235     #     if app:
1236     #         self.log.debug("JujuApi: Destroying application {}".format(
1237     #             name,
1238     #         ))
1239     #
1240     #         await app.destroy()
1241
1242     async def remove_relation(self, a, b):
1243         """
1244         Remove a relation between two application endpoints
1245
1246         :param a An application endpoint
1247         :param b An application endpoint
1248         """
1249         if not self.authenticated:
1250             await self.login()
1251
1252         m = await self.get_model()
1253         try:
1254             m.remove_relation(a, b)
1255         finally:
1256             await m.disconnect()
1257
1258     async def resolve_error(self, model_name, application=None):
1259         """Resolve units in error state."""
1260         if not self.authenticated:
1261             await self.login()
1262
1263         model = await self.get_model(model_name)
1264
1265         app = await self.get_application(model, application)
1266         if app:
1267             self.log.debug(
1268                 "JujuApi: Resolving errors for application {}".format(
1269                     application,
1270                 )
1271             )
1272
1273             for unit in app.units:
1274                 app.resolved(retry=True)
1275
1276     async def run_action(self, model_name, application, action_name, **params):
1277         """Execute an action and return an Action object."""
1278         if not self.authenticated:
1279             await self.login()
1280         result = {
1281             'status': '',
1282             'action': {
1283                 'tag': None,
1284                 'results': None,
1285             }
1286         }
1287
1288         model = await self.get_model(model_name)
1289
1290         app = await self.get_application(model, application)
1291         if app:
1292             # We currently only have one unit per application
1293             # so use the first unit available.
1294             unit = app.units[0]
1295
1296             self.log.debug(
1297                 "JujuApi: Running Action {} against Application {}".format(
1298                     action_name,
1299                     application,
1300                 )
1301             )
1302
1303             action = await unit.run_action(action_name, **params)
1304
1305             # Wait for the action to complete
1306             await action.wait()
1307
1308             result['status'] = action.status
1309             result['action']['tag'] = action.data['id']
1310             result['action']['results'] = action.results
1311
1312         return result
1313
1314     async def set_config(self, model_name, application, config):
1315         """Apply a configuration to the application."""
1316         if not self.authenticated:
1317             await self.login()
1318
1319         app = await self.get_application(model_name, application)
1320         if app:
1321             self.log.debug("JujuApi: Setting config for Application {}".format(
1322                 application,
1323             ))
1324             await app.set_config(config)
1325
1326             # Verify the config is set
1327             newconf = await app.get_config()
1328             for key in config:
1329                 if config[key] != newconf[key]['value']:
1330                     self.log.debug("JujuApi: Config not set! Key {} Value {} doesn't match {}".format(key, config[key], newconf[key]))
1331
1332     # async def set_parameter(self, parameter, value, application=None):
1333     #     """Set a config parameter for a service."""
1334     #     if not self.authenticated:
1335     #         await self.login()
1336     #
1337     #     self.log.debug("JujuApi: Setting {}={} for Application {}".format(
1338     #         parameter,
1339     #         value,
1340     #         application,
1341     #     ))
1342     #     return await self.apply_config(
1343     #         {parameter: value},
1344     #         application=application,
1345         # )
1346
1347     async def wait_for_application(self, model_name, application_name,
1348                                    timeout=300):
1349         """Wait for an application to become active."""
1350         if not self.authenticated:
1351             await self.login()
1352
1353         model = await self.get_model(model_name)
1354
1355         app = await self.get_application(model, application_name)
1356         self.log.debug("Application: {}".format(app))
1357         if app:
1358             self.log.debug(
1359                 "JujuApi: Waiting {} seconds for Application {}".format(
1360                     timeout,
1361                     application_name,
1362                 )
1363             )
1364
1365             await model.block_until(
1366                 lambda: all(
1367                     unit.agent_status == 'idle' and unit.workload_status in
1368                     ['active', 'unknown'] for unit in app.units
1369                 ),
1370                 timeout=timeout
1371             )