import asyncio
import logging
-from juju.controller import Controller
-from juju.client import client
+
import time
from juju.errors import JujuAPIError
Cloud,
CloudCredential,
)
+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
JujuApplicationNotFound,
JujuLeaderUnitNotFound,
JujuActionNotFound,
- JujuModelAlreadyExists,
JujuControllerFailedConnecting,
JujuApplicationExists,
JujuInvalidK8sConfiguration,
+ JujuError
)
from n2vc.utils import DB_DATA
from osm_common.dbbase import DbException
from kubernetes.client.configuration import Configuration
+RBAC_LABEL_KEY_NAME = "rbac-id"
+
class Libjuju:
def __init__(
log: logging.Logger = None,
db: dict = None,
n2vc: N2VCConnector = None,
- apt_mirror: str = None,
- enable_os_upgrade: bool = True,
+ model_config: ModelConfig = {},
):
"""
Constructor
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)
- self.models = set()
self.log.debug("Libjuju initialized!")
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:
+ async def get_controller(self, timeout: float = 15.0) -> Controller:
"""
Get controller
controller = await self.get_controller()
model = None
try:
- # Raise exception if model already exists
- if await self.model_exists(model_name, controller=controller):
- raise JujuModelAlreadyExists(
- "Model {} already exists.".format(model_name)
- )
-
# Block until other workers have finished model creation
while self.creating_model.locked():
await asyncio.sleep(0.1)
- # If the model exists, return it from the controller
- if model_name in self.models:
- return
-
# Create the model
async with self.creating_model:
+ if await self.model_exists(model_name, controller=controller):
+ return
self.log.debug("Creating model {}".format(model_name))
model = await controller.add_model(
model_name,
cloud_name=cloud_name,
credential_name=credential_name or cloud_name,
)
- self.models.add(model_name)
finally:
if model:
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:
nonce=params.nonce,
machine_id=machine_id,
proxy=self.api_proxy,
+ series=params.series,
)
)
try:
# Get application
application = self._get_application(
- model, application_name=application_name,
+ model,
+ application_name=application_name,
)
if application is None:
raise JujuApplicationNotFound("Cannot execute action")
try:
# Get application
application = self._get_application(
- model, application_name=application_name,
+ model,
+ application_name=application_name,
)
# Return list of actions
return metrics
async def add_relation(
- self, model_name: str, endpoint_1: str, endpoint_2: str,
+ self,
+ model_name: str,
+ endpoint_1: str,
+ endpoint_2: str,
):
"""Add relation
await self.disconnect_controller(controller)
async def consume(
- self, offer_url: str, model_name: str,
+ self,
+ offer_url: str,
+ model_name: str,
):
"""
Adds a remote offer to the model. Relations can be created later using "juju relate".
"""
controller = await self.get_controller()
- model = await self.get_model(controller, model_name)
+ model = None
try:
+ if not await self.model_exists(model_name, controller=controller):
+ return
+
+ model = await self.get_model(controller, model_name)
self.log.debug("Destroying model {}".format(model_name))
uuid = model.info.uuid
# Disconnect model
await self.disconnect_model(model)
- # Destroy model
- if model_name in self.models:
- self.models.remove(model_name)
-
await controller.destroy_model(uuid, force=True, max_wait=0)
# Wait until model is destroyed
raise Exception(
"Timeout waiting for model {} to be destroyed".format(model_name)
)
+ except Exception as e:
+ if model:
+ await self.disconnect_model(model)
+ raise e
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):
"""
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
):
self.log.debug("Configuring application {}".format(application_name))
if config:
+ controller = await self.get_controller()
+ model = None
try:
- controller = await self.get_controller()
model = await self.get_model(controller, model_name)
application = self._get_application(
- model, application_name=application_name,
+ model,
+ application_name=application_name,
)
await application.set_config(config)
finally:
- await self.disconnect_model(model)
+ if model:
+ await self.disconnect_model(model)
await self.disconnect_controller(controller)
def _get_api_endpoints_db(self) -> [str]:
if not juju_info:
try:
self.db.create(
- DB_DATA.api_endpoints.table, DB_DATA.api_endpoints.filter,
+ DB_DATA.api_endpoints.table,
+ DB_DATA.api_endpoints.filter,
)
except DbException as e:
# Racing condition: check if another N2VC worker has created it
async def add_k8s(
self,
name: str,
+ rbac_id: str,
+ token: str,
+ client_cert_data: str,
configuration: Configuration,
storage_class: str,
credential_name: str = None,
raise Exception("configuration must be provided")
endpoint = configuration.host
- credential = self.get_k8s_cloud_credential(configuration)
- ca_certificates = (
- [credential.attrs["ClientCertificateData"]]
- if "ClientCertificateData" in credential.attrs
- else []
+ credential = self.get_k8s_cloud_credential(
+ configuration,
+ client_cert_data,
+ token,
)
+ credential.attrs[RBAC_LABEL_KEY_NAME] = rbac_id
cloud = client.Cloud(
type_="kubernetes",
auth_types=[credential.auth_type],
endpoint=endpoint,
- ca_certificates=ca_certificates,
+ ca_certificates=[client_cert_data],
config={
"operator-storage": storage_class,
"workload-storage": storage_class,
)
def get_k8s_cloud_credential(
- self, configuration: Configuration,
+ self,
+ configuration: Configuration,
+ client_cert_data: str,
+ token: str = None,
) -> client.CloudCredential:
attrs = {}
- ca_cert = configuration.ssl_ca_cert or configuration.cert_file
- key = configuration.key_file
- api_key = configuration.api_key
- token = None
+ # TODO: Test with AKS
+ key = None # open(configuration.key_file, "r").read()
username = configuration.username
password = configuration.password
- if "authorization" in api_key:
- authorization = api_key["authorization"]
- if "Bearer " in authorization:
- bearer_list = authorization.split(" ")
- if len(bearer_list) == 2:
- [_, token] = bearer_list
- else:
- raise JujuInvalidK8sConfiguration("unknown format of api_key")
- else:
- token = authorization
- if ca_cert:
- attrs["ClientCertificateData"] = open(ca_cert, "r").read()
+ if client_cert_data:
+ attrs["ClientCertificateData"] = client_cert_data
if key:
- attrs["ClientKeyData"] = open(key, "r").read()
+ attrs["ClientKeyData"] = key
if token:
if username or password:
raise JujuInvalidK8sConfiguration("Cannot set both token and user/pass")
auth_type = None
if key:
auth_type = "oauth2"
+ if client_cert_data:
+ auth_type = "oauth2withcert"
if not token:
raise JujuInvalidK8sConfiguration(
"missing token for auth type {}".format(auth_type)
)
attrs["username"] = username
attrs["password"] = password
- if ca_cert:
+ if client_cert_data:
auth_type = "userpasswithcert"
else:
auth_type = "userpass"
- elif ca_cert and token:
+ elif client_cert_data and token:
auth_type = "certificate"
else:
raise JujuInvalidK8sConfiguration("authentication method not supported")
unit = u
break
return unit
+
+ async def get_cloud_credentials(self, cloud_name: str, credential_name: str):
+ controller = await self.get_controller()
+ try:
+ facade = client.CloudFacade.from_connection(controller.connection())
+ cloud_cred_tag = tag.credential(cloud_name, self.username, credential_name)
+ params = [client.Entity(cloud_cred_tag)]
+ return (await facade.Credential(params)).results
+ finally:
+ await self.disconnect_controller(controller)
projects / osm / N2VC.git / blobdiff