X-Git-Url: https://osm.etsi.org/gitweb/?p=osm%2FN2VC.git;a=blobdiff_plain;f=n2vc%2Flibjuju.py;h=aa7afa10ea2938940a5d70906c17efeeb61a3b23;hp=28474a082bd4767f5a897f8d44bc8dbe9f4b6508;hb=667696ef11356f3267df58f2a81c6ecebb0e94b9;hpb=59f520da90fb12b9d9871889dfbc5d57aa14c591 diff --git a/n2vc/libjuju.py b/n2vc/libjuju.py index 28474a0..aa7afa1 100644 --- a/n2vc/libjuju.py +++ b/n2vc/libjuju.py @@ -81,9 +81,12 @@ class Libjuju: self.log = log or logging.getLogger("Libjuju") self.db = db db_endpoints = self._get_api_endpoints_db() - self.endpoints = db_endpoints or [endpoint] - if db_endpoints is None: + self.endpoints = None + if (db_endpoints and endpoint not in db_endpoints) or not db_endpoints: + self.endpoints = [endpoint] self._update_api_endpoints_db(self.endpoints) + else: + self.endpoints = db_endpoints self.api_proxy = api_proxy self.username = username self.password = password @@ -104,7 +107,10 @@ class Libjuju: self.models = set() self.log.debug("Libjuju initialized!") - self.health_check_task = self.loop.create_task(self.health_check()) + self.health_check_task = self._create_health_check_task() + + def _create_health_check_task(self): + return self.loop.create_task(self.health_check()) async def get_controller(self, timeout: float = 5.0) -> Controller: """ @@ -159,7 +165,8 @@ class Libjuju: :param: controller: Controller that will be disconnected """ - await controller.disconnect() + if controller: + await controller.disconnect() async def add_model(self, model_name: str, cloud_name: str, credential_name=None): """ @@ -485,6 +492,28 @@ class Libjuju: return machine_id + async def deploy( + self, uri: str, model_name: str, wait: bool = True, timeout: float = 3600 + ): + """ + Deploy bundle or charm: Similar to the juju CLI command `juju deploy` + + :param: uri: Path or Charm Store uri in which the charm or bundle can be found + :param: model_name: Model name + :param: wait: Indicates whether to wait or not until all applications are active + :param: timeout: Time in seconds to wait until all applications are active + """ + controller = await self.get_controller() + model = await self.get_model(controller, model_name) + try: + await model.deploy(uri) + if wait: + await JujuModelWatcher.wait_for_model(model, timeout=timeout) + self.log.debug("All units active in model {}".format(model_name)) + finally: + await self.disconnect_model(model) + await self.disconnect_controller(controller) + async def deploy_charm( self, application_name: str, @@ -817,17 +846,9 @@ class Libjuju: self.log.debug("Destroying model {}".format(model_name)) uuid = model.info.uuid - # Destroy machines - machines = await model.get_machines() - for machine_id in machines: - try: - await self.destroy_machine( - model, machine_id=machine_id, total_timeout=total_timeout, - ) - except asyncio.CancelledError: - raise - except Exception: - pass + # Destroy machines that are manually provisioned + # and still are in pending state + await self._destroy_pending_machines(model, only_manual=True) # Disconnect model await self.disconnect_model(model) @@ -836,32 +857,24 @@ class Libjuju: if model_name in self.models: self.models.remove(model_name) - await controller.destroy_model(uuid) + await controller.destroy_model(uuid, force=True, max_wait=0) # Wait until model is destroyed self.log.debug("Waiting for model {} to be destroyed...".format(model_name)) - last_exception = "" if total_timeout is None: total_timeout = 3600 end = time.time() + total_timeout while time.time() < end: - try: - models = await controller.list_models() - if model_name not in models: - self.log.debug( - "The model {} ({}) was destroyed".format(model_name, uuid) - ) - return - except asyncio.CancelledError: - raise - except Exception as e: - last_exception = e + models = await controller.list_models() + if model_name not in models: + self.log.debug( + "The model {} ({}) was destroyed".format(model_name, uuid) + ) + return await asyncio.sleep(5) raise Exception( - "Timeout waiting for model {} to be destroyed {}".format( - model_name, last_exception - ) + "Timeout waiting for model {} to be destroyed".format(model_name) ) finally: await self.disconnect_controller(controller) @@ -884,32 +897,49 @@ class Libjuju: else: self.log.warning("Application not found: {}".format(application_name)) - async def destroy_machine( - self, model: Model, machine_id: str, total_timeout: float = 3600 - ): + async def _destroy_pending_machines(self, model: Model, only_manual: bool = False): """ - Destroy machine + Destroy pending machines in a given model - :param: model: Model object - :param: machine_id: Machine id - :param: total_timeout: Timeout in seconds + :param: only_manual: Bool that indicates only manually provisioned + machines should be destroyed (if True), or that + all pending machines should be destroyed """ - machines = await model.get_machines() - if machine_id in machines: - 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() - self.log.debug("Machine destroyed: {}".format(machine_id)) - else: - self.log.debug("Machine not found: {}".format(machine_id)) + status = await model.get_status() + for machine_id in status.machines: + machine_status = status.machines[machine_id] + if machine_status.agent_status.status == "pending": + if only_manual and not machine_status.instance_id.startswith("manual:"): + break + machine = model.machines[machine_id] + await machine.destroy(force=True) + + # async def destroy_machine( + # self, model: Model, machine_id: str, total_timeout: float = 3600 + # ): + # """ + # Destroy machine + + # :param: model: Model object + # :param: machine_id: Machine id + # :param: total_timeout: Timeout in seconds + # """ + # machines = await model.get_machines() + # if machine_id in machines: + # 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() + # self.log.debug("Machine destroyed: {}".format(machine_id)) + # else: + # self.log.debug("Machine not found: {}".format(machine_id)) async def configure_application( self, model_name: str, application_name: str, config: dict = None @@ -994,6 +1024,7 @@ class Libjuju: :param: interval: Time in seconds between checks """ + controller = None while True: try: controller = await self.get_controller() @@ -1134,7 +1165,7 @@ class Libjuju: auth_type = "certificate" else: raise JujuInvalidK8sConfiguration("authentication method not supported") - return client.CloudCredential(auth_type=auth_type, attrs=attrs,) + return client.CloudCredential(auth_type=auth_type, attrs=attrs) async def add_cloud( self,