1 # Copyright 2019 Canonical Ltd.
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
7 # http://www.apache.org/licenses/LICENSE-2.0
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.
27 import n2vc
.exceptions
28 from n2vc
.provisioner
import SSHProvisioner
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)
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
44 # We might need this to connect to the websocket securely, but test and verify.
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/
54 # Deprecated. Please use n2vc.exceptions namespace.
55 class JujuCharmNotFound(Exception):
56 """The Charm can't be found or is not readable."""
59 class JujuApplicationExists(Exception):
60 """The Application already exists."""
63 class N2VCPrimitiveExecutionFailed(Exception):
64 """Something failed while attempting to execute a primitive."""
67 class NetworkServiceDoesNotExist(Exception):
68 """The Network Service being acted against does not exist."""
71 class PrimitiveDoesNotExist(Exception):
72 """The Primitive being executed does not exist."""
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
)
82 class VCAMonitor(ModelObserver
):
83 """Monitor state changes within the Juju Model."""
86 def __init__(self
, ns_name
):
87 self
.log
= logging
.getLogger(__name__
)
89 self
.ns_name
= ns_name
90 self
.applications
= {}
92 def AddApplication(self
, application_name
, callback
, *callback_args
):
93 if application_name
not in self
.applications
:
94 self
.applications
[application_name
] = {
96 'callback_args': callback_args
99 def RemoveApplication(self
, application_name
):
100 if application_name
in self
.applications
:
101 del self
.applications
[application_name
]
103 async def on_change(self
, delta
, old
, new
, model
):
104 """React to changes in the Juju model."""
106 if delta
.entity
== "unit":
107 # Ignore change events from other applications
108 if delta
.data
['application'] not in self
.applications
.keys():
113 application_name
= delta
.data
['application']
115 callback
= self
.applications
[application_name
]['callback']
117 self
.applications
[application_name
]['callback_args']
120 # Fire off a callback with the application state
124 delta
.data
['application'],
126 new
.workload_status_message
,
130 # This is a charm being removed
134 delta
.data
['application'],
138 except Exception as e
:
139 self
.log
.debug("[1] notify_callback exception: {}".format(e
))
141 elif delta
.entity
== "action":
142 # TODO: Decide how we want to notify the user of actions
144 # uuid = delta.data['id'] # The Action's unique id
145 # msg = delta.data['message'] # The output of the action
147 # if delta.data['status'] == "pending":
148 # # The action is queued
150 # elif delta.data['status'] == "completed""
151 # # The action was successful
153 # elif delta.data['status'] == "failed":
154 # # The action failed.
162 # Create unique models per network service
163 # Document all public functions
175 juju_public_key
=None,
181 Initializes the N2VC object, allowing the caller to interoperate with the VCA.
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
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
197 client = n2vc.vnf.N2VC(
203 artifacts='/app/storage/myvnf/charms',
205 juju_public_key='<contents of the juju public key>',
206 ca_cert='<contents of CA certificate>',
207 api_proxy='192.168.1.155'
211 # Initialize instance-level variables
214 self
.controller
= None
215 self
.connecting
= False
216 self
.authenticated
= False
217 self
.api_proxy
= api_proxy
222 self
.log
= logging
.getLogger(__name__
)
241 self
.juju_public_key
= juju_public_key
243 self
._create
_juju
_public
_key
(juju_public_key
)
245 self
.juju_public_key
= ''
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.
256 cacert
= base64
.b64decode(b64string
).decode("utf-8")
263 except binascii
.Error
as e
:
264 self
.log
.debug("Caught binascii.Error: {}".format(e
))
265 raise n2vc
.exceptions
.InvalidCACertificate("Invalid CA Certificate")
271 self
.ca_cert
= base64_to_cacert(ca_cert
)
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)
280 self
.log
.debug('JujuApi: instantiated')
286 if user
.startswith('user-'):
289 self
.user
= 'user-{}'.format(user
)
291 self
.endpoint
= '%s:%d' % (server
, int(port
))
293 self
.artifacts
= artifacts
295 self
.loop
= loop
or asyncio
.get_event_loop()
298 """Close any open connections."""
301 def _create_juju_public_key(self
, public_key
):
302 """Recreate the Juju public key on disk.
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
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):
317 path
= "{}/.local/share/juju/ssh".format(
318 os
.path
.expanduser('~'),
320 if not os
.path
.exists(path
):
323 with
open('{}/juju_id_rsa.pub'.format(path
), 'w') as f
:
326 def notify_callback(self
, model_name
, application_name
, status
, message
,
327 callback
=None, *callback_args
):
336 except Exception as e
:
337 self
.log
.error("[0] notify_callback exception {}".format(e
))
342 async def Relate(self
, model_name
, vnfd
):
343 """Create a relation between the charm-enabled VDUs in a VNF.
345 The Relation mapping has two parts: the id of the vdu owning the endpoint, and the name of the endpoint.
351 - provides: dataVM:db
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.
356 :param str ns_name: The name of the network service.
357 :param dict vnfd: The parsed yaml VNF descriptor.
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.
367 vnf_config
= vnfd
.get("vnf-configuration")
369 juju
= vnf_config
['juju']
371 configs
.append(vnf_config
)
373 for vdu
in vnfd
['vdu']:
374 vdu_config
= vdu
.get('vdu-configuration')
376 juju
= vdu_config
['juju']
378 configs
.append(vdu_config
)
380 def _get_application_name(name
):
381 """Get the application name that's mapped to a vnf/vdu."""
383 vnf_name
= vnfd
['name']
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(
391 str(vnf_member_index
),
393 return application_name
395 vnf_member_index
+= 1
399 # Loop through relations
403 if 'vca-relationships' in juju
and 'relation' in juju
['vca-relationships']:
404 for rel
in juju
['vca-relationships']['relation']:
407 # get the application name for the provides
408 (name
, endpoint
) = rel
['provides'].split(':')
409 application_name
= _get_application_name(name
)
411 provides
= "{}:{}".format(
416 # get the application name for thr requires
417 (name
, endpoint
) = rel
['requires'].split(':')
418 application_name
= _get_application_name(name
)
420 requires
= "{}:{}".format(
424 self
.log
.debug("Relation: {} <-> {}".format(
428 await self
.add_relation(
433 except Exception as e
:
434 self
.log
.debug("Exception: {}".format(e
))
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.
443 Deploy the charm(s) referenced in a VNF Descriptor.
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
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
458 :param dict machine_spec: A dictionary describing the machine to
462 'hostname': '1.2.3.4',
463 'username': 'ubuntu',
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
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(
482 raise JujuCharmNotFound("No artifacts configured.")
484 ################################
485 # Login to the Juju controller #
486 ################################
487 if not self
.authenticated
:
488 self
.log
.debug("Authenticating with Juju")
491 ##########################################
492 # Get the model for this network service #
493 ##########################################
494 model
= await self
.get_model(model_name
)
496 ########################################
497 # Verify the application doesn't exist #
498 ########################################
499 app
= await self
.get_application(model
, application_name
)
501 raise JujuApplicationExists("Can't deploy application \"{}\" to model \"{}\" because it already exists.".format(application_name
, model_name
))
503 ################################################################
504 # Register this application with the model-level event monitor #
505 ################################################################
507 self
.log
.debug("JujuApi: Registering callback for {}".format(
510 await self
.Subscribe(model_name
, application_name
, callback
, *callback_args
)
512 #######################################
513 # Get the initial charm configuration #
514 #######################################
517 if 'rw_mgmt_ip' in params
:
518 rw_mgmt_ip
= params
['rw_mgmt_ip']
520 if 'initial-config-primitive' not in params
:
521 params
['initial-config-primitive'] = {}
523 initial_config
= self
._get
_config
_from
_dict
(
524 params
['initial-config-primitive'],
525 {'<rw_mgmt_ip>': rw_mgmt_ip
}
528 ########################################################
529 # Check for specific machine placement (native charms) #
530 ########################################################
534 if machine_spec
.keys():
535 if all(k
in machine_spec
for k
in ['hostname', 'username']):
537 # Allow series to be derived from the native charm
540 self
.log
.debug("Provisioning manual machine {}@{}".format(
541 machine_spec
['username'],
542 machine_spec
['hostname'],
545 """Native Charm support
547 Taking a bare VM (assumed to be an Ubuntu cloud image),
548 the provisioning process will:
549 - Create an ubuntu user w/sudo access
551 - Detect architecture
552 - Download and install Juju agent from controller
554 - Add an iptables rule to route traffic to the API proxy
557 to
= await self
.provision_machine(
558 model_name
=model_name
,
559 username
=machine_spec
['username'],
560 hostname
=machine_spec
['hostname'],
561 private_key_path
=self
.GetPrivateKeyPath(),
563 self
.log
.debug("Provisioned machine id {}".format(to
))
565 # TODO: If to is none, raise an exception
567 # The native charm won't have the sshproxy layer, typically, but LCM uses the config primitive
568 # to interpret what the values are. That's a gap to fill.
571 The ssh-* config parameters are unique to the sshproxy layer,
572 which most native charms will not be aware of.
574 Setting invalid config parameters will cause the deployment to
577 For the moment, we will strip the ssh-* parameters from native
578 charms, until the feature gap is addressed in the information
582 # Native charms don't include the ssh-* config values, so strip them
583 # from the initial_config, otherwise the deploy will raise an error.
584 # self.log.debug("Removing ssh-* from initial-config")
585 for k
in ['ssh-hostname', 'ssh-username', 'ssh-password']:
586 if k
in initial_config
:
587 self
.log
.debug("Removing parameter {}".format(k
))
588 del initial_config
[k
]
590 self
.log
.debug("JujuApi: Deploying charm ({}/{}) from {} to {}".format(
597 ########################################################
598 # Deploy the charm and apply the initial configuration #
599 ########################################################
600 app
= await model
.deploy(
601 # We expect charm_path to be either the path to the charm on disk
602 # or in the format of cs:series/name
604 # This is the formatted, unique name for this charm
605 application_name
=application_name
,
606 # Proxy charms should use the current LTS. This will need to be
607 # changed for native charms.
609 # Apply the initial 'config' primitive during deployment
610 config
=initial_config
,
611 # Where to deploy the charm to.
615 #############################
616 # Map the vdu id<->app name #
617 #############################
619 await self
.Relate(model_name
, vnfd
)
620 except KeyError as ex
:
621 # We don't currently support relations between NS and VNF/VDU charms
622 self
.log
.warn("[N2VC] Relations not supported: {}".format(ex
))
623 except Exception as ex
:
624 # This may happen if not all of the charms needed by the relation
625 # are ready. We can safely ignore this, because Relate will be
626 # retried when the endpoint of the relation is deployed.
627 self
.log
.warn("[N2VC] Relations not ready")
629 # #######################################
630 # # Execute initial config primitive(s) #
631 # #######################################
632 uuids
= await self
.ExecuteInitialPrimitives(
641 # # Build a sequential list of the primitives to execute
642 # for primitive in params['initial-config-primitive']:
644 # if primitive['name'] == 'config':
645 # # This is applied when the Application is deployed
648 # seq = primitive['seq']
651 # if 'parameter' in primitive:
652 # params = primitive['parameter']
654 # primitives[seq] = {
655 # 'name': primitive['name'],
656 # 'parameters': self._map_primitive_parameters(
658 # {'<rw_mgmt_ip>': rw_mgmt_ip}
662 # for primitive in sorted(primitives):
663 # await self.ExecutePrimitive(
666 # primitives[primitive]['name'],
669 # **primitives[primitive]['parameters'],
671 # except N2VCPrimitiveExecutionFailed as e:
673 # "[N2VC] Exception executing primitive: {}".format(e)
677 async def GetPrimitiveStatus(self
, model_name
, uuid
):
678 """Get the status of an executed Primitive.
680 The status of an executed Primitive will be one of three values:
687 if not self
.authenticated
:
690 model
= await self
.get_model(model_name
)
692 results
= await model
.get_action_status(uuid
)
695 status
= results
[uuid
]
697 except Exception as e
:
699 "Caught exception while getting primitive status: {}".format(e
)
701 raise N2VCPrimitiveExecutionFailed(e
)
705 async def GetPrimitiveOutput(self
, model_name
, uuid
):
706 """Get the output of an executed Primitive.
708 Note: this only returns output for a successfully executed primitive.
712 if not self
.authenticated
:
715 model
= await self
.get_model(model_name
)
716 results
= await model
.get_action_output(uuid
, 60)
717 except Exception as e
:
719 "Caught exception while getting primitive status: {}".format(e
)
721 raise N2VCPrimitiveExecutionFailed(e
)
725 # async def ProvisionMachine(self, model_name, hostname, username):
726 # """Provision machine for usage with Juju.
728 # Provisions a previously instantiated machine for use with Juju.
731 # if not self.authenticated:
734 # # FIXME: This is hard-coded until model-per-ns is added
735 # model_name = 'default'
737 # model = await self.get_model(model_name)
738 # model.add_machine(spec={})
740 # machine = await model.add_machine(spec='ssh:{}@{}:{}'.format(
747 # except Exception as e:
749 # "Caught exception while getting primitive status: {}".format(e)
751 # raise N2VCPrimitiveExecutionFailed(e)
753 def GetPrivateKeyPath(self
):
754 homedir
= os
.environ
['HOME']
755 sshdir
= "{}/.ssh".format(homedir
)
756 private_key_path
= "{}/id_n2vc_rsa".format(sshdir
)
757 return private_key_path
759 async def GetPublicKey(self
):
760 """Get the N2VC SSH public key.abs
762 Returns the SSH public key, to be injected into virtual machines to
763 be managed by the VCA.
765 The first time this is run, a ssh keypair will be created. The public
766 key is injected into a VM so that we can provision the machine with
767 Juju, after which Juju will communicate with the VM directly via the
772 # Find the path to where we expect our key to live.
773 homedir
= os
.environ
['HOME']
774 sshdir
= "{}/.ssh".format(homedir
)
775 if not os
.path
.exists(sshdir
):
778 private_key_path
= "{}/id_n2vc_rsa".format(sshdir
)
779 public_key_path
= "{}.pub".format(private_key_path
)
781 # If we don't have a key generated, generate it.
782 if not os
.path
.exists(private_key_path
):
783 cmd
= "ssh-keygen -t {} -b {} -N '' -f {}".format(
788 subprocess
.check_output(shlex
.split(cmd
))
790 # Read the public key
791 with
open(public_key_path
, "r") as f
:
792 public_key
= f
.readline()
796 async def ExecuteInitialPrimitives(self
, model_name
, application_name
,
797 params
, callback
=None, *callback_args
):
798 """Execute multiple primitives.
800 Execute multiple primitives as declared in initial-config-primitive.
801 This is useful in cases where the primitives initially failed -- for
802 example, if the charm is a proxy but the proxy hasn't been configured
808 # Build a sequential list of the primitives to execute
809 for primitive
in params
['initial-config-primitive']:
811 if primitive
['name'] == 'config':
814 seq
= primitive
['seq']
817 if 'parameter' in primitive
:
818 params_
= primitive
['parameter']
820 user_values
= params
.get("user_values", {})
821 if 'rw_mgmt_ip' not in user_values
:
822 user_values
['rw_mgmt_ip'] = None
823 # just for backward compatibility, because it will be provided always by modern version of LCM
826 'name': primitive
['name'],
827 'parameters': self
._map
_primitive
_parameters
(
833 for primitive
in sorted(primitives
):
835 # self.log.debug("Queuing action {}".format(primitives[primitive]['name']))
837 await self
.ExecutePrimitive(
840 primitives
[primitive
]['name'],
843 **primitives
[primitive
]['parameters'],
846 except PrimitiveDoesNotExist
as e
:
847 self
.log
.debug("Ignoring exception PrimitiveDoesNotExist: {}".format(e
))
849 except Exception as e
:
850 self
.log
.debug("XXXXXXXXXXXXXXXXXXXXXXXXX Unexpected exception: {}".format(e
))
853 except N2VCPrimitiveExecutionFailed
as e
:
855 "[N2VC] Exception executing primitive: {}".format(e
)
860 async def ExecutePrimitive(self
, model_name
, application_name
, primitive
,
861 callback
, *callback_args
, **params
):
862 """Execute a primitive of a charm for Day 1 or Day 2 configuration.
864 Execute a primitive defined in the VNF descriptor.
866 :param str model_name: The name or unique id of the network service.
867 :param str application_name: The name of the application
868 :param str primitive: The name of the primitive to execute.
869 :param obj callback: A callback function to receive status changes.
870 :param tuple callback_args: A list of arguments to be passed to the
872 :param dict params: A dictionary of key=value pairs representing the
873 primitive's parameters
876 'rw_mgmt_ip': '1.2.3.4',
877 # Pass the initial-config-primitives section of the vnf or vdu
878 'initial-config-primitives': {...}
881 self
.log
.debug("Executing primitive={} params={}".format(primitive
, params
))
884 if not self
.authenticated
:
887 model
= await self
.get_model(model_name
)
889 if primitive
== 'config':
890 # config is special, and expecting params to be a dictionary
891 await self
.set_config(
897 app
= await self
.get_application(model
, application_name
)
899 # Does this primitive exist?
900 actions
= await app
.get_actions()
902 if primitive
not in actions
.keys():
903 raise PrimitiveDoesNotExist("Primitive {} does not exist".format(primitive
))
905 # Run against the first (and probably only) unit in the app
908 action
= await unit
.run_action(primitive
, **params
)
910 except PrimitiveDoesNotExist
as e
:
911 # Catch and raise this exception if it's thrown from the inner block
913 except Exception as e
:
914 # An unexpected exception was caught
916 "Caught exception while executing primitive: {}".format(e
)
918 raise N2VCPrimitiveExecutionFailed(e
)
921 async def RemoveCharms(self
, model_name
, application_name
, callback
=None,
923 """Remove a charm from the VCA.
925 Remove a charm referenced in a VNF Descriptor.
927 :param str model_name: The name of the network service.
928 :param str application_name: The name of the application
929 :param obj callback: A callback function to receive status changes.
930 :param tuple callback_args: A list of arguments to be passed to the
934 if not self
.authenticated
:
937 model
= await self
.get_model(model_name
)
938 app
= await self
.get_application(model
, application_name
)
940 # Remove this application from event monitoring
941 await self
.Unsubscribe(model_name
, application_name
)
943 # self.notify_callback(model_name, application_name, "removing", callback, *callback_args)
945 "Removing the application {}".format(application_name
)
949 # await self.disconnect_model(self.monitors[model_name])
951 self
.notify_callback(
955 "Removing charm {}".format(application_name
),
960 except Exception as e
:
961 print("Caught exception: {}".format(e
))
965 async def CreateNetworkService(self
, ns_uuid
):
966 """Create a new Juju model for the Network Service.
968 Creates a new Model in the Juju Controller.
970 :param str ns_uuid: A unique id representing an instaance of a
973 :returns: True if the model was created. Raises JujuError on failure.
975 if not self
.authenticated
:
978 models
= await self
.controller
.list_models()
979 if ns_uuid
not in models
:
981 await self
.get_model(ns_uuid
)
985 async def DestroyNetworkService(self
, ns_uuid
):
986 """Destroy a Network Service.
988 Destroy the Network Service and any deployed charms.
990 :param ns_uuid The unique id of the Network Service
992 :returns: True if the model was created. Raises JujuError on failure.
995 # Do not delete the default model. The default model was used by all
996 # Network Services, prior to the implementation of a model per NS.
997 if ns_uuid
.lower() == "default":
1000 if not self
.authenticated
:
1003 models
= await self
.controller
.list_models()
1004 if ns_uuid
in models
:
1005 model
= await self
.controller
.get_model(ns_uuid
)
1007 for application
in model
.applications
:
1008 app
= model
.applications
[application
]
1010 await self
.RemoveCharms(ns_uuid
, application
)
1012 self
.log
.debug("Unsubscribing Watcher for {}".format(application
))
1013 await self
.Unsubscribe(ns_uuid
, application
)
1015 self
.log
.debug("Waiting for application to terminate")
1018 await model
.block_until(
1020 unit
.workload_status
in ['terminated'] for unit
in app
.units
1024 except Exception as e
:
1025 self
.log
.debug("Timed out waiting for {} to terminate.".format(application
))
1027 for machine
in model
.machines
:
1029 self
.log
.debug("Destroying machine {}".format(machine
))
1030 await model
.machines
[machine
].destroy(force
=True)
1031 except JujuAPIError
as e
:
1032 if 'does not exist' in str(e
):
1033 # Our cached model may be stale, because the machine
1034 # has already been removed. It's safe to continue.
1037 self
.log
.debug("Caught exception: {}".format(e
))
1040 # Disconnect from the Model
1041 if ns_uuid
in self
.models
:
1042 self
.log
.debug("Disconnecting model {}".format(ns_uuid
))
1043 # await self.disconnect_model(self.models[ns_uuid])
1044 await self
.disconnect_model(ns_uuid
)
1047 self
.log
.debug("Destroying model {}".format(ns_uuid
))
1048 await self
.controller
.destroy_models(ns_uuid
)
1050 raise NetworkServiceDoesNotExist(
1051 "The Network Service '{}' does not exist".format(ns_uuid
)
1056 async def GetMetrics(self
, model_name
, application_name
):
1057 """Get the metrics collected by the VCA.
1059 :param model_name The name or unique id of the network service
1060 :param application_name The name of the application
1063 model
= await self
.get_model(model_name
)
1064 app
= await self
.get_application(model
, application_name
)
1066 metrics
= await app
.get_metrics()
1070 async def HasApplication(self
, model_name
, application_name
):
1071 model
= await self
.get_model(model_name
)
1072 app
= await self
.get_application(model
, application_name
)
1077 async def Subscribe(self
, ns_name
, application_name
, callback
, *callback_args
):
1078 """Subscribe to callbacks for an application.
1080 :param ns_name str: The name of the Network Service
1081 :param application_name str: The name of the application
1082 :param callback obj: The callback method
1083 :param callback_args list: The list of arguments to append to calls to
1086 self
.monitors
[ns_name
].AddApplication(
1092 async def Unsubscribe(self
, ns_name
, application_name
):
1093 """Unsubscribe to callbacks for an application.
1095 Unsubscribes the caller from notifications from a deployed application.
1097 :param ns_name str: The name of the Network Service
1098 :param application_name str: The name of the application
1100 self
.monitors
[ns_name
].RemoveApplication(
1104 # Non-public methods
1105 async def add_relation(self
, model_name
, relation1
, relation2
):
1107 Add a relation between two application endpoints.
1109 :param str model_name: The name or unique id of the network service
1110 :param str relation1: '<application>[:<relation_name>]'
1111 :param str relation2: '<application>[:<relation_name>]'
1114 if not self
.authenticated
:
1117 m
= await self
.get_model(model_name
)
1119 await m
.add_relation(relation1
, relation2
)
1120 except JujuAPIError
as e
:
1121 # If one of the applications in the relationship doesn't exist,
1122 # or the relation has already been added, let the operation fail
1124 if 'not found' in e
.message
:
1126 if 'already exists' in e
.message
:
1131 # async def apply_config(self, config, application):
1132 # """Apply a configuration to the application."""
1133 # print("JujuApi: Applying configuration to {}.".format(
1136 # return await self.set_config(application=application, config=config)
1138 def _get_config_from_dict(self
, config_primitive
, values
):
1139 """Transform the yang config primitive to dict.
1148 for primitive
in config_primitive
:
1149 if primitive
['name'] == 'config':
1150 # config = self._map_primitive_parameters()
1151 for parameter
in primitive
['parameter']:
1152 param
= str(parameter
['name'])
1153 if parameter
['value'] == "<rw_mgmt_ip>":
1154 config
[param
] = str(values
[parameter
['value']])
1156 config
[param
] = str(parameter
['value'])
1160 def _map_primitive_parameters(self
, parameters
, user_values
):
1162 for parameter
in parameters
:
1163 param
= str(parameter
['name'])
1164 value
= parameter
.get('value')
1166 # map parameters inside a < >; e.g. <rw_mgmt_ip>. with the provided user_values.
1167 # Must exist at user_values except if there is a default value
1168 if isinstance(value
, str) and value
.startswith("<") and value
.endswith(">"):
1169 if parameter
['value'][1:-1] in user_values
:
1170 value
= user_values
[parameter
['value'][1:-1]]
1171 elif 'default-value' in parameter
:
1172 value
= parameter
['default-value']
1174 raise KeyError("parameter {}='{}' not supplied ".format(param
, value
))
1176 # If there's no value, use the default-value (if set)
1177 if value
is None and 'default-value' in parameter
:
1178 value
= parameter
['default-value']
1180 # Typecast parameter value, if present
1181 paramtype
= "string"
1183 if 'data-type' in parameter
:
1184 paramtype
= str(parameter
['data-type']).lower()
1186 if paramtype
== "integer":
1188 elif paramtype
== "boolean":
1193 # If there's no data-type, assume the value is a string
1196 raise ValueError("parameter {}='{}' cannot be converted to type {}".format(param
, value
, paramtype
))
1198 params
[param
] = value
1201 def _get_config_from_yang(self
, config_primitive
, values
):
1202 """Transform the yang config primitive to dict."""
1204 for primitive
in config_primitive
.values():
1205 if primitive
['name'] == 'config':
1206 for parameter
in primitive
['parameter'].values():
1207 param
= str(parameter
['name'])
1208 if parameter
['value'] == "<rw_mgmt_ip>":
1209 config
[param
] = str(values
[parameter
['value']])
1211 config
[param
] = str(parameter
['value'])
1215 def FormatApplicationName(self
, *args
):
1217 Generate a Juju-compatible Application name
1219 :param args tuple: Positional arguments to be used to construct the
1223 - Only accepts characters a-z and non-consequitive dashes (-)
1224 - Application name should not exceed 50 characters
1228 FormatApplicationName("ping_pong_ns", "ping_vnf", "a")
1231 for c
in "-".join(list(args
)):
1233 c
= chr(97 + int(c
))
1234 elif not c
.isalpha():
1237 return re
.sub('-+', '-', appname
.lower())
1239 # def format_application_name(self, nsd_name, vnfr_name, member_vnf_index=0):
1240 # """Format the name of the application
1243 # - Only accepts characters a-z and non-consequitive dashes (-)
1244 # - Application name should not exceed 50 characters
1246 # name = "{}-{}-{}".format(nsd_name, vnfr_name, member_vnf_index)
1250 # c = chr(97 + int(c))
1251 # elif not c.isalpha():
1254 # return re.sub('\-+', '-', new_name.lower())
1256 def format_model_name(self
, name
):
1257 """Format the name of model.
1259 Model names may only contain lowercase letters, digits and hyphens
1262 return name
.replace('_', '-').lower()
1264 async def get_application(self
, model
, application
):
1265 """Get the deployed application."""
1266 if not self
.authenticated
:
1270 if application
and model
:
1271 if model
.applications
:
1272 if application
in model
.applications
:
1273 app
= model
.applications
[application
]
1277 async def get_model(self
, model_name
):
1278 """Get a model from the Juju Controller.
1280 Note: Model objects returned must call disconnected() before it goes
1282 if not self
.authenticated
:
1285 if model_name
not in self
.models
:
1286 # Get the models in the controller
1287 models
= await self
.controller
.list_models()
1289 if model_name
not in models
:
1291 self
.models
[model_name
] = await self
.controller
.add_model(
1293 config
={'authorized-keys': self
.juju_public_key
}
1296 except JujuError
as e
:
1297 if "already exists" not in e
.message
:
1300 self
.models
[model_name
] = await self
.controller
.get_model(
1304 self
.refcount
['model'] += 1
1306 # Create an observer for this model
1307 await self
.create_model_monitor(model_name
)
1309 return self
.models
[model_name
]
1311 async def create_model_monitor(self
, model_name
):
1312 """Create a monitor for the model, if none exists."""
1313 if not self
.authenticated
:
1316 if model_name
not in self
.monitors
:
1317 self
.monitors
[model_name
] = VCAMonitor(model_name
)
1318 self
.models
[model_name
].add_observer(self
.monitors
[model_name
])
1322 async def login(self
):
1323 """Login to the Juju controller."""
1325 if self
.authenticated
:
1328 self
.connecting
= True
1330 self
.log
.debug("JujuApi: Logging into controller")
1332 self
.controller
= Controller(loop
=self
.loop
)
1336 "Connecting to controller... ws://{} as {}/{}".format(
1343 await self
.controller
.connect(
1344 endpoint
=self
.endpoint
,
1346 password
=self
.secret
,
1347 cacert
=self
.ca_cert
,
1349 self
.refcount
['controller'] += 1
1350 self
.authenticated
= True
1351 self
.log
.debug("JujuApi: Logged into controller")
1352 except Exception as ex
:
1353 self
.log
.debug("Caught exception: {}".format(ex
))
1355 # current_controller no longer exists
1356 # self.log.debug("Connecting to current controller...")
1357 # await self.controller.connect_current()
1358 # await self.controller.connect(
1359 # endpoint=self.endpoint,
1360 # username=self.user,
1363 self
.log
.fatal("VCA credentials not configured.")
1364 self
.authenticated
= False
1367 async def logout(self
):
1368 """Logout of the Juju controller."""
1369 if not self
.authenticated
:
1373 for model
in self
.models
:
1374 await self
.disconnect_model(model
)
1377 self
.log
.debug("Disconnecting controller {}".format(
1380 await self
.controller
.disconnect()
1381 self
.refcount
['controller'] -= 1
1382 self
.controller
= None
1384 self
.authenticated
= False
1386 self
.log
.debug(self
.refcount
)
1388 except Exception as e
:
1390 "Fatal error logging out of Juju Controller: {}".format(e
)
1395 async def disconnect_model(self
, model
):
1396 self
.log
.debug("Disconnecting model {}".format(model
))
1397 if model
in self
.models
:
1399 await self
.models
[model
].disconnect()
1400 self
.refcount
['model'] -= 1
1401 self
.models
[model
] = None
1402 except Exception as e
:
1403 self
.log
.debug("Caught exception: {}".format(e
))
1405 async def provision_machine(self
, model_name
: str,
1406 hostname
: str, username
: str,
1407 private_key_path
: str) -> int:
1408 """Provision a machine.
1410 This executes the SSH provisioner, which will log in to a machine via
1411 SSH and prepare it for use with the Juju model
1413 :param model_name str: The name of the model
1414 :param hostname str: The IP or hostname of the target VM
1415 :param user str: The username to login to
1416 :param private_key_path str: The path to the private key that's been injected to the VM via cloud-init
1417 :return machine_id int: Returns the id of the machine or None if provisioning fails
1419 if not self
.authenticated
:
1425 self
.log
.debug("Instantiating SSH Provisioner for {}@{} ({})".format(
1430 provisioner
= SSHProvisioner(
1433 private_key_path
=private_key_path
,
1439 params
= provisioner
.provision_machine()
1440 except Exception as ex
:
1441 self
.log
.debug("caught exception from provision_machine: {}".format(ex
))
1445 params
.jobs
= ['JobHostUnits']
1447 model
= await self
.get_model(model_name
)
1449 connection
= model
.connection()
1451 # Submit the request.
1452 self
.log
.debug("Adding machine to model")
1453 client_facade
= client
.ClientFacade
.from_connection(connection
)
1454 results
= await client_facade
.AddMachines(params
=[params
])
1455 error
= results
.machines
[0].error
1457 raise ValueError("Error adding machine: %s" % error
.message
)
1459 machine_id
= results
.machines
[0].machine
1461 # Need to run this after AddMachines has been called,
1462 # as we need the machine_id
1463 self
.log
.debug("Installing Juju agent")
1464 await provisioner
.install_agent(
1471 self
.log
.debug("Missing API Proxy")
1474 # async def remove_application(self, name):
1475 # """Remove the application."""
1476 # if not self.authenticated:
1477 # await self.login()
1479 # app = await self.get_application(name)
1481 # self.log.debug("JujuApi: Destroying application {}".format(
1485 # await app.destroy()
1487 async def remove_relation(self
, a
, b
):
1489 Remove a relation between two application endpoints
1491 :param a An application endpoint
1492 :param b An application endpoint
1494 if not self
.authenticated
:
1497 m
= await self
.get_model()
1499 m
.remove_relation(a
, b
)
1501 await m
.disconnect()
1503 async def resolve_error(self
, model_name
, application
=None):
1504 """Resolve units in error state."""
1505 if not self
.authenticated
:
1508 model
= await self
.get_model(model_name
)
1510 app
= await self
.get_application(model
, application
)
1513 "JujuApi: Resolving errors for application {}".format(
1518 for unit
in app
.units
:
1519 app
.resolved(retry
=True)
1521 async def run_action(self
, model_name
, application
, action_name
, **params
):
1522 """Execute an action and return an Action object."""
1523 if not self
.authenticated
:
1533 model
= await self
.get_model(model_name
)
1535 app
= await self
.get_application(model
, application
)
1537 # We currently only have one unit per application
1538 # so use the first unit available.
1542 "JujuApi: Running Action {} against Application {}".format(
1548 action
= await unit
.run_action(action_name
, **params
)
1550 # Wait for the action to complete
1553 result
['status'] = action
.status
1554 result
['action']['tag'] = action
.data
['id']
1555 result
['action']['results'] = action
.results
1559 async def set_config(self
, model_name
, application
, config
):
1560 """Apply a configuration to the application."""
1561 if not self
.authenticated
:
1564 app
= await self
.get_application(model_name
, application
)
1566 self
.log
.debug("JujuApi: Setting config for Application {}".format(
1569 await app
.set_config(config
)
1571 # Verify the config is set
1572 newconf
= await app
.get_config()
1574 if config
[key
] != newconf
[key
]['value']:
1575 self
.log
.debug("JujuApi: Config not set! Key {} Value {} doesn't match {}".format(key
, config
[key
], newconf
[key
]))
1577 # async def set_parameter(self, parameter, value, application=None):
1578 # """Set a config parameter for a service."""
1579 # if not self.authenticated:
1580 # await self.login()
1582 # self.log.debug("JujuApi: Setting {}={} for Application {}".format(
1587 # return await self.apply_config(
1588 # {parameter: value},
1589 # application=application,
1592 async def wait_for_application(self
, model_name
, application_name
,
1594 """Wait for an application to become active."""
1595 if not self
.authenticated
:
1598 model
= await self
.get_model(model_name
)
1600 app
= await self
.get_application(model
, application_name
)
1601 self
.log
.debug("Application: {}".format(app
))
1604 "JujuApi: Waiting {} seconds for Application {}".format(
1610 await model
.block_until(
1612 unit
.agent_status
== 'idle' and unit
.workload_status
in
1613 ['active', 'unknown'] for unit
in app
.units