}
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.
-
- Create a new model in the Juju controller to encapsulate the
- charms associated with a network service.
-
- You can pass either the nsd record or the id of the network
- service, but this method will fail without one of them.
- """
- 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
-
- return self.default_model
-
- async def Relate(self, ns_name, vnfd):
+ 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.
# Compare the named portion of the relation to the vdu's id
if vdu['id'] == name:
application_name = self.FormatApplicationName(
- ns_name,
+ model_name,
vnf_name,
str(vnf_member_index),
)
requires
))
await self.add_relation(
- ns_name,
+ model_name,
provides,
requires,
)
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)
########################################
{'<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,
# #######################################
# # 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:
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 = {}
"""
Add a relation between two application endpoints.
- :param str model_name Name of the network service.
- :param str relation1 '<application>[:<relation_name>]'
- :param str relation12 '<application>[:<relation_name>]'
+ :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:
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
return
try:
- if self.default_model:
- self.log.debug("Disconnecting model {}".format(
- self.default_model
- ))
- await self.default_model.disconnect()
- self.refcount['model'] -= 1
- self.default_model = None
-
for model in self.models:
- await self.models[model].disconnect()
- self.refcount['model'] -= 1
- self.models[model] = None
+ await self.disconnect_model(model)
if self.controller:
self.log.debug("Disconnecting controller {}".format(
)
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(