mreg-cli 1.0.0__py3-none-any.whl

mreg_cli/errorbuilder.py

@@ -0,0 +1,193 @@
+"""Builders for error messages with underlined suggestions."""
+
+from __future__ import annotations
+
+import logging
+import shlex
+from abc import ABC, abstractmethod
+
+logger = logging.getLogger(__name__)
+
+ExcOrStr = Exception | str
+
+
+# Re-usable function for error builders that don't need a specific implementation
+def default_get_offset(self: "ErrorBuilder") -> tuple[int, int]:  # noqa: ARG001
+    """Get the start and end index of the underlined part of the command."""
+    return -1, -1
+
+
+class ErrorBuilder(ABC):
+    """Base class for building error messages with an underline and suggestion."""
+
+    # Subclasses should implement this:
+    SUGGESTION = ""
+
+    # Characters used for formatting the error message
+    CHAR_UNDERLINE = "^"
+    CHAR_OFFSET = " "
+    CHAR_SUGGESTION = "└"
+
+    def __init__(self, command: str, exc_or_str: ExcOrStr) -> None:
+        """Instantiate the builder with the command that caused the error."""
+        self.command = command
+        self.exc_or_str = exc_or_str
+
+    def get_underline(self, start: int, end: int) -> str:
+        """Get the underline part of the message.
+
+        :param int start: The start index of the underlined part of the command.
+        :param int end: The end index of the underlined part of the command.
+
+        :returns: The underlined part of the command.
+        """
+        return self.offset(self.CHAR_UNDERLINE * (end - start), start)
+
+    def get_suggestion(self, start: int) -> str:
+        """Get the suggestion part of the message.
+
+        :param int start: The start index of the underlined part of the command.
+        """
+        msg = self.SUGGESTION
+        if self.CHAR_SUGGESTION:
+            msg = f"{self.CHAR_SUGGESTION} {msg}"
+        return self.offset(msg, start)
+
+    def offset(self, s: str, n: int) -> str:
+        """Offset the string by n spaces.
+
+        :param str s: The string to offset.
+        :param int n: The number of spaces to offset by.
+
+        :returns: The offset string.
+        """
+        return " " * n + s
+
+    def build(self) -> str:
+        """Build the error message with an underline and suggestion.
+
+        :returns: The error message with an underline and suggestion.
+        """
+        start, end = self.get_offset()
+        lines = [
+            self.command,
+            self.get_underline(start, end),
+            self.get_suggestion(start),
+        ]
+        # prepend the exception message if it exists
+        if self.exc_or_str:
+            lines.insert(0, str(self.exc_or_str))
+        return "\n".join(lines)
+
+    @abstractmethod
+    def get_offset(self) -> tuple[int, int]:
+        """Compute the start and end index of the underlined part of the command."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def can_build(self) -> bool:
+        """Check if the builder can build an error message for the given command."""
+        raise NotImplementedError
+
+
+class FallbackErrorBuilder(ErrorBuilder):
+    """Builder for errors without a specific implementation.
+
+    Renders the error message as a single line without an underline or suggestion.
+    The error message is displayed as-is.
+    """
+
+    get_offset = default_get_offset  # needed for ABC parent class
+
+    def build(self) -> str:
+        """Build the error message without an underline or suggestion."""
+        return str(self.exc_or_str)
+
+    def can_build(self) -> bool:  # noqa: D102
+        return True
+
+
+class FilterErrorBuilder(ErrorBuilder):
+    """Error builder for commands with a filter."""
+
+    SUGGESTION = "Consider enclosing this part in quotes."
+
+    @staticmethod
+    def find_word_with_char_offset(command: str, char: str) -> tuple[int, int]:
+        """Find the start and end index of a word containing a specific character.
+
+        Cannot fail; will always return a tuple of two integers.
+
+        :param str command: The command to search.
+        :param str char: The character to search for.
+
+        :returns: Tuple of two integers representing the start and end index of the word.
+                  Returns (-1, -1) if the character is not found.
+        """
+        command = command.strip()
+        if not command:
+            return -1, -1
+
+        # Parse the command into parts
+        cmd = shlex.split(command, posix=False)  # keep quotes and backslashes
+        for part in cmd:
+            # Skip parts that contain quotes
+            # NOTE: This is a very naive check, and will not work for all cases
+            #      (e.g. escaped quotes)
+            if "'" in part or '"' in part:
+                continue
+
+            if char in part:
+                try:
+                    start, end = command.index(part), command.index(part) + len(part)
+                    if start > end or start >= len(command) or end >= len(command):
+                        raise ValueError(f"Invalid start and end values: {start}, {end}")
+                except ValueError as e:
+                    logger.error(
+                        "Failed to get index of char '%s' in part '%s' of command %s: %s",
+                        char,
+                        part,
+                        command,
+                        e,
+                    )
+                else:
+                    return start, end
+        return -1, -1
+
+    def get_offset(self) -> tuple[int, int]:  # noqa: D102 (missing docstring [inherit it from parent])
+        return self.find_word_with_char_offset(self.command, "|")
+
+    def can_build(self) -> bool:  # noqa: D102 (missing docstring [inherit it from parent])
+        return "|" in self.command
+
+
+BUILDERS: list[type[ErrorBuilder]] = [
+    FilterErrorBuilder,
+]
+
+
+def get_builder(command: str, exc_or_str: ExcOrStr) -> ErrorBuilder:
+    """Get the appropriate error builder for the given command.
+
+    :param str command: The command that caused the error.
+    :param exc_or_str: The exception or error message.
+
+    :returns: An error builder instance.
+    """
+    for builder in BUILDERS:
+        b = builder(command, exc_or_str)
+        if b.can_build():
+            return b
+    return FallbackErrorBuilder(command, exc_or_str)
+
+
+def build_error_message(command: str, exc_or_str: ExcOrStr) -> str:
+    """Build an error message for the given command and exception.
+
+    :param str command: The command that caused the error.
+    :param exc_or_str: The exception or error message.
+
+    :returns: Error message based on the command and exception.
+    """
+    builder = get_builder(command, exc_or_str)
+    return builder.build()

mreg_cli/exceptions.py

@@ -0,0 +1,237 @@
+"""Custom exceptions for mreg_cli.
+
+Note that Cli exceptions offer a print_self() method that prints the exception
+with appropriate formatting. This is useful for printing exceptions in the
+context of a CLI command.
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from typing import Any
+
+from prompt_toolkit import print_formatted_text
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.formatted_text.html import html_escape
+
+
+class CliExit(Exception):
+    """Exception used to exit the CLI."""
+
+    pass
+
+
+class CliException(Exception):
+    """Base exception class for the CLI."""
+
+    def escape(self) -> str:
+        """Get an HTML-escaped string representation of the exception."""
+        return html_escape(str(self))
+
+    def formatted_exception(self) -> str:
+        """Return a formatted string representation of the exception.
+
+        :returns: Formatted string for the exception message.
+        """
+        raise NotImplementedError("This method should be implemented by subclasses")
+
+    def print_self(self):
+        """Print the exception with appropriate formatting."""
+        print_formatted_text(HTML(self.formatted_exception()), file=sys.stdout)
+
+
+class CliError(CliException):
+    """Exception class for CLI errors.
+
+    Errors are not recoverable and stem from internal failures that
+    the user cannot be expected to resolve.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        """Initialize the error."""
+        super().__init__(*args, **kwargs)
+        logging.getLogger(__name__).error(str(self))
+        from mreg_cli.outputmanager import OutputManager
+
+        OutputManager().add_error(str(self))
+
+    def formatted_exception(self) -> str:
+        """Return a string formatted with HTML red tag for the error message.
+
+        :returns: Formatted error message.
+        """
+        return f"<ansired>ERROR: {self.escape()}</ansired>"
+
+
+class CliWarning(CliException):
+    """Exception class for CLI warnings.
+
+    Warnings should be recoverable by changing the user input.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        """Initialize the warning."""
+        from mreg_cli.outputmanager import OutputManager
+
+        super().__init__(*args, **kwargs)
+        logging.getLogger(__name__).warning(str(self))
+        OutputManager().add_warning(str(self))
+
+    def formatted_exception(self) -> str:
+        """Return a string formatted with HTML italic tag for the warning message.
+
+        :returns: Formatted warning message.
+        """
+        return f"<i>{self.escape()}</i>"
+
+
+class CreateError(CliError):
+    """Error class for failed creation."""
+
+    pass
+
+
+class PatchError(CliError):
+    """Error class for failed patching."""
+
+    pass
+
+
+class DeleteError(CliError):
+    """Error class for failed deletion."""
+
+    pass
+
+
+class GetError(CliError):
+    """Error class for failed retrieval."""
+
+    pass
+
+
+class InternalError(CliError):
+    """Error class for internal errors."""
+
+    pass
+
+
+class APIError(CliError):
+    """Error class for API errors."""
+
+    pass
+
+
+class UnexpectedDataError(APIError):
+    """Error class for unexpected API data."""
+
+    pass
+
+
+class ValidationError(CliError):
+    """Error class for validation failures."""
+
+    pass
+
+
+class FileError(CliError):
+    """Error class for file errors."""
+
+    pass
+
+
+class APINotOk(CliWarning):
+    """Warning class for API not returning OK."""
+
+    pass
+
+
+class TooManyResults(CliWarning):
+    """Warning class for too many results."""
+
+    pass
+
+
+class NoHistoryFound(CliWarning):
+    """Warning class for no history found."""
+
+    pass
+
+
+class EntityNotFound(CliWarning):
+    """Warning class for an entity that was not found."""
+
+    pass
+
+
+class EntityAlreadyExists(CliWarning):
+    """Warning class for an entity that already exists."""
+
+    pass
+
+
+class MultipleEntititesFound(CliWarning):
+    """Warning class for multiple entities found."""
+
+    pass
+
+
+class EntityOwnershipMismatch(CliWarning):
+    """Warning class for an entity that already exists but owned by someone else."""
+
+    pass
+
+
+class InputFailure(CliWarning):
+    """Warning class for input failure."""
+
+    pass
+
+
+class ForceMissing(CliWarning):
+    """Warning class for missing force flag."""
+
+    pass
+
+
+class InvalidIPAddress(CliWarning):
+    """Warning class for an entity that is not an IP address."""
+
+    pass
+
+
+class InvalidIPv4Address(CliWarning):
+    """Warning class for an entity that is not an IPv4 address."""
+
+    pass
+
+
+class InvalidIPv6Address(CliWarning):
+    """Warning class for an entity that is not an IPv6 address."""
+
+    pass
+
+
+class InvalidNetwork(CliWarning):
+    """Warning class for an entity that is not a network."""
+
+    pass
+
+
+class NetworkOverlap(CliWarning):
+    """Warning class for a networkthat overlaps with another network."""
+
+    pass
+
+
+class LoginFailedError(CliException):
+    """Error class for login failure."""
+
+    def formatted_exception(self) -> str:
+        """Return a string formatted with 'Login failed:' prefixing the error message.
+
+        :returns: Formatted error message.
+        """
+        return f"Login failed: {self.escape()}"
+
+    pass

