X-Git-Url: https://osm.etsi.org/gitweb/?p=osm%2FN2VC.git;a=blobdiff_plain;f=n2vc%2Flibjuju.py;h=eb0fa72f45a33d1841d46387f61cce0882cdda97;hp=7a730335553392c5041706ce28e6303155bff94f;hb=561202994dc290e20a5f15ae8ffd07f20fb84069;hpb=b0a8f409e149715bf37d30c414474888c8a499f3 diff --git a/n2vc/libjuju.py b/n2vc/libjuju.py index 7a73033..eb0fa72 100644 --- a/n2vc/libjuju.py +++ b/n2vc/libjuju.py @@ -32,6 +32,7 @@ from juju.controller import Controller from juju.client import client from juju import tag +from n2vc.config import ModelConfig from n2vc.juju_watcher import JujuModelWatcher from n2vc.provisioner import AsyncSSHProvisioner from n2vc.n2vc_conn import N2VCConnector @@ -43,6 +44,7 @@ from n2vc.exceptions import ( JujuControllerFailedConnecting, JujuApplicationExists, JujuInvalidK8sConfiguration, + JujuError ) from n2vc.utils import DB_DATA from osm_common.dbbase import DbException @@ -63,8 +65,7 @@ class Libjuju: log: logging.Logger = None, db: dict = None, n2vc: N2VCConnector = None, - apt_mirror: str = None, - enable_os_upgrade: bool = True, + model_config: ModelConfig = {}, ): """ Constructor @@ -99,11 +100,7 @@ class Libjuju: self.n2vc = n2vc # Generate config for models - self.model_config = {} - if apt_mirror: - self.model_config["apt-mirror"] = apt_mirror - self.model_config["enable-os-refresh-update"] = enable_os_upgrade - self.model_config["enable-os-upgrade"] = enable_os_upgrade + self.model_config = model_config self.loop.set_exception_handler(self.handle_exception) self.creating_model = asyncio.Lock(loop=self.loop) @@ -205,6 +202,68 @@ class Libjuju: await self.disconnect_model(model) await self.disconnect_controller(controller) + async def get_executed_actions(self, model_name: str) -> list: + """ + Get executed/history of actions for a model. + + :param: model_name: Model name, str. + :return: List of executed actions for a model. + """ + model = None + executed_actions = [] + controller = await self.get_controller() + try: + model = await self.get_model(controller, model_name) + # Get all unique action names + actions = {} + for application in model.applications: + application_actions = await self.get_actions(application, model_name) + actions.update(application_actions) + # Get status of all actions + for application_action in actions: + app_action_status_list = await model.get_action_status(name=application_action) + for action_id, action_status in app_action_status_list.items(): + executed_action = {"id": action_id, "action": application_action, + "status": action_status} + # Get action output by id + action_status = await model.get_action_output(executed_action["id"]) + for k, v in action_status.items(): + executed_action[k] = v + executed_actions.append(executed_action) + except Exception as e: + raise JujuError("Error in getting executed actions for model: {}. Error: {}" + .format(model_name, str(e))) + finally: + if model: + await self.disconnect_model(model) + await self.disconnect_controller(controller) + return executed_actions + + async def get_application_configs(self, model_name: str, application_name: str) -> dict: + """ + Get available configs for an application. + + :param: model_name: Model name, str. + :param: application_name: Application name, str. + + :return: A dict which has key - action name, value - action description + """ + model = None + application_configs = {} + controller = await self.get_controller() + try: + model = await self.get_model(controller, model_name) + application = self._get_application(model, application_name=application_name) + application_configs = await application.get_config() + except Exception as e: + raise JujuError("Error in getting configs for application: {} in model: {}. Error: {}" + .format(application_name, model_name, str(e))) + finally: + if model: + await self.disconnect_model(model) + await self.disconnect_controller(controller) + return application_configs + async def get_model( self, controller: Controller, model_name: str, id=None ) -> Model: @@ -885,23 +944,59 @@ class Libjuju: finally: await self.disconnect_controller(controller) - async def destroy_application(self, model: Model, application_name: str): + async def destroy_application( + self, model_name: str, application_name: str, total_timeout: float + ): """ Destroy application - :param: model: Model object + :param: model_name: Model name :param: application_name: Application name + :param: total_timeout: Timeout """ - self.log.debug( - "Destroying application {} in model {}".format( - application_name, model.info.name + + controller = await self.get_controller() + model = None + + try: + model = await self.get_model(controller, model_name) + self.log.debug( + "Destroying application {} in model {}".format( + application_name, model_name + ) ) - ) - application = model.applications.get(application_name) - if application: - await application.destroy() - else: - self.log.warning("Application not found: {}".format(application_name)) + application = self._get_application(model, application_name) + if application: + await application.destroy() + else: + self.log.warning("Application not found: {}".format(application_name)) + + self.log.debug( + "Waiting for application {} to be destroyed in model {}...".format( + application_name, model_name + ) + ) + if total_timeout is None: + total_timeout = 3600 + end = time.time() + total_timeout + while time.time() < end: + if not self._get_application(model, application_name): + self.log.debug( + "The application {} was destroyed in model {} ".format( + application_name, model_name + ) + ) + return + await asyncio.sleep(5) + raise Exception( + "Timeout waiting for application {} to be destroyed in model {}".format( + application_name, model_name + ) + ) + finally: + if model is not None: + await self.disconnect_model(model) + await self.disconnect_controller(controller) async def _destroy_pending_machines(self, model: Model, only_manual: bool = False): """