fix: add status command through load modules, probably should add an own status-mode?

Signed-off-by: Boekhorst <[email protected]>

Author: boekhorstb1

src/rookify/__main__.py

@@ -116,9 +116,9 @@ def read_pickle_file(
     )
 
 
-def show_progress_from_pickle_file(
+def show_progress_from_state(
     args: argparse.Namespace, pickle_file_name: str, log: BindableLogger
-) -> None:
+) -> bool:
     # states_data = load_pickler(pickle_file_name)
     modules = get_all_modules()
 
@@ -127,9 +127,12 @@ def show_progress_from_pickle_file(
         module = args.show_progress
         if args.show_progress not in modules:
             log.error(f"The module {module} does not exist")
+            return False
         log.info("Show progress of the {0} module".format(args.show_progress))
+        return True
     else:
         log.info("Show progress of {0} modules".format(args.show_progress))
+        return True
 
 
 def main() -> None:
@@ -182,24 +185,18 @@ def main() -> None:
         )
         return
 
-    # If show_progress is run and there is a picklefile, show progress status based on picklefile contents
-    # NOTE: this is always run in preflight-mode (migration shoudl not be executed)
-    if args.show_progress is not None and pickle_file_name is not None:
-        show_progress_from_pickle_file(args, pickle_file_name, log)
-        return
-
-    # TODO: should progress be checkable if no pickle file is present? Should rookify check the status by analyzing the source and traget machines state?
-    elif args.show_progress is not None and pickle_file_name is None:
-        log.info(
-            "Currently rookify can only check the state of progress by analyzing the pickle file states."
-        )
-        return
-
-    # Else run the rook migration
     else:
-        log.debug("Executing Rookify")
-
         machine = Machine(config["general"].get("machine_pickle_file"))
-        load_modules(machine, config)
 
-        machine.execute(dry_run_mode=args.dry_run_mode)
+        if args.show_progress is not None:
+            if show_progress_from_state(args, pickle_file_name, log) is True:
+                load_modules(machine, config, show_progress=True)
+                # NOTE: this is always run in preflight-mode (migration should not be executed)
+                machine.execute(dry_run_mode=True)
+                return
+            else:
+                return
+        else:
+            load_modules(machine, config)
+            log.debug("Executing Rookify")
+            machine.execute(dry_run_mode=args.dry_run_mode)

src/rookify/modules/__init__.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 import importlib
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 from ..logger import get_logger
 from .machine import Machine
 
@@ -22,7 +22,12 @@ def __init__(self, module_name: str, message: str):
         self.message = message
 
 
-def _load_module(machine: Machine, config: Dict[str, Any], module_name: str) -> None:
+def _load_module(
+    machine: Machine,
+    config: Dict[str, Any],
+    module_name: str,
+    show_progress: Optional[bool] = False,
+) -> None:
     """
     Dynamically loads a module from the 'rookify.modules' package.
 
@@ -43,12 +48,14 @@ def _load_module(machine: Machine, config: Dict[str, Any], module_name: str) ->
         additional_modules = module.ModuleHandler.REQUIRES
 
     for module_name in additional_modules:
-        _load_module(machine, config, module_name)
+        _load_module(machine, config, module_name, show_progress)
 
-    module.ModuleHandler.register_states(machine, config)
+    module.ModuleHandler.register_states(machine, config, show_progress)
 
 
-def load_modules(machine: Machine, config: Dict[str, Any]) -> None:
+def load_modules(
+    machine: Machine, config: Dict[str, Any], show_progress: Optional[bool] = False
+) -> None:
     """
     Dynamically loads modules from the 'modules' package.
 
@@ -61,7 +68,7 @@ def load_modules(machine: Machine, config: Dict[str, Any]) -> None:
     for entry in importlib.resources.files("rookify.modules").iterdir():
         if entry.is_dir() and entry.name in config["migration_modules"]:
             migration_modules.remove(entry.name)
-            _load_module(machine, config, entry.name)
+            _load_module(machine, config, entry.name, show_progress)
 
     if len(migration_modules) > 0 or len(config["migration_modules"]) < 1:
         logger = get_logger()

src/rookify/modules/analyze_ceph/main.py

@@ -55,7 +55,9 @@ def status(self) -> Any:
             self.logger.info("AnalyzeCephHandler has already been run.")
             self.logger.info("Current state data: %s", state.data)
         else:
-            self.logger.info("Progress: Not all commands have been run yet.")
+            self.logger.info(
+                "AnalyzeCephHandler Progress: Not all commands have been run yet."
+            )
 
     @staticmethod
     def register_preflight_state(

src/rookify/modules/machine.py

@@ -26,7 +26,9 @@ def add_execution_state(self, name: str, **kwargs: Dict[str, Any]) -> None:
     def add_preflight_state(self, name: str, **kwargs: Dict[str, Any]) -> None:
         self._preflight_states.append(self.__class__.state_cls(name, **kwargs))
 
-    def execute(self, dry_run_mode: bool = False) -> None:
+    def execute(
+        self, dry_run_mode: bool = False, show_progress: Optional[bool] = False
+    ) -> None:
         states = self._preflight_states
         if not dry_run_mode:
             states = states + self._execution_states

src/rookify/modules/module.py

@@ -59,6 +59,13 @@ def ssh(self) -> SSH:
             self.__ssh = SSH(self._config["ssh"])
         return self.__ssh
 
+    @abc.abstractmethod
+    def status(self) -> None:
+        """
+        Run the modules status check
+        """
+        pass
+
     @abc.abstractmethod
     def preflight(self) -> None:
         """
@@ -87,7 +94,12 @@ def load_template(self, filename: str, **variables: Any) -> Template:
         return template
 
     @classmethod
-    def register_states(cls, machine: Machine, config: Dict[str, Any]) -> None:
+    def register_states(
+        cls,
+        machine: Machine,
+        config: Dict[str, Any],
+        show_progress: Optional[bool] = False,
+    ) -> None:
         """
         Register states for transitions
         """
@@ -116,7 +128,10 @@ def register_states(cls, machine: Machine, config: Dict[str, Any]) -> None:
             )
         else:
             if preflight_state_name is not None:
-                cls.register_preflight_state(machine, preflight_state_name, handler)
+                if show_progress is True:
+                    cls.register_status_state(machine, preflight_state_name, handler)
+                else:
+                    cls.register_preflight_state(machine, preflight_state_name, handler)
 
             if execution_state_name is not None:
                 cls.register_execution_state(machine, execution_state_name, handler)
@@ -131,6 +146,16 @@ def register_preflight_state(
 
         machine.add_preflight_state(state_name, on_enter=handler.preflight, **kwargs)
 
+    @staticmethod
+    def register_status_state(
+        machine: Machine, state_name: str, handler: Any, **kwargs: Any
+    ) -> None:
+        """
+        Register state for transitions
+        """
+
+        machine.add_preflight_state(state_name, on_enter=handler.status, **kwargs)
+
     @staticmethod
     def register_execution_state(
         machine: Machine, state_name: str, handler: Any, **kwargs: Any

tests/test_main.py

@@ -210,7 +210,7 @@ def getUnsortedData() -> Any:
     (["--dry-run", "--show-progress", "analyze_ceph"], "Show progress of the analyze_ceph module", "info"),
     (["--show-progress"], "Show progress of all modules", "info"),
     (["--dry-run", "--show-progress"], "Show progress of all modules", "info"),
-    (["--show-progress"], "Analyze ceph has been run", "info")
+    (["--show-progress"], "AnalyzeCephHandler Progress: Not all commands have been run yet.", "info")
 ]
 # fmt: on