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                 juju = cfg['juju']
 343                 if 'relation' in juju:
 344                     for rel in juju['relation']:
 345                         try:
 346
 347                             # get the application name for the provides
 348                             (name, endpoint) = rel['provides'].split(':')
 349                             application_name = _get_application_name(name)
 350
 351                             provides = "{}:{}".format(
 352                                 application_name,
 353                                 endpoint
 354                             )
 355
 356                             # get the application name for thr requires
 357                             (name, endpoint) = rel['requires'].split(':')
 358                             application_name = _get_application_name(name)
 359
 360                             requires = "{}:{}".format(
 361                                 application_name,
 362                                 endpoint
 363                             )
 364                             self.log.debug("Relation: {} <-> {}".format(
 365                                 provides,
 366                                 requires
 367                             ))
 368                             await self.add_relation(
 369                                 model_name,
 370                                 provides,
 371                                 requires,
 372                             )
 373                         except Exception as e:
 374                             self.log.debug("Exception: {}".format(e))
 375
 376         return
 377
 378     async def DeployCharms(self, model_name, application_name, vnfd,
 379                            charm_path, params={}, machine_spec={},
 380                            callback=None, *callback_args):
 381         """Deploy one or more charms associated with a VNF.
 382
 383         Deploy the charm(s) referenced in a VNF Descriptor.
 384
 385         :param str model_name: The name or unique id of the network service.
 386         :param str application_name: The name of the application
 387         :param dict vnfd: The name of the application
 388         :param str charm_path: The path to the Juju charm
 389         :param dict params: A dictionary of runtime parameters
 390           Examples::
 391           {
 392             'rw_mgmt_ip': '1.2.3.4',
 393             # Pass the initial-config-primitives section of the vnf or vdu
 394             'initial-config-primitives': {...}
 395             'user_values': dictionary with the day-1 parameters provided at instantiation time. It will replace values
 396                 inside < >. rw_mgmt_ip will be included here also
 397           }
 398         :param dict machine_spec: A dictionary describing the machine to
 399         install to
 400           Examples::
 401           {
 402             'hostname': '1.2.3.4',
 403             'username': 'ubuntu',
 404           }
 405         :param obj callback: A callback function to receive status changes.
 406         :param tuple callback_args: A list of arguments to be passed to the
 407         callback
 408         """
 409
 410         ########################################################
 411         # Verify the path to the charm exists and is readable. #
 412         ########################################################
 413         if not os.path.exists(charm_path):
 414             self.log.debug("Charm path doesn't exist: {}".format(charm_path))
 415             self.notify_callback(
 416                 model_name,
 417                 application_name,
 418                 "failed",
 419                 callback,
 420                 *callback_args,
 421             )
 422             raise JujuCharmNotFound("No artifacts configured.")
 423
 424         ################################
 425         # Login to the Juju controller #
 426         ################################
 427         if not self.authenticated:
 428             self.log.debug("Authenticating with Juju")
 429             await self.login()
 430
 431         ##########################################
 432         # Get the model for this network service #
 433         ##########################################
 434         model = await self.get_model(model_name)
 435
 436         ########################################
 437         # Verify the application doesn't exist #
 438         ########################################
 439         app = await self.get_application(model, application_name)
 440         if app:
 441             raise JujuApplicationExists("Can't deploy application \"{}\" to model \"{}\" because it already exists.".format(application_name, model_name))
 442
 443         ################################################################
 444         # Register this application with the model-level event monitor #
 445         ################################################################
 446         if callback:
 447             self.log.debug("JujuApi: Registering callback for {}".format(
 448                 application_name,
 449             ))
 450             await self.Subscribe(model_name, application_name, callback, *callback_args)
 451
 452         ########################################################
 453         # Check for specific machine placement (native charms) #
 454         ########################################################
 455         to = ""
 456         if machine_spec.keys():
 457             if all(k in machine_spec for k in ['host', 'user']):
 458                 # Enlist an existing machine as a Juju unit
 459                 machine = await model.add_machine(spec='ssh:{}@{}:{}'.format(
 460                     machine_spec['username'],
 461                     machine_spec['hostname'],
 462                     self.GetPrivateKeyPath(),
 463                 ))
 464                 to = machine.id
 465
 466         #######################################
 467         # Get the initial charm configuration #
 468         #######################################
 469
 470         rw_mgmt_ip = None
 471         if 'rw_mgmt_ip' in params:
 472             rw_mgmt_ip = params['rw_mgmt_ip']
 473
 474         if 'initial-config-primitive' not in params:
 475             params['initial-config-primitive'] = {}
 476
 477         initial_config = self._get_config_from_dict(
 478             params['initial-config-primitive'],
 479             {'<rw_mgmt_ip>': rw_mgmt_ip}
 480         )
 481
 482         self.log.debug("JujuApi: Deploying charm ({}/{}) from {}".format(
 483             model_name,
 484             application_name,
 485             charm_path,
 486             to=to,
 487         ))
 488
 489         ########################################################
 490         # Deploy the charm and apply the initial configuration #
 491         ########################################################
 492         app = await model.deploy(
 493             # We expect charm_path to be either the path to the charm on disk
 494             # or in the format of cs:series/name
 495             charm_path,
 496             # This is the formatted, unique name for this charm
 497             application_name=application_name,
 498             # Proxy charms should use the current LTS. This will need to be
 499             # changed for native charms.
 500             series='xenial',
 501             # Apply the initial 'config' primitive during deployment
 502             config=initial_config,
 503             # Where to deploy the charm to.
 504             to=to,
 505         )
 506
 507         # Map the vdu id<->app name,
 508         #
 509         await self.Relate(model_name, vnfd)
 510
 511         # #######################################
 512         # # Execute initial config primitive(s) #
 513         # #######################################
 514         uuids = await self.ExecuteInitialPrimitives(
 515             model_name,
 516             application_name,
 517             params,
 518         )
 519         return uuids
 520
 521         # primitives = {}
 522         #
 523         # # Build a sequential list of the primitives to execute
 524         # for primitive in params['initial-config-primitive']:
 525         #     try:
 526         #         if primitive['name'] == 'config':
 527         #             # This is applied when the Application is deployed
 528         #             pass
 529         #         else:
 530         #             seq = primitive['seq']
 531         #
 532         #             params = {}
 533         #             if 'parameter' in primitive:
 534         #                 params = primitive['parameter']
 535         #
 536         #             primitives[seq] = {
 537         #                 'name': primitive['name'],
 538         #                 'parameters': self._map_primitive_parameters(
 539         #                     params,
 540         #                     {'<rw_mgmt_ip>': rw_mgmt_ip}
 541         #                 ),
 542         #             }
 543         #
 544         #             for primitive in sorted(primitives):
 545         #                 await self.ExecutePrimitive(
 546         #                     model_name,
 547         #                     application_name,
 548         #                     primitives[primitive]['name'],
 549         #                     callback,
 550         #                     callback_args,
 551         #                     **primitives[primitive]['parameters'],
 552         #                 )
 553         #     except N2VCPrimitiveExecutionFailed as e:
 554         #         self.log.debug(
 555         #             "[N2VC] Exception executing primitive: {}".format(e)
 556         #         )
 557         #         raise
 558
 559     async def GetPrimitiveStatus(self, model_name, uuid):
 560         """Get the status of an executed Primitive.
 561
 562         The status of an executed Primitive will be one of three values:
 563         - completed
 564         - failed
 565         - running
 566         """
 567         status = None
 568         try:
 569             if not self.authenticated:
 570                 await self.login()
 571
 572             model = await self.get_model(model_name)
 573
 574             results = await model.get_action_status(uuid)
 575
 576             if uuid in results:
 577                 status = results[uuid]
 578
 579         except Exception as e:
 580             self.log.debug(
 581                 "Caught exception while getting primitive status: {}".format(e)
 582             )
 583             raise N2VCPrimitiveExecutionFailed(e)
 584
 585         return status
 586
 587     async def GetPrimitiveOutput(self, model_name, uuid):
 588         """Get the output of an executed Primitive.
 589
 590         Note: this only returns output for a successfully executed primitive.
 591         """
 592         results = None
 593         try:
 594             if not self.authenticated:
 595                 await self.login()
 596
 597             model = await self.get_model(model_name)
 598             results = await model.get_action_output(uuid, 60)
 599         except Exception as e:
 600             self.log.debug(
 601                 "Caught exception while getting primitive status: {}".format(e)
 602             )
 603             raise N2VCPrimitiveExecutionFailed(e)
 604
 605         return results
 606
 607     # async def ProvisionMachine(self, model_name, hostname, username):
 608     #     """Provision machine for usage with Juju.
 609     #
 610     #     Provisions a previously instantiated machine for use with Juju.
 611     #     """
 612     #     try:
 613     #         if not self.authenticated:
 614     #             await self.login()
 615     #
 616     #         # FIXME: This is hard-coded until model-per-ns is added
 617     #         model_name = 'default'
 618     #
 619     #         model = await self.get_model(model_name)
 620     #         model.add_machine(spec={})
 621     #
 622     #         machine = await model.add_machine(spec='ssh:{}@{}:{}'.format(
 623     #             "ubuntu",
 624     #             host['address'],
 625     #             private_key_path,
 626     #         ))
 627     #         return machine.id
 628     #
 629     #     except Exception as e:
 630     #         self.log.debug(
 631     #             "Caught exception while getting primitive status: {}".format(e)
 632     #         )
 633     #         raise N2VCPrimitiveExecutionFailed(e)
 634
 635     def GetPrivateKeyPath(self):
 636         homedir = os.environ['HOME']
 637         sshdir = "{}/.ssh".format(homedir)
 638         private_key_path = "{}/id_n2vc_rsa".format(sshdir)
 639         return private_key_path
 640
 641     async def GetPublicKey(self):
 642         """Get the N2VC SSH public key.abs
 643
 644         Returns the SSH public key, to be injected into virtual machines to
 645         be managed by the VCA.
 646
 647         The first time this is run, a ssh keypair will be created. The public
 648         key is injected into a VM so that we can provision the machine with
 649         Juju, after which Juju will communicate with the VM directly via the
 650         juju agent.
 651         """
 652         public_key = ""
 653
 654         # Find the path to where we expect our key to live.
 655         homedir = os.environ['HOME']
 656         sshdir = "{}/.ssh".format(homedir)
 657         if not os.path.exists(sshdir):
 658             os.mkdir(sshdir)
 659
 660         private_key_path = "{}/id_n2vc_rsa".format(sshdir)
 661         public_key_path = "{}.pub".format(private_key_path)
 662
 663         # If we don't have a key generated, generate it.
 664         if not os.path.exists(private_key_path):
 665             cmd = "ssh-keygen -t {} -b {} -N '' -f {}".format(
 666                 "rsa",
 667                 "4096",
 668                 private_key_path
 669             )
 670             subprocess.check_output(shlex.split(cmd))
 671
 672         # Read the public key
 673         with open(public_key_path, "r") as f:
 674             public_key = f.readline()
 675
 676         return public_key
 677
 678     async def ExecuteInitialPrimitives(self, model_name, application_name,
 679                                        params, callback=None, *callback_args):
 680         """Execute multiple primitives.
 681
 682         Execute multiple primitives as declared in initial-config-primitive.
 683         This is useful in cases where the primitives initially failed -- for
 684         example, if the charm is a proxy but the proxy hasn't been configured
 685         yet.
 686         """
 687         uuids = []
 688         primitives = {}
 689
 690         # Build a sequential list of the primitives to execute
 691         for primitive in params['initial-config-primitive']:
 692             try:
 693                 if primitive['name'] == 'config':
 694                     pass
 695                 else:
 696                     seq = primitive['seq']
 697
 698                     params_ = {}
 699                     if 'parameter' in primitive:
 700                         params_ = primitive['parameter']
 701
 702                     user_values = params.get("user_values", {})
 703                     if 'rw_mgmt_ip' not in user_values:
 704                         user_values['rw_mgmt_ip'] = None
 705                         # just for backward compatibility, because it will be provided always by modern version of LCM
 706
 707                     primitives[seq] = {
 708                         'name': primitive['name'],
 709                         'parameters': self._map_primitive_parameters(
 710                             params_,
 711                             user_values
 712                         ),
 713                     }
 714
 715                     for primitive in sorted(primitives):
 716                         uuids.append(
 717                             await self.ExecutePrimitive(
 718                                 model_name,
 719                                 application_name,
 720                                 primitives[primitive]['name'],
 721                                 callback,
 722                                 callback_args,
 723                                 **primitives[primitive]['parameters'],
 724                             )
 725                         )
 726             except N2VCPrimitiveExecutionFailed as e:
 727                 self.log.debug(
 728                     "[N2VC] Exception executing primitive: {}".format(e)
 729                 )
 730                 raise
 731         return uuids
 732
 733     async def ExecutePrimitive(self, model_name, application_name, primitive,
 734                                callback, *callback_args, **params):
 735         """Execute a primitive of a charm for Day 1 or Day 2 configuration.
 736
 737         Execute a primitive defined in the VNF descriptor.
 738
 739         :param str model_name: The name or unique id of the network service.
 740         :param str application_name: The name of the application
 741         :param str primitive: The name of the primitive to execute.
 742         :param obj callback: A callback function to receive status changes.
 743         :param tuple callback_args: A list of arguments to be passed to the
 744          callback function.
 745         :param dict params: A dictionary of key=value pairs representing the
 746          primitive's parameters
 747           Examples::
 748           {
 749             'rw_mgmt_ip': '1.2.3.4',
 750             # Pass the initial-config-primitives section of the vnf or vdu
 751             'initial-config-primitives': {...}
 752           }
 753         """
 754         self.log.debug("Executing primitive={} params={}".format(primitive, params))
 755         uuid = None
 756         try:
 757             if not self.authenticated:
 758                 await self.login()
 759
 760             model = await self.get_model(model_name)
 761
 762             if primitive == 'config':
 763                 # config is special, and expecting params to be a dictionary
 764                 await self.set_config(
 765                     model,
 766                     application_name,
 767                     params['params'],
 768                 )
 769             else:
 770                 app = await self.get_application(model, application_name)
 771                 if app:
 772                     # Run against the first (and probably only) unit in the app
 773                     unit = app.units[0]
 774                     if unit:
 775                         action = await unit.run_action(primitive, **params)
 776                         uuid = action.id
 777         except Exception as e:
 778             self.log.debug(
 779                 "Caught exception while executing primitive: {}".format(e)
 780             )
 781             raise N2VCPrimitiveExecutionFailed(e)
 782         return uuid
 783
 784     async def RemoveCharms(self, model_name, application_name, callback=None,
 785                            *callback_args):
 786         """Remove a charm from the VCA.
 787
 788         Remove a charm referenced in a VNF Descriptor.
 789
 790         :param str model_name: The name of the network service.
 791         :param str application_name: The name of the application
 792         :param obj callback: A callback function to receive status changes.
 793         :param tuple callback_args: A list of arguments to be passed to the
 794          callback function.
 795         """
 796         try:
 797             if not self.authenticated:
 798                 await self.login()
 799
 800             model = await self.get_model(model_name)
 801             app = await self.get_application(model, application_name)
 802             if app:
 803                 # Remove this application from event monitoring
 804                 await self.Unsubscribe(model_name, application_name)
 805
 806                 # self.notify_callback(model_name, application_name, "removing", callback, *callback_args)
 807                 self.log.debug(
 808                     "Removing the application {}".format(application_name)
 809                 )
 810                 await app.remove()
 811
 812                 await self.disconnect_model(self.monitors[model_name])
 813
 814                 self.notify_callback(
 815                     model_name,
 816                     application_name,
 817                     "removed",
 818                     "Removing charm {}".format(application_name),
 819                     callback,
 820                     *callback_args,
 821                 )
 822
 823         except Exception as e:
 824             print("Caught exception: {}".format(e))
 825             self.log.debug(e)
 826             raise e
 827
 828     async def CreateNetworkService(self, ns_uuid):
 829         """Create a new Juju model for the Network Service.
 830
 831         Creates a new Model in the Juju Controller.
 832
 833         :param str ns_uuid: A unique id representing an instaance of a
 834             Network Service.
 835
 836         :returns: True if the model was created. Raises JujuError on failure.
 837         """
 838         if not self.authenticated:
 839             await self.login()
 840
 841         models = await self.controller.list_models()
 842         if ns_uuid not in models:
 843             try:
 844                 self.models[ns_uuid] = await self.controller.add_model(
 845                     ns_uuid
 846                 )
 847             except JujuError as e:
 848                 if "already exists" not in e.message:
 849                     raise e
 850
 851             # Create an observer for this model
 852             await self.create_model_monitor(ns_uuid)
 853
 854         return True
 855
 856     async def DestroyNetworkService(self, ns_uuid):
 857         """Destroy a Network Service.
 858
 859         Destroy the Network Service and any deployed charms.
 860
 861         :param ns_uuid The unique id of the Network Service
 862
 863         :returns: True if the model was created. Raises JujuError on failure.
 864         """
 865
 866         # Do not delete the default model. The default model was used by all
 867         # Network Services, prior to the implementation of a model per NS.
 868         if ns_uuid.lower() == "default":
 869             return False
 870
 871         if not self.authenticated:
 872             self.log.debug("Authenticating with Juju")
 873             await self.login()
 874
 875         # Disconnect from the Model
 876         if ns_uuid in self.models:
 877             await self.disconnect_model(self.models[ns_uuid])
 878
 879         try:
 880             await self.controller.destroy_models(ns_uuid)
 881         except JujuError:
 882             raise NetworkServiceDoesNotExist(
 883                 "The Network Service '{}' does not exist".format(ns_uuid)
 884             )
 885
 886         return True
 887
 888     async def GetMetrics(self, model_name, application_name):
 889         """Get the metrics collected by the VCA.
 890
 891         :param model_name The name or unique id of the network service
 892         :param application_name The name of the application
 893         """
 894         metrics = {}
 895         model = await self.get_model(model_name)
 896         app = await self.get_application(model, application_name)
 897         if app:
 898             metrics = await app.get_metrics()
 899
 900         return metrics
 901
 902     async def HasApplication(self, model_name, application_name):
 903         model = await self.get_model(model_name)
 904         app = await self.get_application(model, application_name)
 905         if app:
 906             return True
 907         return False
 908
 909     async def Subscribe(self, ns_name, application_name, callback, *callback_args):
 910         """Subscribe to callbacks for an application.
 911
 912         :param ns_name str: The name of the Network Service
 913         :param application_name str: The name of the application
 914         :param callback obj: The callback method
 915         :param callback_args list: The list of arguments to append to calls to
 916             the callback method
 917         """
 918         self.monitors[ns_name].AddApplication(
 919             application_name,
 920             callback,
 921             *callback_args
 922         )
 923
 924     async def Unsubscribe(self, ns_name, application_name):
 925         """Unsubscribe to callbacks for an application.
 926
 927         Unsubscribes the caller from notifications from a deployed application.
 928
 929         :param ns_name str: The name of the Network Service
 930         :param application_name str: The name of the application
 931         """
 932         self.monitors[ns_name].RemoveApplication(
 933             application_name,
 934         )
 935
 936     # Non-public methods
 937     async def add_relation(self, model_name, relation1, relation2):
 938         """
 939         Add a relation between two application endpoints.
 940
 941         :param str model_name: The name or unique id of the network service
 942         :param str relation1: '<application>[:<relation_name>]'
 943         :param str relation2: '<application>[:<relation_name>]'
 944         """
 945
 946         if not self.authenticated:
 947             await self.login()
 948
 949         m = await self.get_model(model_name)
 950         try:
 951             await m.add_relation(relation1, relation2)
 952         except JujuAPIError as e:
 953             # If one of the applications in the relationship doesn't exist,
 954             # or the relation has already been added, let the operation fail
 955             # silently.
 956             if 'not found' in e.message:
 957                 return
 958             if 'already exists' in e.message:
 959                 return
 960
 961             raise e
 962
 963     # async def apply_config(self, config, application):
 964     #     """Apply a configuration to the application."""
 965     #     print("JujuApi: Applying configuration to {}.".format(
 966     #         application
 967     #     ))
 968     #     return await self.set_config(application=application, config=config)
 969
 970     def _get_config_from_dict(self, config_primitive, values):
 971         """Transform the yang config primitive to dict.
 972
 973         Expected result:
 974
 975             config = {
 976                 'config':
 977             }
 978         """
 979         config = {}
 980         for primitive in config_primitive:
 981             if primitive['name'] == 'config':
 982                 # config = self._map_primitive_parameters()
 983                 for parameter in primitive['parameter']:
 984                     param = str(parameter['name'])
 985                     if parameter['value'] == "<rw_mgmt_ip>":
 986                         config[param] = str(values[parameter['value']])
 987                     else:
 988                         config[param] = str(parameter['value'])
 989
 990         return config
 991
 992     def _map_primitive_parameters(self, parameters, user_values):
 993         params = {}
 994         for parameter in parameters:
 995             param = str(parameter['name'])
 996             value = parameter.get('value')
 997
 998             # map parameters inside a < >; e.g. <rw_mgmt_ip>. with the provided user_values.
 999             # Must exist at user_values except if there is a default value
