Fail-fast with non-existent playbooks for run

Author: brookelew

src/ansible_navigator/action_base.py

@@ -171,6 +171,18 @@ def rerun(self) -> None:
         Defined in the child class if necessary.
         """
 
+    # TODO: Create PreRun Stdout class
+    def pre_run_stdout(self) -> RunStdoutReturn:
+        """Performs pre-run tasks, such as fail-fast checks.
+        """
+        messages = []
+        message = f"Subcommand '{self._name}' does not support mode 'stdout'."
+        messages.append(ExitMessage(message=message))
+        message = "Try again with '--mode interactive'"
+        messages.append(ExitMessage(message=message, prefix=ExitPrefix.HINT))
+        message = "\n".join(str(message) for message in messages)
+        return RunStdoutReturn(message=message, return_code=1)
+
     def run_stdout(self) -> RunStdoutReturn:
         """Provide a message saying subcommand does not support mode stdout.
 

src/ansible_navigator/actions/__init__.py

@@ -48,5 +48,17 @@
     Interaction | None,
 ] = actions.run_interactive_factory(__package__)
 
+pre_run_action_stdout: Callable[
+    [str, ApplicationConfiguration],
+    RunStdoutReturn,
+] = actions.pre_run_stdout_factory(
+    __package__,
+)
+
+pre_run_action: Callable[
+    [str, AppPublic, Interaction],
+    Interaction | None,
+] = actions.pre_run_interactive_factory(__package__)
+
 
 __all__ = ["get", "kegexes", "names", "run_action", "run_action_stdout"]

src/ansible_navigator/actions/_actions.py

@@ -251,3 +251,83 @@ def run_stdout_factory(package: str) -> Callable[..., Any]:
         A partial ``run_stdout()`` method for the package
     """
     return functools.partial(run_stdout, package)
+
+
+def pre_run_interactive(package: str, action: str, *args: Any, **_kwargs: dict[str, Any]) -> Any:
+    """Call the given action's ``pre_run()`` method.
+
+    Args:
+        package: The name of the package
+        action: The name of the action
+        *args: The arguments passed to the action's run method
+        **_kwargs: The keyword arguments passed to the action's run
+            method
+
+    Returns:
+        The outcome of running the action's run method
+    """
+    action_cls = get(package, action)
+    app, interaction = args
+    app_action = action_cls(app.args)
+    supports_interactive = hasattr(app_action, "pre_run")
+    if not supports_interactive:
+        logger.error("Subcommand '%s' does not support mode interactive", action)
+    pre_run_action = app_action.pre_run if supports_interactive else app_action.no_interactive_mode
+
+    # Allow tracebacks to bring down the UI, used in tests
+    if os.getenv("ANSIBLE_NAVIGATOR_ALLOW_UI_TRACEBACK") == "true":
+        return pre_run_action(app=app, interaction=interaction)
+
+    # Capture and show a UI notification
+    try:
+        return pre_run_action(app=app, interaction=interaction)
+    except Exception:
+        logger.critical("Subcommand '%s' encountered a fatal error.", action)
+        logger.exception("Logging an uncaught exception")
+        warn_msg = [f"Unexpected errors were encountered while performing pre-run for '{action}'."]
+        warn_msg.append("Please log an issue with the log file contents.")
+        warning = error_notification(warn_msg)
+        interaction.ui.show_form(warning)
+        return None
+
+
+def pre_run_interactive_factory(package: str) -> Callable[..., Any]:
+    """Create a ``pre_run_interactive()`` function for one package.
+
+    Args:
+        package: The name of the package
+
+    Returns:
+        A partial ``pre_run_interactive()`` method for the package
+    """
+    return functools.partial(pre_run_interactive, package)
+
+
+def pre_run_stdout(package: str, action: str, *args: Any, **_kwargs: dict[str, Any]) -> RunStdoutReturn:
+    """Call the given action's ``pre_run_stdout`` method.
+
+    Args:
+        package: The name of the package
+        action: The name of the action
+        *args: The arguments passed to the action's pre_run_stdout method
+        **_kwargs: The keyword arguments passed to the action's
+            pre_run_stdout method
+
+    Returns:
+        The outcome of running the action's ``pre_run_stdout()`` method
+    """
+    action_cls = get(package, action)
+    args = args[0]
+    return action_cls(args).pre_run_stdout()
+
+
+def pre_run_stdout_factory(package: str) -> Callable[..., Any]:
+    """Create a ``pre_run_stdout()`` function for one package.
+
+    Args:
+        package: The name of the package
+
+    Returns:
+        A partial ``pre_run_stdout()`` method for the package
+    """
+    return functools.partial(pre_run_stdout, package)

src/ansible_navigator/actions/run.py

@@ -48,14 +48,12 @@
 from . import run_action
 from .stdout import Action as stdout_action
 
-
 if TYPE_CHECKING:
     from collections.abc import Callable
 
     from ansible_navigator.app_public import AppPublic
     from ansible_navigator.configuration_subsystem.definitions import ApplicationConfiguration
 
-
 RESULT_TO_COLOR = [
     ("(?i)^failed$", 9),
     ("(?i)^ok$", 10),
@@ -114,7 +112,7 @@ def color_menu(_colno: int, colname: str, entry: dict[str, Any]) -> tuple[int, i
 
     elif "task" in entry:
         if entry["__result"].lower() == "in progress" or (
-            colname in ["__result", "__host", "__number", "__task", "__task_action"]
+                colname in ["__result", "__host", "__number", "__task", "__task_action"]
         ):
             color = get_color(entry["__result"])
         elif colname == "__changed":
@@ -258,11 +256,11 @@ def mode(self) -> str:
             such, else return mode
         """
         if all(
-            (
-                self._args.mode == "stdout",
-                self._args.playbook_artifact_enable,
-                self._args.app != "replay",
-            ),
+                (
+                        self._args.mode == "stdout",
+                        self._args.playbook_artifact_enable,
+                        self._args.app != "replay",
+                ),
         ):
             return "stdout_w_artifact"
         return self._args.mode
