from n2vc.exceptions import (
JujuMachineNotFound,
JujuApplicationNotFound,
+ JujuLeaderUnitNotFound,
+ JujuActionNotFound,
JujuModelAlreadyExists,
JujuControllerFailedConnecting,
JujuApplicationExists,
+ JujuError
)
from n2vc.utils import DB_DATA
from osm_common.dbbase import DbException
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
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:
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
machine_id, model_name
)
)
- machine = model.machines[machine_id]
+ machine = machines[machine_id]
else:
raise JujuMachineNotFound("Machine {} not found".format(machine_id))
connection=connection,
nonce=params.nonce,
machine_id=machine_id,
- api=self.api_proxy,
+ proxy=self.api_proxy,
)
)
: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
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)
)
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)
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
-
# Disconnect model
await self.disconnect_model(model)
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)
else:
self.log.warning("Application not found: {}".format(application_name))
- 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 = model.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 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
projects / osm / N2VC.git / blobdiff