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
progress_timeout: float = None,
total_timeout: float = None,
series: str = "xenial",
+ wait: bool = True,
) -> (Machine, bool):
"""
Create machine
:param: db_dict: Dictionary with data of the DB to write the updates
:param: progress_timeout: Maximum time between two updates in the model
:param: total_timeout: Timeout for the entity to be active
+ :param: series: Series of the machine (xenial, bionic, focal, ...)
+ :param: wait: Wait until machine is ready
:return: (juju.machine.Machine, bool): Machine object and a boolean saying
if the machine is new or it already existed
machine_id, model_name
)
)
- machine = model.machines[machine_id]
+ machine = machines[machine_id]
else:
raise JujuMachineNotFound("Machine {} not found".format(machine_id))
machine.entity_id, model_name
)
)
- await JujuModelWatcher.wait_for(
- model=model,
- entity=machine,
- progress_timeout=progress_timeout,
- total_timeout=total_timeout,
- db_dict=db_dict,
- n2vc=self.n2vc,
- )
+ if wait:
+ await JujuModelWatcher.wait_for(
+ model=model,
+ entity=machine,
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout,
+ db_dict=db_dict,
+ n2vc=self.n2vc,
+ )
finally:
await self.disconnect_model(model)
await self.disconnect_controller(controller)
connection=connection,
nonce=params.nonce,
machine_id=machine_id,
- api=self.api_proxy,
+ proxy=self.api_proxy,
)
)
total_timeout: float = None,
config: dict = None,
series: str = None,
+ num_units: int = 1,
):
"""Deploy charm
:param: total_timeout: Timeout for the entity to be active
:param: config: Config for the charm
:param: series: Series of the charm
+ :param: num_units: Number of units
:return: (juju.application.Application): Juju application
"""
application_name, model_name
)
)
+ if num_units > 1:
+ for _ in range(num_units - 1):
+ m, _ = await self.create_machine(model_name, wait=False)
+ await application.add_unit(to=m.entity_id)
+
await JujuModelWatcher.wait_for(
model=model,
entity=application,
: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)
await self.disconnect_model(model)
await self.disconnect_controller(controller)
- async def destroy_model(
- self, model_name: str, total_timeout: float,
- ):
+ async def destroy_model(self, model_name: str, total_timeout: float):
"""
Destroy model
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:
- 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]
- # 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
- 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
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)