Fix bug 1216: Remove machines only for native charms

[osm/N2VC.git] / n2vc / libjuju.py

diff --git a/n2vc/libjuju.py b/n2vc/libjuju.py
index be16e2a..d998475 100644 (file)
--- a/n2vc/libjuju.py
+++ b/n2vc/libjuju.py
@@ -29,6 +29,8 @@ from n2vc.n2vc_conn import N2VCConnector
 from n2vc.exceptions import (
     JujuMachineNotFound,
     JujuApplicationNotFound,
 from n2vc.exceptions import (
     JujuMachineNotFound,
     JujuApplicationNotFound,

+    JujuLeaderUnitNotFound,
+    JujuActionNotFound,

     JujuModelAlreadyExists,
     JujuControllerFailedConnecting,
     JujuApplicationExists,
     JujuModelAlreadyExists,
     JujuControllerFailedConnecting,
     JujuApplicationExists,


@@ -230,6 +232,30 @@ class Libjuju:
             if need_to_disconnect:
                 await self.disconnect_controller(controller)
 
             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
     async def get_model_status(self, model_name: str) -> FullStatus:
         """
         Get model status


@@ -298,7 +324,7 @@ class Libjuju:
                             machine_id, model_name
                         )
                     )
                             machine_id, model_name
                         )
                     )

-                    machine = model.machines[machine_id]
+                    machine = machines[machine_id]

                 else:
                     raise JujuMachineNotFound("Machine {} not found".format(machine_id))
 
                 else:
                     raise JujuMachineNotFound("Machine {} not found".format(machine_id))
 


@@ -406,7 +432,7 @@ class Libjuju:
                     connection=connection,
                     nonce=params.nonce,
                     machine_id=machine_id,
                     connection=connection,
                     nonce=params.nonce,
                     machine_id=machine_id,

-                    api=self.api_proxy,
+                    proxy=self.api_proxy,

                 )
             )
 
                 )
             )
 


@@ -570,7 +596,6 @@ class Libjuju:
 
         :param: application_name:   Application name
         :param: model_name:         Model name
 
         :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
         :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


@@ -601,12 +626,14 @@ class Libjuju:
                 if await u.is_leader_from_status():
                     unit = u
             if unit is None:
                 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:
 
             actions = await application.get_actions()
 
             if action_name not in actions:

-                raise Exception(
+                raise JujuActionNotFound(

                     "Action {} not in available actions".format(action_name)
                 )
 
                     "Action {} not in available actions".format(action_name)
                 )
 


@@ -637,8 +664,6 @@ class Libjuju:
                     action_name, action.status, application_name, model_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)
         finally:
             await self.disconnect_model(model)
             await self.disconnect_controller(controller)


@@ -740,18 +765,6 @@ class Libjuju:
             self.log.debug("Destroying model {}".format(model_name))
             uuid = model.info.uuid
 
             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)
 
             # Disconnect model
             await self.disconnect_model(model)
 


@@ -759,32 +772,24 @@ class Libjuju:
             if model_name in self.models:
                 self.models.remove(model_name)
 
             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))
 
             # 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:
 
             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(
                 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)
             )
         finally:
             await self.disconnect_controller(controller)


@@ -807,34 +812,32 @@ class Libjuju:
         else:
             self.log.warning("Application not found: {}".format(application_name))
 
         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
 
     async def configure_application(
         self, model_name: str, application_name: str, config: dict = None