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