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
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:
"""
: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):
"""
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,
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)
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
- ):
+ 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
:param: interval: Time in seconds between checks
"""
+ controller = None
while True:
try:
controller = await self.get_controller()
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,