X-Git-Url: https://osm.etsi.org/gitweb/?p=osm%2FN2VC.git;a=blobdiff_plain;f=n2vc%2Flibjuju.py;h=d2c725fa944d7f9ce4d2f3cc6f45dfbf8087762b;hp=2f1883796e56178ebf68cabb45e951a306b64bf5;hb=475a7221e3598ad1c75ce802c5ad74ef7ecf72f1;hpb=42f328a34a3ec7c066350de81e1331632a3fee92 diff --git a/n2vc/libjuju.py b/n2vc/libjuju.py index 2f18837..d2c725f 100644 --- a/n2vc/libjuju.py +++ b/n2vc/libjuju.py @@ -22,7 +22,12 @@ from juju.errors import JujuAPIError from juju.model import Model from juju.machine import Machine from juju.application import Application -from juju.client._definitions import FullStatus +from juju.client._definitions import ( + FullStatus, + QueryApplicationOffersResults, + Cloud, + CloudCredential, +) from n2vc.juju_watcher import JujuModelWatcher from n2vc.provisioner import AsyncSSHProvisioner from n2vc.n2vc_conn import N2VCConnector @@ -34,9 +39,11 @@ from n2vc.exceptions import ( JujuModelAlreadyExists, JujuControllerFailedConnecting, JujuApplicationExists, + JujuInvalidK8sConfiguration, ) from n2vc.utils import DB_DATA from osm_common.dbbase import DbException +from kubernetes.client.configuration import Configuration class Libjuju: @@ -242,7 +249,9 @@ class Libjuju: """ if not model_names: raise Exception( - "model_names must be a non-empty array. Given value: {}".format(model_names) + "model_names must be a non-empty array. Given value: {}".format( + model_names + ) ) non_existing_models = [] models = await self.list_models() @@ -624,7 +633,9 @@ class Libjuju: if await u.is_leader_from_status(): unit = u if unit is None: - raise JujuLeaderUnitNotFound("Cannot execute action: leader unit not found") + raise JujuLeaderUnitNotFound( + "Cannot execute action: leader unit not found" + ) actions = await application.get_actions() @@ -702,24 +713,38 @@ class Libjuju: await self.disconnect_model(model) await self.disconnect_controller(controller) + async def get_metrics(self, model_name: str, application_name: str) -> dict: + """Get the metrics collected by the VCA. + + :param model_name The name or unique id of the network service + :param application_name The name of the application + """ + if not model_name or not application_name: + raise Exception("model_name and application_name must be non-empty strings") + metrics = {} + controller = await self.get_controller() + model = await self.get_model(controller, model_name) + try: + application = self._get_application(model, application_name) + if application is not None: + metrics = await application.get_metrics() + finally: + self.disconnect_model(model) + self.disconnect_controller(controller) + return metrics + async def add_relation( - self, - model_name: str, - application_name_1: str, - application_name_2: str, - relation_1: str, - relation_2: str, + self, model_name: str, endpoint_1: str, endpoint_2: str, ): """Add relation - :param: model_name: Model name - :param: application_name_1 First application name - :param: application_name_2: Second application name - :param: relation_1: First relation name - :param: relation_2: Second relation name + :param: model_name: Model name + :param: endpoint_1 First endpoint name + ("app:endpoint" format or directly the saas name) + :param: endpoint_2: Second endpoint name (^ same format) """ - self.log.debug("Adding relation: {} -> {}".format(relation_1, relation_2)) + self.log.debug("Adding relation: {} -> {}".format(endpoint_1, endpoint_2)) # Get controller controller = await self.get_controller() @@ -727,13 +752,9 @@ class Libjuju: # Get model model = await self.get_model(controller, model_name) - # Build relation strings - r1 = "{}:{}".format(application_name_1, relation_1) - r2 = "{}:{}".format(application_name_2, relation_2) - # Add relation try: - await model.add_relation(relation1=r1, relation2=r2) + await model.add_relation(endpoint_1, endpoint_2) except JujuAPIError as e: if "not found" in e.message: self.log.warning("Relation not found: {}".format(e.message)) @@ -747,6 +768,28 @@ class Libjuju: await self.disconnect_model(model) await self.disconnect_controller(controller) + async def consume( + self, offer_url: str, model_name: str, + ): + """ + Adds a remote offer to the model. Relations can be created later using "juju relate". + + :param: offer_url: Offer Url + :param: model_name: Model name + + :raises ParseError if there's a problem parsing the offer_url + :raises JujuError if remote offer includes and endpoint + :raises JujuAPIError if the operation is not successful + """ + controller = await self.get_controller() + model = await controller.get_model(model_name) + + try: + await model.consume(offer_url) + finally: + await self.disconnect_model(model) + await self.disconnect_controller(controller) + async def destroy_model(self, model_name: str, total_timeout: float): """ Destroy model @@ -848,9 +891,7 @@ class Libjuju: # wait for machine removal machines = await model.get_machines() while machine_id in machines and time.time() < end: - self.log.debug( - "Waiting for machine {} is destroyed".format(machine_id) - ) + self.log.debug("Waiting for machine {} is destroyed".format(machine_id)) await asyncio.sleep(0.5) machines = await model.get_machines() self.log.debug("Machine destroyed: {}".format(machine_id)) @@ -966,3 +1007,145 @@ class Libjuju: return models finally: await self.disconnect_controller(controller) + + async def list_offers(self, model_name: str) -> QueryApplicationOffersResults: + """List models with certain names + + :param: model_name: Model name + + :return: Returns list of offers + """ + + controller = await self.get_controller() + try: + return await controller.list_offers(model_name) + finally: + await self.disconnect_controller(controller) + + async def add_k8s( + self, name: str, configuration: Configuration, storage_class: str + ): + """ + Add a Kubernetes cloud to the controller + + Similar to the `juju add-k8s` command in the CLI + + :param: name: Name for the K8s cloud + :param: configuration: Kubernetes configuration object + :param: storage_class: Storage Class to use in the cloud + """ + + if not storage_class: + raise Exception("storage_class must be a non-empty string") + if not name: + raise Exception("name must be a non-empty string") + if not configuration: + raise Exception("configuration must be provided") + + endpoint = configuration.host + credential = self.get_k8s_cloud_credential(configuration) + ca_certificates = ( + [credential.attrs["ClientCertificateData"]] + if "ClientCertificateData" in credential.attrs + else [] + ) + cloud = client.Cloud( + type_="kubernetes", + auth_types=[credential.auth_type], + endpoint=endpoint, + ca_certificates=ca_certificates, + config={ + "operator-storage": storage_class, + "workload-storage": storage_class, + }, + ) + + return await self.add_cloud(name, cloud, credential) + + def get_k8s_cloud_credential( + self, configuration: Configuration, + ) -> client.CloudCredential: + attrs = {} + ca_cert = configuration.ssl_ca_cert or configuration.cert_file + key = configuration.key_file + api_key = configuration.api_key + token = None + username = configuration.username + password = configuration.password + + if "authorization" in api_key: + authorization = api_key["authorization"] + if "Bearer " in authorization: + bearer_list = authorization.split(" ") + if len(bearer_list) == 2: + [_, token] = bearer_list + else: + raise JujuInvalidK8sConfiguration("unknown format of api_key") + else: + token = authorization + if ca_cert: + attrs["ClientCertificateData"] = open(ca_cert, "r").read() + if key: + attrs["ClientKeyData"] = open(key, "r").read() + if token: + if username or password: + raise JujuInvalidK8sConfiguration("Cannot set both token and user/pass") + attrs["Token"] = token + + auth_type = None + if key: + auth_type = "oauth2" + if not token: + raise JujuInvalidK8sConfiguration( + "missing token for auth type {}".format(auth_type) + ) + elif username: + if not password: + self.log.debug( + "credential for user {} has empty password".format(username) + ) + attrs["username"] = username + attrs["password"] = password + if ca_cert: + auth_type = "userpasswithcert" + else: + auth_type = "userpass" + elif ca_cert and token: + auth_type = "certificate" + else: + raise JujuInvalidK8sConfiguration("authentication method not supported") + return client.CloudCredential(auth_type=auth_type, attrs=attrs,) + + async def add_cloud( + self, name: str, cloud: Cloud, credential: CloudCredential = None + ) -> Cloud: + """ + Add cloud to the controller + + :param: name: Name of the cloud to be added + :param: cloud: Cloud object + :param: credential: CloudCredentials object for the cloud + """ + controller = await self.get_controller() + try: + _ = await controller.add_cloud(name, cloud) + if credential: + await controller.add_credential(name, credential=credential, cloud=name) + # Need to return the object returned by the controller.add_cloud() function + # I'm returning the original value now until this bug is fixed: + # https://github.com/juju/python-libjuju/issues/443 + return cloud + finally: + await self.disconnect_controller(controller) + + async def remove_cloud(self, name: str): + """ + Remove cloud + + :param: name: Name of the cloud to be removed + """ + controller = await self.get_controller() + try: + await controller.remove_cloud(name) + finally: + await self.disconnect_controller(controller)