import os
import os.path
import re
+import shlex
import ssl
+import subprocess
import sys
# import time
from juju.controller import Controller
from juju.model import ModelObserver
-
+from juju.errors import JujuAPIError
# We might need this to connect to the websocket securely, but test and verify.
try:
self.applications[application_name]['callback_args']
if old and new:
- old_status = old.workload_status
- new_status = new.workload_status
-
- if old_status == new_status:
- """The workload status may fluctuate around certain
- events, so wait until the status has stabilized before
- triggering the callback."""
- if callback:
- callback(
- self.ns_name,
- delta.data['application'],
- new_status,
- new.workload_status_message,
- *callback_args)
+ # Fire off a callback with the application state
+ if callback:
+ callback(
+ self.ns_name,
+ delta.data['application'],
+ new.workload_status,
+ new.workload_status_message,
+ *callback_args)
if old and not new:
# This is a charm being removed
self.connecting = False
self.authenticated = False
+ # For debugging
+ self.refcount = {
+ 'controller': 0,
+ 'model': 0,
+ }
+
self.models = {}
- self.default_model = None
# Model Observers
self.monitors = {}
return True
# Public methods
- async def CreateNetworkService(self, nsd):
- """Create a new model to encapsulate this network service.
+ async def Relate(self, model_name, vnfd):
+ """Create a relation between the charm-enabled VDUs in a VNF.
+
+ The Relation mapping has two parts: the id of the vdu owning the endpoint, and the name of the endpoint.
- Create a new model in the Juju controller to encapsulate the
- charms associated with a network service.
+ vdu:
+ ...
+ relation:
+ - provides: dataVM:db
+ requires: mgmtVM:app
- You can pass either the nsd record or the id of the network
- service, but this method will fail without one of them.
+ 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.
+
+ :param str ns_name: The name of the network service.
+ :param dict vnfd: The parsed yaml VNF descriptor.
"""
- if not self.authenticated:
- await self.login()
- # Ideally, we will create a unique model per network service.
- # This change will require all components, i.e., LCM and SO, to use
- # N2VC for 100% compatibility. If we adopt unique models for the LCM,
- # services deployed via LCM would't be manageable via SO and vice versa
+ # Currently, the call to Relate() is made automatically after the
+ # deployment of each charm; if the relation depends on a charm that
+ # hasn't been deployed yet, the call will fail silently. This will
+ # prevent an API breakage, with the intent of making this an explicitly
+ # required call in a more object-oriented refactor of the N2VC API.
+
+ configs = []
+ vnf_config = vnfd.get("vnf-configuration")
+ if vnf_config:
+ juju = vnf_config['juju']
+ if juju:
+ configs.append(vnf_config)
+
+ for vdu in vnfd['vdu']:
+ vdu_config = vdu.get('vdu-configuration')
+ if vdu_config:
+ juju = vdu_config['juju']
+ if juju:
+ configs.append(vdu_config)
+
+ def _get_application_name(name):
+ """Get the application name that's mapped to a vnf/vdu."""
+ vnf_member_index = 0
+ vnf_name = vnfd['name']
+
+ for vdu in vnfd.get('vdu'):
+ # Compare the named portion of the relation to the vdu's id
+ if vdu['id'] == name:
+ application_name = self.FormatApplicationName(
+ model_name,
+ vnf_name,
+ str(vnf_member_index),
+ )
+ return application_name
+ else:
+ vnf_member_index += 1
+
+ return None
- return self.default_model
+ # Loop through relations
+ for cfg in configs:
+ if 'juju' in cfg:
+ if 'relation' in juju:
+ for rel in juju['relation']:
+ try:
+
+ # get the application name for the provides
+ (name, endpoint) = rel['provides'].split(':')
+ application_name = _get_application_name(name)
+
+ provides = "{}:{}".format(
+ application_name,
+ endpoint
+ )
+
+ # get the application name for thr requires
+ (name, endpoint) = rel['requires'].split(':')
+ application_name = _get_application_name(name)
+
+ requires = "{}:{}".format(
+ application_name,
+ endpoint
+ )
+ self.log.debug("Relation: {} <-> {}".format(
+ provides,
+ requires
+ ))
+ await self.add_relation(
+ model_name,
+ provides,
+ requires,
+ )
+ except Exception as e:
+ self.log.debug("Exception: {}".format(e))
+
+ return
async def DeployCharms(self, model_name, application_name, vnfd,
charm_path, params={}, machine_spec={},
Deploy the charm(s) referenced in a VNF Descriptor.
- :param str model_name: The name of the network service.
+ :param str model_name: The name or unique id of the network service.
:param str application_name: The name of the application
:param dict vnfd: The name of the application
:param str charm_path: The path to the Juju charm
##########################################
# Get the model for this network service #
##########################################
- # TODO: In a point release, we will use a model per deployed network
- # service. In the meantime, we will always use the 'default' model.
- model_name = 'default'
model = await self.get_model(model_name)
########################################
########################################################
to = ""
if machine_spec.keys():
- # TODO: This needs to be tested.
- # if all(k in machine_spec for k in ['hostname', 'username']):
- # # Enlist the existing machine in Juju
- # machine = await self.model.add_machine(spec='ssh:%@%'.format(
- # specs['host'],
- # specs['user'],
- # ))
- # to = machine.id
- pass
+ if all(k in machine_spec for k in ['host', 'user']):
+ # Enlist an existing machine as a Juju unit
+ machine = await model.add_machine(spec='ssh:{}@{}:{}'.format(
+ machine_spec['user'],
+ machine_spec['host'],
+ self.GetPrivateKeyPath(),
+ ))
+ to = machine.id
#######################################
# Get the initial charm configuration #
if 'rw_mgmt_ip' in params:
rw_mgmt_ip = params['rw_mgmt_ip']
- # initial_config = {}
- # self.log.debug(type(params))
- # self.log.debug("Params: {}".format(params))
if 'initial-config-primitive' not in params:
params['initial-config-primitive'] = {}
{'<rw_mgmt_ip>': rw_mgmt_ip}
)
- self.log.debug("JujuApi: Deploying charm ({}) from {}".format(
+ self.log.debug("JujuApi: Deploying charm ({}/{}) from {}".format(
+ model_name,
application_name,
charm_path,
to=to,
series='xenial',
# Apply the initial 'config' primitive during deployment
config=initial_config,
- # TBD: Where to deploy the charm to.
- to=None,
+ # Where to deploy the charm to.
+ to=to,
)
+ # Map the vdu id<->app name,
+ #
+ await self.Relate(model_name, vnfd)
+
# #######################################
# # Execute initial config primitive(s) #
# #######################################
- await self.ExecuteInitialPrimitives(
+ uuids = await self.ExecuteInitialPrimitives(
model_name,
application_name,
params,
)
+ return uuids
# primitives = {}
#
if not self.authenticated:
await self.login()
- # FIXME: This is hard-coded until model-per-ns is added
- model_name = 'default'
-
model = await self.get_model(model_name)
results = await model.get_action_status(uuid)
if not self.authenticated:
await self.login()
- # FIXME: This is hard-coded until model-per-ns is added
- model_name = 'default'
-
model = await self.get_model(model_name)
results = await model.get_action_output(uuid, 60)
except Exception as e:
return results
+ # async def ProvisionMachine(self, model_name, hostname, username):
+ # """Provision machine for usage with Juju.
+ #
+ # Provisions a previously instantiated machine for use with Juju.
+ # """
+ # try:
+ # if not self.authenticated:
+ # await self.login()
+ #
+ # # FIXME: This is hard-coded until model-per-ns is added
+ # model_name = 'default'
+ #
+ # model = await self.get_model(model_name)
+ # model.add_machine(spec={})
+ #
+ # machine = await model.add_machine(spec='ssh:{}@{}:{}'.format(
+ # "ubuntu",
+ # host['address'],
+ # private_key_path,
+ # ))
+ # return machine.id
+ #
+ # except Exception as e:
+ # self.log.debug(
+ # "Caught exception while getting primitive status: {}".format(e)
+ # )
+ # raise N2VCPrimitiveExecutionFailed(e)
+
+ def GetPrivateKeyPath(self):
+ homedir = os.environ['HOME']
+ sshdir = "{}/.ssh".format(homedir)
+ private_key_path = "{}/id_n2vc_rsa".format(sshdir)
+ return private_key_path
+
+ async def GetPublicKey(self):
+ """Get the N2VC SSH public key.abs
+
+ Returns the SSH public key, to be injected into virtual machines to
+ be managed by the VCA.
+
+ The first time this is run, a ssh keypair will be created. The public
+ key is injected into a VM so that we can provision the machine with
+ Juju, after which Juju will communicate with the VM directly via the
+ juju agent.
+ """
+ public_key = ""
+
+ # Find the path to where we expect our key to live.
+ homedir = os.environ['HOME']
+ sshdir = "{}/.ssh".format(homedir)
+ if not os.path.exists(sshdir):
+ os.mkdir(sshdir)
+
+ private_key_path = "{}/id_n2vc_rsa".format(sshdir)
+ public_key_path = "{}.pub".format(private_key_path)
+
+ # If we don't have a key generated, generate it.
+ if not os.path.exists(private_key_path):
+ cmd = "ssh-keygen -t {} -b {} -N '' -f {}".format(
+ "rsa",
+ "4096",
+ private_key_path
+ )
+ subprocess.check_output(shlex.split(cmd))
+
+ # Read the public key
+ with open(public_key_path, "r") as f:
+ public_key = f.readline()
+
+ return public_key
+
async def ExecuteInitialPrimitives(self, model_name, application_name,
params, callback=None, *callback_args):
"""Execute multiple primitives.
Execute a primitive defined in the VNF descriptor.
- :param str model_name: The name of the network service.
+ :param str model_name: The name or unique id of the network service.
:param str application_name: The name of the application
:param str primitive: The name of the primitive to execute.
:param obj callback: A callback function to receive status changes.
if not self.authenticated:
await self.login()
- # FIXME: This is hard-coded until model-per-ns is added
- model_name = 'default'
-
model = await self.get_model(model_name)
if primitive == 'config':
)
await app.remove()
+ await self.disconnect_model(self.monitors[model_name])
+
# Notify the callback that this charm has been removed.
self.notify_callback(
model_name,
async def GetMetrics(self, model_name, application_name):
"""Get the metrics collected by the VCA.
- :param model_name The name of the model
+ :param model_name The name or unique id of the network service
:param application_name The name of the application
"""
metrics = {}
return metrics
+ async def HasApplication(self, model_name, application_name):
+ model = await self.get_model(model_name)
+ app = await self.get_application(model, application_name)
+ if app:
+ return True
+ return False
+
# Non-public methods
- async def add_relation(self, a, b, via=None):
+ async def add_relation(self, model_name, relation1, relation2):
"""
Add a relation between two application endpoints.
- :param a An application endpoint
- :param b An application endpoint
- :param via The egress subnet(s) for outbound traffic, e.g.,
- (192.168.0.0/16,10.0.0.0/8)
+ :param str model_name: The name or unique id of the network service
+ :param str relation1: '<application>[:<relation_name>]'
+ :param str relation2: '<application>[:<relation_name>]'
"""
+
if not self.authenticated:
await self.login()
- m = await self.get_model()
+ m = await self.get_model(model_name)
try:
- m.add_relation(a, b, via)
- finally:
- await m.disconnect()
+ await m.add_relation(relation1, relation2)
+ except JujuAPIError as e:
+ # If one of the applications in the relationship doesn't exist,
+ # or the relation has already been added, let the operation fail
+ # silently.
+ if 'not found' in e.message:
+ return
+ if 'already exists' in e.message:
+ return
+
+ raise e
# async def apply_config(self, config, application):
# """Apply a configuration to the application."""
params = {}
for parameter in parameters:
param = str(parameter['name'])
+ value = None
+
+ # If there's no value, use the default-value (if set)
+ if parameter['value'] is None and 'default-value' in parameter:
+ value = parameter['default-value']
# Typecast parameter value, if present
if 'data-type' in parameter:
paramtype = str(parameter['data-type']).lower()
- value = None
if paramtype == "integer":
value = int(parameter['value'])
value = bool(parameter['value'])
else:
value = str(parameter['value'])
+ else:
+ # If there's no data-type, assume the value is a string
+ value = str(parameter['value'])
if parameter['value'] == "<rw_mgmt_ip>":
params[param] = str(values[parameter['value']])
return config
- @staticmethod
def FormatApplicationName(self, *args):
"""
Generate a Juju-compatible Application name
FormatApplicationName("ping_pong_ns", "ping_vnf", "a")
"""
-
appname = ""
for c in "-".join(list(args)):
if c.isdigit():
return app
- async def get_model(self, model_name='default'):
+ async def get_model(self, model_name):
"""Get a model from the Juju Controller.
Note: Model objects returned must call disconnected() before it goes
await self.login()
if model_name not in self.models:
- self.models[model_name] = await self.controller.get_model(
- model_name,
- )
+ # Get the models in the controller
+ models = await self.controller.list_models()
+
+ if model_name not in models:
+ self.models[model_name] = await self.controller.add_model(
+ model_name
+ )
+ else:
+ self.models[model_name] = await self.controller.get_model(
+ model_name
+ )
+
+ self.refcount['model'] += 1
# Create an observer for this model
self.monitors[model_name] = VCAMonitor(model_name)
password=self.secret,
cacert=cacert,
)
+ self.refcount['controller'] += 1
else:
# current_controller no longer exists
# self.log.debug("Connecting to current controller...")
self.authenticated = True
self.log.debug("JujuApi: Logged into controller")
- # self.default_model = await self.controller.get_model("default")
-
async def logout(self):
"""Logout of the Juju controller."""
if not self.authenticated:
return
try:
- if self.default_model:
- self.log.debug("Disconnecting model {}".format(
- self.default_model
- ))
- await self.default_model.disconnect()
- self.default_model = None
-
for model in self.models:
- await self.models[model].disconnect()
- model = None
+ await self.disconnect_model(model)
if self.controller:
self.log.debug("Disconnecting controller {}".format(
self.controller
))
await self.controller.disconnect()
+ self.refcount['controller'] -= 1
self.controller = None
self.authenticated = False
+
+ self.log.debug(self.refcount)
+
except Exception as e:
self.log.fatal(
"Fatal error logging out of Juju Controller: {}".format(e)
)
raise e
+ async def disconnect_model(self, model):
+ self.log.debug("Disconnecting model {}".format(model))
+ if model in self.models:
+ print(self.models[model].applications)
+ if len(self.models[model].applications) == 0:
+ print("Destroying empty model")
+ await self.controller.destroy_models(model)
+
+ print("Disconnecting model")
+ await self.models[model].disconnect()
+ self.refcount['model'] -= 1
+ self.models[model] = None
+
# async def remove_application(self, name):
# """Remove the application."""
# if not self.authenticated:
finally:
await m.disconnect()
- async def resolve_error(self, application=None):
+ async def resolve_error(self, model_name, application=None):
"""Resolve units in error state."""
if not self.authenticated:
await self.login()
- app = await self.get_application(self.default_model, application)
+ model = await self.get_model(model_name)
+
+ app = await self.get_application(model, application)
if app:
self.log.debug(
"JujuApi: Resolving errors for application {}".format(
for unit in app.units:
app.resolved(retry=True)
- async def run_action(self, application, action_name, **params):
+ async def run_action(self, model_name, application, action_name, **params):
"""Execute an action and return an Action object."""
if not self.authenticated:
await self.login()
'results': None,
}
}
- app = await self.get_application(self.default_model, application)
+
+ model = await self.get_model(model_name)
+
+ app = await self.get_application(model, application)
if app:
# We currently only have one unit per application
# so use the first unit available.
if not self.authenticated:
await self.login()
- # TODO: In a point release, we will use a model per deployed network
- # service. In the meantime, we will always use the 'default' model.
- model_name = 'default'
model = await self.get_model(model_name)
app = await self.get_application(model, application_name)
self.log.debug("Application: {}".format(app))
- # app = await self.get_application(model_name, application_name)
if app:
self.log.debug(
"JujuApi: Waiting {} seconds for Application {}".format(
projects / osm / N2VC.git / blobdiff