mreg_cli/help_formatter.py

@@ -0,0 +1,38 @@
+"""A formatter for the CLI that adds extra information and improves command formatting."""
+
+from __future__ import annotations
+
+import argparse
+from typing import Any
+
+
+class CustomHelpFormatter(argparse.HelpFormatter):
+    """Custom help formatter to add extra information and improve command formatting."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Initialize the formatter."""
+        super().__init__(*args, **kwargs)
+        self._max_help_position = 35  # Adjust this to control the indentation of help text
+
+    def _format_action(self, action: argparse.Action) -> str:
+        """Format the action with custom width.
+
+        :param action: The argparse Action being formatted.
+
+        :returns: Formatted action string.
+        """
+        # Check if this is a _SubParsersAction (used for subcommands)
+        if isinstance(action, argparse._SubParsersAction):
+            # Use a custom heading for subcommands
+            formatted_action = "commands:\n"
+
+            # Format each subcommand
+            for subcommand, parser in action.choices.items():
+                subcommand_help = parser.description if parser.description else ""
+                formatted_subcommand = f"  {subcommand:<20} {subcommand_help}"
+                formatted_action += formatted_subcommand + "\n"
+
+            return formatted_action
+
+        # Handle non-_SubParsersAction actions with default formatting
+        return super()._format_action(action)

