Docstrings, timeout, loop_sleep

Author: lexxai

src/cluster_tasks/controller_sync.py

@@ -22,15 +22,20 @@ def main():
     backend_name = scenarios_config.get("API.backend", "https")
     register_backends(backend_name)
     ext_api = ProxmoxAPI(backend_name=backend_name, backend_type="sync")
-    with ext_api as api:
-        node_tasks = NodeTasksSync(api=api)  # Pass the api instance to NodeTasksAsync
-        for v in scenarios_config.get("Scenarios").values():
-            scenario_file = v.get("file")
-            config = v.get("config")
-            # Create scenario instance using the factory
-            scenario = ScenarioFactory.create_scenario(scenario_file, config)
-            # Run the scenario
-            scenario.run(node_tasks)
+    try:
+        with ext_api as api:
+            node_tasks = NodeTasksSync(
+                api=api, timeout=120
+            )  # Pass the api instance to NodeTasksAsync
+            for v in scenarios_config.get("Scenarios").values():
+                scenario_file = v.get("file")
+                config = v.get("config")
+                # Create scenario instance using the factory
+                scenario = ScenarioFactory.create_scenario(scenario_file, config)
+                # Run the scenario
+                scenario.run(node_tasks)
+    except Exception as e:
+        logger.error(f"MAIN: {e}")
 
 
 if __name__ == "__main__":

src/cluster_tasks/tasks/base_tasks.py

@@ -1,24 +1,67 @@
 from datetime import timedelta
-
 from ext_api.proxmox_api import ProxmoxAPI
 
 
 class BaseTasks:
-    TIMEOUT = 60
-    LOOP_SLEEP = 2
+    """
+    BaseTasks class that provides common functionality for tasks interacting
+    with the Proxmox API. It manages timeouts, loop sleeps, and provides utility
+    methods for formatting durations.
+
+    Attributes:
+        timeout (int): The default timeout in seconds for tasks.
+        loop_sleep (int): The default sleep duration between task loops in seconds.
+        _api (ProxmoxAPI): The Proxmox API instance used for interacting with Proxmox.
+    """
+
+    timeout = 60
+    loop_sleep = 2
+
+    def __init__(
+        self, api: ProxmoxAPI, timeout: int = timeout, loop_sleep: int = loop_sleep
+    ):
+        """
+        Initializes the BaseTasks class with the given Proxmox API instance and optional
+        timeout and loop sleep values.
 
-    def __init__(self, api: ProxmoxAPI):
+        Args:
+            api (ProxmoxAPI): The Proxmox API instance for making API calls.
+            timeout (int, optional): The timeout value for tasks (default is 60).
+            loop_sleep (int, optional): The sleep time between loops in seconds (default is 2).
+        """
         self._api: ProxmoxAPI = api
+        self.timeout = timeout
+        self.loop_sleep = loop_sleep
 
     @property
     def api(self):
+        """
+        Gets the Proxmox API instance.
+
+        Returns:
+            ProxmoxAPI: The Proxmox API instance.
+        """
         return self._api
 
     @api.setter
     def api(self, value):
+        """
+        Sets a new Proxmox API instance.
+
+        Args:
+            value (ProxmoxAPI): The new Proxmox API instance to set.
+        """
         self._api = value
 
     @staticmethod
     def format_duration(seconds: float | int) -> str:
-        """Format a duration (in seconds) as HH:MM:SS."""
+        """
+        Formats a duration (in seconds) as a string in the format HH:MM:SS.
+
+        Args:
+            seconds (float or int): The duration in seconds to format.
+
+        Returns:
+            str: The formatted duration as HH:MM:SS.
+        """
         return str(timedelta(seconds=seconds)).split(".")[0]

src/cluster_tasks/tasks/node_tasks_base.py

@@ -53,12 +53,12 @@ def wait_task_done_sync(self, node: str, upid: str) -> bool:
                 return True
             duration = time.time() - start_time
             formatted_duration = self.format_duration(duration)
-            formatted_timeout = self.format_duration(self.TIMEOUT)
+            formatted_timeout = self.format_duration(self.timeout)
             logger.info(
                 f"Waiting for task to finish... [ {formatted_duration} / {formatted_timeout} ]"
             )
-            time.sleep(self.LOOP_SLEEP)
-            if time.time() - start_time > self.TIMEOUT:
+            time.sleep(self.loop_sleep)
+            if time.time() - start_time > self.timeout:
                 logger.warning(
                     f"Timeout reached while waiting for task to finish. {upid=}"
                 )
@@ -75,12 +75,12 @@ async def wait_task_done_async(self, node: str, upid: str) -> bool:
                 return True
             duration = time.time() - start_time
             formatted_duration = self.format_duration(duration)
-            formatted_timeout = self.format_duration(self.TIMEOUT)
+            formatted_timeout = self.format_duration(self.timeout)
             logger.info(
                 f"Waiting for task to finish... [ {formatted_duration} / {formatted_timeout} ]"
             )
-            await asyncio.sleep(self.LOOP_SLEEP)
-            if time.time() - start_time > self.TIMEOUT:
+            await asyncio.sleep(self.loop_sleep)
+            if time.time() - start_time > self.timeout:
                 logger.warning(
                     f"Timeout reached while waiting for task to finish. {upid=}"
                 )