1000             if isinstance(value, str) and value.startswith("<") and value.endswith(">"):
1001                 if parameter['value'][1:-1] in user_values:
1002                     value = user_values[parameter['value'][1:-1]]
1003                 elif 'default-value' in parameter:
1004                     value = parameter['default-value']
1005                 else:
1006                     raise KeyError("parameter {}='{}' not supplied ".format(param, value))
1007
1008             # If there's no value, use the default-value (if set)
1009             if value is None and 'default-value' in parameter:
1010                 value = parameter['default-value']
1011
1012             # Typecast parameter value, if present
1013             paramtype = "string"
1014             try:
1015                 if 'data-type' in parameter:
1016                     paramtype = str(parameter['data-type']).lower()
1017
1018                     if paramtype == "integer":
1019                         value = int(value)
1020                     elif paramtype == "boolean":
1021                         value = bool(value)
1022                     else:
1023                         value = str(value)
1024                 else:
1025                     # If there's no data-type, assume the value is a string
1026                     value = str(value)
1027             except ValueError:
1028                 raise ValueError("parameter {}='{}' cannot be converted to type {}".format(param, value, paramtype))
1029
1030             params[param] = value
1031         return params
1032
1033     def _get_config_from_yang(self, config_primitive, values):
1034         """Transform the yang config primitive to dict."""
1035         config = {}
1036         for primitive in config_primitive.values():
1037             if primitive['name'] == 'config':
1038                 for parameter in primitive['parameter'].values():
1039                     param = str(parameter['name'])
1040                     if parameter['value'] == "<rw_mgmt_ip>":
1041                         config[param] = str(values[parameter['value']])
1042                     else:
1043                         config[param] = str(parameter['value'])
1044
1045         return config
1046
1047     def FormatApplicationName(self, *args):
1048         """
1049         Generate a Juju-compatible Application name
1050
1051         :param args tuple: Positional arguments to be used to construct the
1052         application name.
1053
1054         Limitations::
1055         - Only accepts characters a-z and non-consequitive dashes (-)
1056         - Application name should not exceed 50 characters
1057
1058         Examples::
1059
1060             FormatApplicationName("ping_pong_ns", "ping_vnf", "a")
1061         """
1062         appname = ""
1063         for c in "-".join(list(args)):
1064             if c.isdigit():
1065                 c = chr(97 + int(c))
1066             elif not c.isalpha():
1067                 c = "-"
1068             appname += c
1069         return re.sub('-+', '-', appname.lower())
1070
1071     # def format_application_name(self, nsd_name, vnfr_name, member_vnf_index=0):
1072     #     """Format the name of the application
1073     #
1074     #     Limitations:
1075     #     - Only accepts characters a-z and non-consequitive dashes (-)
1076     #     - Application name should not exceed 50 characters
1077     #     """
1078     #     name = "{}-{}-{}".format(nsd_name, vnfr_name, member_vnf_index)
1079     #     new_name = ''
1080     #     for c in name:
1081     #         if c.isdigit():
1082     #             c = chr(97 + int(c))
1083     #         elif not c.isalpha():
1084     #             c = "-"
1085     #         new_name += c
1086     #     return re.sub('\-+', '-', new_name.lower())
1087
1088     def format_model_name(self, name):
1089         """Format the name of model.
1090
1091         Model names may only contain lowercase letters, digits and hyphens
1092         """
1093
1094         return name.replace('_', '-').lower()
1095
1096     async def get_application(self, model, application):
1097         """Get the deployed application."""
1098         if not self.authenticated:
1099             await self.login()
1100
1101         app = None
1102         if application and model:
1103             if model.applications:
1104                 if application in model.applications:
1105                     app = model.applications[application]
1106
1107         return app
1108
1109     async def get_model(self, model_name):
1110         """Get a model from the Juju Controller.
1111
1112         Note: Model objects returned must call disconnected() before it goes
1113         out of scope."""
1114         if not self.authenticated:
1115             await self.login()
1116
1117         if model_name not in self.models:
1118             # Get the models in the controller
1119             models = await self.controller.list_models()
1120
1121             if model_name not in models:
1122                 try:
1123                     self.models[model_name] = await self.controller.add_model(
1124                         model_name
1125                     )
1126                 except JujuError as e:
1127                     if "already exists" not in e.message:
1128                         raise e
1129             else:
1130                 self.models[model_name] = await self.controller.get_model(
1131                     model_name
1132                 )
1133
1134             self.refcount['model'] += 1
1135
1136             # Create an observer for this model
1137             await self.create_model_monitor(model_name)
1138
1139         return self.models[model_name]
1140
1141     async def create_model_monitor(self, model_name):
1142         """Create a monitor for the model, if none exists."""
1143         if not self.authenticated:
1144             await self.login()
1145
1146         if model_name not in self.monitors:
1147             self.monitors[model_name] = VCAMonitor(model_name)
1148             self.models[model_name].add_observer(self.monitors[model_name])
1149
1150         return True
1151
1152     async def login(self):
1153         """Login to the Juju controller."""
1154
1155         if self.authenticated:
1156             return
1157
1158         self.connecting = True
1159
1160         self.log.debug("JujuApi: Logging into controller")
1161
1162         self.controller = Controller(loop=self.loop)
1163
1164         if self.secret:
1165             self.log.debug(
1166                 "Connecting to controller... ws://{}:{} as {}/{}".format(
1167                     self.endpoint,
1168                     self.port,
1169                     self.user,
1170                     self.secret,
1171                 )
1172             )
1173             await self.controller.connect(
1174                 endpoint=self.endpoint,
1175                 username=self.user,
1176                 password=self.secret,
1177                 cacert=self.ca_cert,
1178             )
1179             self.refcount['controller'] += 1
1180         else:
1181             # current_controller no longer exists
1182             # self.log.debug("Connecting to current controller...")
1183             # await self.controller.connect_current()
1184             # await self.controller.connect(
1185             #     endpoint=self.endpoint,
1186             #     username=self.user,
1187             #     cacert=cacert,
1188             # )
1189             self.log.fatal("VCA credentials not configured.")
1190
1191         self.authenticated = True
1192         self.log.debug("JujuApi: Logged into controller")
1193
1194     async def logout(self):
1195         """Logout of the Juju controller."""
1196         if not self.authenticated:
1197             return False
1198
1199         try:
1200             for model in self.models:
1201                 await self.disconnect_model(model)
1202
1203             if self.controller:
1204                 self.log.debug("Disconnecting controller {}".format(
1205                     self.controller
1206                 ))
1207                 await self.controller.disconnect()
1208                 self.refcount['controller'] -= 1
1209                 self.controller = None
1210
1211             self.authenticated = False
1212
1213             self.log.debug(self.refcount)
1214
1215         except Exception as e:
1216             self.log.fatal(
1217                 "Fatal error logging out of Juju Controller: {}".format(e)
1218             )
1219             raise e
1220         return True
1221
1222     async def disconnect_model(self, model):
1223         self.log.debug("Disconnecting model {}".format(model))
1224         if model in self.models:
1225             print("Disconnecting model")
1226             await self.models[model].disconnect()
1227             self.refcount['model'] -= 1
1228             self.models[model] = None
1229
1230     # async def remove_application(self, name):
1231     #     """Remove the application."""
1232     #     if not self.authenticated:
1233     #         await self.login()
1234     #
1235     #     app = await self.get_application(name)
1236     #     if app:
1237     #         self.log.debug("JujuApi: Destroying application {}".format(
1238     #             name,
1239     #         ))
1240     #
1241     #         await app.destroy()
1242
1243     async def remove_relation(self, a, b):
1244         """
1245         Remove a relation between two application endpoints
1246
1247         :param a An application endpoint
1248         :param b An application endpoint
1249         """
1250         if not self.authenticated:
1251             await self.login()
1252
1253         m = await self.get_model()
1254         try:
1255             m.remove_relation(a, b)
1256         finally:
1257             await m.disconnect()
1258
1259     async def resolve_error(self, model_name, application=None):
1260         """Resolve units in error state."""
1261         if not self.authenticated:
1262             await self.login()
1263
1264         model = await self.get_model(model_name)
1265
1266         app = await self.get_application(model, application)
1267         if app:
1268             self.log.debug(
1269                 "JujuApi: Resolving errors for application {}".format(
1270                     application,
1271                 )
1272             )
1273
1274             for unit in app.units:
1275                 app.resolved(retry=True)
1276
1277     async def run_action(self, model_name, application, action_name, **params):
1278         """Execute an action and return an Action object."""
1279         if not self.authenticated:
1280             await self.login()
1281         result = {
1282             'status': '',
1283             'action': {
1284                 'tag': None,
1285                 'results': None,
1286             }
1287         }
1288
1289         model = await self.get_model(model_name)
1290
1291         app = await self.get_application(model, application)
1292         if app:
1293             # We currently only have one unit per application
1294             # so use the first unit available.
1295             unit = app.units[0]
1296
1297             self.log.debug(
1298                 "JujuApi: Running Action {} against Application {}".format(
1299                     action_name,
1300                     application,
1301                 )
1302             )
1303
1304             action = await unit.run_action(action_name, **params)
1305
1306             # Wait for the action to complete
1307             await action.wait()
1308
1309             result['status'] = action.status
1310             result['action']['tag'] = action.data['id']
1311             result['action']['results'] = action.results
1312
1313         return result
1314
1315     async def set_config(self, model_name, application, config):
1316         """Apply a configuration to the application."""
1317         if not self.authenticated:
1318             await self.login()
1319
1320         app = await self.get_application(model_name, application)
1321         if app:
1322             self.log.debug("JujuApi: Setting config for Application {}".format(
1323                 application,
1324             ))
1325             await app.set_config(config)
1326
1327             # Verify the config is set
1328             newconf = await app.get_config()
1329             for key in config:
1330                 if config[key] != newconf[key]['value']:
1331                     self.log.debug("JujuApi: Config not set! Key {} Value {} doesn't match {}".format(key, config[key], newconf[key]))
1332
1333     # async def set_parameter(self, parameter, value, application=None):
1334     #     """Set a config parameter for a service."""
1335     #     if not self.authenticated:
1336     #         await self.login()
1337     #
1338     #     self.log.debug("JujuApi: Setting {}={} for Application {}".format(
1339     #         parameter,
1340     #         value,
1341     #         application,
1342     #     ))
1343     #     return await self.apply_config(
1344     #         {parameter: value},
1345     #         application=application,
1346         # )
1347
1348     async def wait_for_application(self, model_name, application_name,
1349                                    timeout=300):
1350         """Wait for an application to become active."""
1351         if not self.authenticated:
1352             await self.login()
1353
1354         model = await self.get_model(model_name)
1355
1356         app = await self.get_application(model, application_name)
1357         self.log.debug("Application: {}".format(app))
1358         if app:
1359             self.log.debug(
1360                 "JujuApi: Waiting {} seconds for Application {}".format(
1361                     timeout,
1362                     application_name,
1363                 )
1364             )
1365
1366             await model.block_until(
1367                 lambda: all(
1368                     unit.agent_status == 'idle' and unit.workload_status in
1369                     ['active', 'unknown'] for unit in app.units
1370                 ),
1371                 timeout=timeout
1372             )