mreg_cli/main.py

@@ -0,0 +1,238 @@
+"""Main entry point for mreg_cli."""
+
+from __future__ import annotations
+
+import argparse
+import getpass
+import logging
+
+from prompt_toolkit import HTML
+from prompt_toolkit.shortcuts import CompleteStyle, PromptSession
+
+import mreg_cli.utilities.api as api
+from mreg_cli.__about__ import __version__
+from mreg_cli.cli import cli, source
+from mreg_cli.config import MregCliConfig
+from mreg_cli.exceptions import LoginFailedError
+from mreg_cli.outputmanager import OutputManager
+from mreg_cli.types import LogLevel
+from mreg_cli.utilities.api import try_token_or_login
+
+logger = logging.getLogger(__name__)
+
+
+def main():
+    """Entry point for the mreg cli."""
+    # Read config file first, to provide defaults
+    config = MregCliConfig()
+
+    parser = argparse.ArgumentParser(description="The MREG cli")
+
+    parser.add_argument(
+        "--version",
+        help="Show version and exit.",
+        action="store_true",
+    )
+
+    connect_args = parser.add_argument_group("connection settings")
+    connect_args.add_argument(
+        "--url",
+        default=config.get_url(),
+        help="use mreg server at %(metavar)s (default: %(default)s)",
+        metavar="URL",
+    )
+
+    connect_args.add_argument(
+        "-u",
+        "--user",
+        default=config.get("user", getpass.getuser()),
+        help="authenticate as %(metavar)s (default: %(default)s)",
+        metavar="USER",
+    )
+
+    mreg_args = parser.add_argument_group("mreg settings")
+    mreg_args.add_argument(
+        "-d",
+        "--domain",
+        default=config.get("domain", config.get_default_domain()),
+        help="default %(metavar)s (default: %(default)s)",
+        metavar="DOMAIN",
+    )
+
+    mreg_args.add_argument(
+        "-p",
+        "--prompt",
+        help="default %(metavar)s), defaults to the server name if not set.",
+        metavar="PROMPT",
+    )
+
+    output_args = parser.add_argument_group("output settings")
+    output_args.add_argument(
+        "-v",
+        "--log-level",
+        dest="loglevel",
+        default="INFO",
+        choices=LogLevel.choices(),
+        help="Log level for logging.",
+    )
+    output_args.add_argument(
+        "-l",
+        "--logfile",
+        dest="logfile",
+        help="write log to %(metavar)s",
+        metavar="LOGFILE",
+    )
+    output_args.add_argument(
+        "--show-token",
+        dest="show_token",
+        action="store_true",
+        help="show API token after login",
+    )
+    output_args.add_argument(
+        "--record",
+        dest="record_traffic",
+        help="Record all server/client traffic to %(metavar)s",
+        metavar="RECFILE",
+    )
+    output_args.add_argument(
+        "--record-without-timestamps",
+        dest="record_traffic_without_timestamps",
+        action="store_true",
+        help="Do not apply timestamps to the recording file",
+    )
+    output_args.add_argument(
+        "--source",
+        dest="source",
+        help="Read commands from %(metavar)s",
+        metavar="SOURCE",
+    )
+
+    output_args.add_argument(
+        "--token-only",
+        dest="token_only",
+        action="store_true",
+        default=False,
+        help="Only attempt token login, this will avoid interactive prompts.",
+    )
+
+    output_args.add_argument(
+        "command", metavar="command", nargs="*", help="Oneshot command to issue to the cli."
+    )
+
+    args = parser.parse_args()
+
+    if args.version:
+        print(f"mreg-cli {__version__}")
+        raise SystemExit() from None
+
+    logfile = config.get_default_logfile()
+    conf = {k: v for k, v in vars(args).items() if v}
+    config.set_cmd_config(conf)
+
+    if "logfile" in conf:
+        logfile = conf["logfile"]
+
+    config.start_logging(logfile, args.loglevel)
+
+    logger.debug(f"args: {args}")
+
+    if "record_traffic" in conf:
+        OutputManager().recording_start(conf["record_traffic"])
+
+    if "record_traffic_without_timestamps" in conf:
+        OutputManager().record_timestamps(False)
+
+    if config.get("user") is None:
+        print("Username not set in config or as argument")
+        return
+    elif config.get("url") is None:
+        print("mreg url not set in config or as argument")
+        return
+
+    try:
+        try_token_or_login(
+            str(config.get("user")),
+            str(config.get("url")),
+            fail_without_token=args.token_only,
+        )
+
+    except (EOFError, KeyboardInterrupt, LoginFailedError) as e:
+        print(e)
+        raise SystemExit() from None
+    if args.show_token:
+        print(api.get_session_token() or "Token not found.")
+        raise SystemExit() from None
+
+    # Define a function that returns the prompt message
+    def get_prompt_message():
+        """Return the prompt message."""
+        manager = OutputManager()
+
+        if args.prompt:
+            prompt = args.prompt
+        elif config.get("prompt"):
+            prompt = config.get("prompt")
+        else:
+            host = str(config.get("url")).replace("https://", "").replace("http://", "")
+            user = args.user or config.get("user", "?")
+            prompt = f"{user}@{host}"
+
+        prefix: list[str] = []
+
+        if manager.recording_active():
+            prefix.append(f">'{manager.recording_filename()}'")
+
+        if prefix:
+            prefix_str = ",".join(prefix)
+            return HTML(f"[{prefix_str}] {prompt}> ")
+        return HTML(f"{prompt}> ")
+
+    # session is a PromptSession object from prompt_toolkit which handles
+    # some configurations of the prompt for us: the text of the prompt; the
+    # completer; and other visual things.
+    session = PromptSession(
+        message=get_prompt_message,
+        search_ignore_case=True,
+        completer=cli,
+        complete_while_typing=True,
+        complete_style=CompleteStyle.MULTI_COLUMN,
+    )
+
+    # Welcome text for the app
+    print("Type -h for help.")
+
+    # if the --source parameter was given, read commands from the source file and then exit
+    if "source" in conf:
+        logger.info("Reading commands from %s", conf["source"])
+        for command in source([conf["source"]], "verbosity" in conf, False):
+            cli.process_command_line(command)
+        return
+
+    # Check if we got a oneshot command. If so, execute it and exit.
+    if args.command:
+        cmd = " ".join(args.command)
+        try:
+            cli.process_command_line(cmd)
+        except ValueError as e:
+            print(e)
+
+        raise SystemExit() from None
+
+    # The app runs in an infinite loop and is expected to exit using sys.exit()
+    logger.debug("Entering main loop")
+    while True:
+        try:
+            lines = session.prompt()
+        except KeyboardInterrupt:
+            continue
+        except EOFError:
+            raise SystemExit() from None
+        try:
+            for line in lines.splitlines():
+                cli.process_command_line(line)
+        except ValueError as e:
+            print(e)
+
+
+if __name__ == "__main__":
+    main()