@@ -302,6 +300,19 @@ def run_stdout(self) -> RunStdoutReturn:
             )
         return RunStdoutReturn(message="", return_code=return_code)
 
+    def pre_run_stdout(self) -> RunStdoutReturn:
+        # Ensure the playbook and inventory are valid
+
+        if isinstance(self._args.playbook, str):
+            playbook_valid = Path(self._args.playbook).exists()
+        else:
+            playbook_valid = False
+
+        if not playbook_valid:
+            return RunStdoutReturn(message=f"Playbook \"{self._args.playbook}\" does not exist", return_code=1)
+
+        return RunStdoutReturn(message="", return_code=0)
+
     def run(self, interaction: Interaction, app: AppPublic) -> Interaction | None:
         """Run :run or :replay.
 
@@ -335,7 +346,7 @@ def run(self, interaction: Interaction, app: AppPublic) -> Interaction | None:
 
         self.steps.append(self._plays)
 
-        # Show a notification until the first the first message from the queue is processed
+        # Show a notification until the first message from the queue is processed
         if self._subaction_type == "run":
             messages = ["Preparing for automation, please wait..."]
             notification = nonblocking_notification(messages=messages)

src/ansible_navigator/cli.py

@@ -23,7 +23,7 @@
 from .action_defs import RunReturn
 from .action_defs import RunStdoutReturn
 from .action_runner import ActionRunner
-from .actions import run_action_stdout
+from .actions import run_action_stdout, pre_run_action_stdout
 from .configuration_subsystem import Constants
 from .configuration_subsystem import NavigatorConfiguration
 from .image_manager import ImagePuller
@@ -153,6 +153,36 @@ def run(args: ApplicationConfiguration) -> ActionReturn:
     return RunReturn(message="", return_code=0)
 
 
+def pre_run_validation(args: ApplicationConfiguration) -> ActionReturn:
+    """Pre-run validation for the appropriate subcommand for failing earlier.
+
+    Args:
+        args: The current application settings
+
+    Returns:
+        A message to display and a return code
+    """
+    if args.mode == "stdout":
+        try:
+            result = pre_run_action_stdout(args.app.replace("-", "_"), args)
+        except KeyboardInterrupt:
+            logger.warning("Dirty exit, killing the pid")
+            os.kill(os.getpid(), signal.SIGTERM)
+            # TODO: Create new class for PreRunReturns
+            return RunStdoutReturn(message="", return_code=1)
+        return result
+    # if args.mode == "interactive":
+    #     try:
+    #         clear_screen()
+    #         wrapper(ActionRunner(args=args).pre_run)
+    #         return RunInteractiveReturn(message="", return_code=0)
+    #     except KeyboardInterrupt:
+    #         logger.warning("Dirty exit, killing the pid")
+    #         os.kill(os.getpid(), signal.SIGTERM)
+    #         return RunInteractiveReturn(message="", return_code=1)
+    return RunReturn(message="", return_code=0)
+
+
 def main() -> None:
     """Start application here."""
     messages: list[LogMessage] = log_dependencies()
@@ -203,6 +233,16 @@ def main() -> None:
 
     os.environ.setdefault("ESCDELAY", "25")
 
+    pre_run_validation_return = pre_run_validation(args)
+    pre_run_validation_message = f"{pre_run_validation_return.message}\n"
+    if pre_run_validation_return.return_code != 0 and pre_run_validation_return.message:
+        sys.stderr.write(pre_run_validation_message)
+        sys.exit(pre_run_validation_return.return_code)
+    elif pre_run_validation_return.return_code != 0:
+        sys.exit(pre_run_validation_return.return_code)
+    elif pre_run_validation_return.message:
+        sys.stdout.write(pre_run_validation_message)
+
     if args.execution_environment:
         pull_image(args)
     cache_scripts()