await self.login(cluster_uuid)
# We're creating a new cluster
- print("Getting model {}".format(self.get_namespace(cluster_uuid), cluster_uuid=cluster_uuid))
- model = await self.get_model(
- self.get_namespace(cluster_uuid),
- cluster_uuid=cluster_uuid
- )
+ #print("Getting model {}".format(self.get_namespace(cluster_uuid), cluster_uuid=cluster_uuid))
+ #model = await self.get_model(
+ # self.get_namespace(cluster_uuid),
+ # cluster_uuid=cluster_uuid
+ #)
- # Disconnect from the model
- if model and model.is_connected():
- await model.disconnect()
+ ## Disconnect from the model
+ #if model and model.is_connected():
+ # await model.disconnect()
return cluster_uuid, True
):
raise NotImplemented()
+ async def synchronize_repos(
+ self,
+ cluster_uuid: str,
+ name: str
+ ):
+ """
+ Returns None as currently add_repo is not implemented
+ """
+ return None
+
"""Reset"""
async def reset(
self,
# Disconnect from the controller
print("[reset] Disconnecting controller")
- await self.controller.disconnect()
+ await self.logout()
# Destroy the controller (via CLI)
print("[reset] Destroying controller")
await self.destroy_controller(cluster_uuid)
print("[reset] Removing k8s cloud")
- namespace = self.get_namespace(cluster_uuid)
- k8s_cloud = "{}-k8s".format(namespace)
+ k8s_cloud = "k8s-{}".format(cluster_uuid)
await self.remove_cloud(k8s_cloud)
except Exception as ex:
print("Caught exception during reset: {}".format(ex))
+ return True
+
"""Deployment"""
async def install(
atomic: bool = True,
timeout: float = 300,
params: dict = None,
- db_dict: dict = None
+ db_dict: dict = None,
+ kdu_name: str = None
) -> bool:
"""Install a bundle
:param timeout int: The time, in seconds, to wait for the install
to finish
:param params dict: Key-value pairs of instantiation parameters
+ :param kdu_name: Name of the KDU instance to be installed
:return: If successful, returns ?
"""
##
# Get or create the model, based on the NS
# uuid.
- model_name = db_dict["filter"]["_id"]
+ if kdu_name:
+ kdu_instance = "{}-{}".format(kdu_name, db_dict["filter"]["_id"])
+ else:
+ kdu_instance = db_dict["filter"]["_id"]
- self.log.debug("Checking for model named {}".format(model_name))
- model = await self.get_model(model_name, cluster_uuid=cluster_uuid)
- if not model:
- # Create the new model
- self.log.debug("Adding model: {}".format(model_name))
- model = await self.add_model(model_name, cluster_uuid=cluster_uuid)
+ self.log.debug("Checking for model named {}".format(kdu_instance))
+
+ # Create the new model
+ self.log.debug("Adding model: {}".format(kdu_instance))
+ model = await self.add_model(kdu_instance, cluster_uuid=cluster_uuid)
if model:
# TODO: Instantiation parameters
print("[install] Disconnecting model")
await model.disconnect()
- return True
+ return kdu_instance
raise Exception("Unable to install")
async def instances_list(
async def uninstall(
self,
cluster_uuid: str,
- kdu_instance: str,
+ kdu_instance: str
) -> bool:
"""Uninstall a KDU instance
- :param cluster_uuid str: The UUID of the cluster to uninstall
+ :param cluster_uuid str: The UUID of the cluster
:param kdu_instance str: The unique name of the KDU instance
:return: Returns True if successful, or raises an exception
"""
- removed = False
-
- # Remove an application from the model
- model = await self.get_model(self.get_namespace(cluster_uuid), cluster_uuid=cluster_uuid)
-
- if model:
- # Get the application
- if kdu_instance not in model.applications:
- # TODO: Raise a named exception
- raise Exception("Application not found.")
+ if not self.authenticated:
+ self.log.debug("[uninstall] Connecting to controller")
+ await self.login(cluster_uuid)
- application = model.applications[kdu_instance]
+ self.log.debug("[uninstall] Destroying model")
- # Destroy the application
- await application.destroy()
+ await self.controller.destroy_models(kdu_instance)
- # TODO: Verify removal
+ self.log.debug("[uninstall] Model destroyed and disconnecting")
+ await self.logout()
- removed = True
- return removed
+ return True
"""Introspection"""
async def inspect_kdu(
await self.login(cluster_uuid)
self.log.debug("Adding model '{}' to cluster_uuid '{}'".format(model_name, cluster_uuid))
- model = await self.controller.add_model(
- model_name,
- config={'authorized-keys': self.juju_public_key}
- )
+ try:
+ model = await self.controller.add_model(
+ model_name,
+ config={'authorized-keys': self.juju_public_key}
+ )
+ except Exception as ex:
+ self.log.debug(ex)
+ self.log.debug("Caught exception: {}".format(ex))
+ pass
+
return model
async def bootstrap(