X-Git-Url: https://osm.etsi.org/gitweb/?p=osm%2FN2VC.git;a=blobdiff_plain;f=n2vc%2Flibjuju.py;h=d761adc6bbd48ae1e82d4d073ff68393631487c6;hp=b0e13588b4b5cf7bb7b0f1d23291d8a55ebc2da4;hb=85755d17a807df83d0e472e6e73500a4d743296b;hpb=f8a9d46e66f1222d7aefdf5a641e4490ef1a40b8;ds=sidebyside diff --git a/n2vc/libjuju.py b/n2vc/libjuju.py index b0e1358..d761adc 100644 --- a/n2vc/libjuju.py +++ b/n2vc/libjuju.py @@ -22,13 +22,20 @@ 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 from n2vc.exceptions import ( JujuMachineNotFound, JujuApplicationNotFound, + JujuLeaderUnitNotFound, + JujuActionNotFound, JujuModelAlreadyExists, JujuControllerFailedConnecting, JujuApplicationExists, @@ -70,7 +77,10 @@ class Libjuju: self.log = log or logging.getLogger("Libjuju") self.db = db - self.endpoints = self._get_api_endpoints_db() or [endpoint] + db_endpoints = self._get_api_endpoints_db() + self.endpoints = db_endpoints or [endpoint] + if db_endpoints is None: + self._update_api_endpoints_db(self.endpoints) self.api_proxy = api_proxy self.username = username self.password = password @@ -227,6 +237,30 @@ class Libjuju: if need_to_disconnect: await self.disconnect_controller(controller) + async def models_exist(self, model_names: [str]) -> (bool, list): + """ + Check if models exists + + :param: model_names: List of strings with model names + + :return (bool, list[str]): (True if all models exists, List of model names that don't exist) + """ + if not model_names: + raise Exception( + "model_names must be a non-empty array. Given value: {}".format( + model_names + ) + ) + non_existing_models = [] + models = await self.list_models() + existing_models = list(set(models).intersection(model_names)) + non_existing_models = list(set(model_names) - set(existing_models)) + + return ( + len(non_existing_models) == 0, + non_existing_models, + ) + async def get_model_status(self, model_name: str) -> FullStatus: """ Get model status @@ -295,7 +329,7 @@ class Libjuju: machine_id, model_name ) ) - machine = model.machines[machine_id] + machine = machines[machine_id] else: raise JujuMachineNotFound("Machine {} not found".format(machine_id)) @@ -403,7 +437,7 @@ class Libjuju: connection=connection, nonce=params.nonce, machine_id=machine_id, - api=self.api_proxy, + proxy=self.api_proxy, ) ) @@ -567,7 +601,6 @@ class Libjuju: :param: application_name: Application name :param: model_name: Model name - :param: cloud_name: Cloud name :param: action_name: Name of the action :param: db_dict: Dictionary with data of the DB to write the updates :param: progress_timeout: Maximum time between two updates in the model @@ -598,12 +631,14 @@ class Libjuju: if await u.is_leader_from_status(): unit = u if unit is None: - raise Exception("Cannot execute action: leader unit not found") + raise JujuLeaderUnitNotFound( + "Cannot execute action: leader unit not found" + ) actions = await application.get_actions() if action_name not in actions: - raise Exception( + raise JujuActionNotFound( "Action {} not in available actions".format(action_name) ) @@ -634,8 +669,6 @@ class Libjuju: action_name, action.status, application_name, model_name ) ) - except Exception as e: - raise e finally: await self.disconnect_model(model) await self.disconnect_controller(controller) @@ -678,24 +711,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() @@ -703,13 +750,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)) @@ -723,6 +766,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 @@ -737,19 +802,6 @@ class Libjuju: self.log.debug("Destroying model {}".format(model_name)) uuid = model.info.uuid - # Destroy applications - for application_name in model.applications: - try: - await self.destroy_application( - model, application_name=application_name, - ) - except Exception as e: - self.log.error( - "Error destroying application {} in model {}: {}".format( - application_name, model_name, e - ) - ) - # Destroy machines machines = await model.get_machines() for machine_id in machines: @@ -829,26 +881,18 @@ class Libjuju: """ machines = await model.get_machines() if machine_id in machines: - machine = model.machines[machine_id] - # TODO: change this by machine.is_manual when this is upstreamed: - # https://github.com/juju/python-libjuju/pull/396 - if "instance-id" in machine.safe_data and machine.safe_data[ - "instance-id" - ].startswith("manual:"): - await machine.destroy(force=True) - - # max timeout - end = time.time() + total_timeout - - # wait for machine removal + machine = machines[machine_id] + await machine.destroy(force=True) + # max timeout + end = time.time() + total_timeout + + # 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)) + await asyncio.sleep(0.5) 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) - ) - await asyncio.sleep(0.5) - machines = await model.get_machines() - self.log.debug("Machine destroyed: {}".format(machine_id)) + self.log.debug("Machine destroyed: {}".format(machine_id)) else: self.log.debug("Machine not found: {}".format(machine_id)) @@ -944,3 +988,122 @@ class Libjuju: finally: await self.disconnect_controller(controller) await asyncio.sleep(interval) + + async def list_models(self, contains: str = None) -> [str]: + """List models with certain names + + :param: contains: String that is contained in model name + + :retur: [models] Returns list of model names + """ + + controller = await self.get_controller() + try: + models = await controller.list_models() + if contains: + models = [model for model in models if contains in model] + 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, auth_data: dict, 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: auth_data: Dictionary with needed credentials. Format: + { + "server": "192.168.0.21:16443", + "cacert": "-----BEGIN CERTIFI...", + "token": "clhkRExRem5Xd1dCdnFEVXdvRGt...", + + } + :param: storage_class: Storage Class to use in the cloud + """ + + required_auth_data_keys = ["server", "cacert", "token"] + missing_keys = [] + for k in required_auth_data_keys: + if k not in auth_data: + missing_keys.append(k) + if missing_keys: + raise Exception( + "missing keys in auth_data: {}".format(",".join(missing_keys)) + ) + 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") + + endpoint = auth_data["server"] + cacert = auth_data["cacert"] + token = auth_data["token"] + region_name = "{}-region".format(name) + + cloud = client.Cloud( + auth_types=["certificate"], + ca_certificates=[cacert], + endpoint=endpoint, + config={ + "operator-storage": storage_class, + "workload-storage": storage_class, + }, + regions=[client.CloudRegion(endpoint=endpoint, name=region_name)], + type_="kubernetes", + ) + + cred = client.CloudCredential( + auth_type="certificate", + attrs={"ClientCertificateData": cacert, "Token": token}, + ) + return await self.add_cloud(name, cloud, cred) + + 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)