mreg-cli 1.0.0__py3-none-any.whl

mreg_cli/commands/zone.py

@@ -0,0 +1,288 @@
+"""Zone commands for mreg_cli."""
+
+from __future__ import annotations
+
+import argparse
+from typing import Any
+
+from mreg_cli.api.models import Zone
+from mreg_cli.commands.base import BaseCommand
+from mreg_cli.commands.registry import CommandRegistry
+from mreg_cli.exceptions import DeleteError, InputFailure
+from mreg_cli.outputmanager import OutputManager
+from mreg_cli.types import Flag
+
+command_registry = CommandRegistry()
+
+
+class ZoneCommands(BaseCommand):
+    """Zone commands for the CLI."""
+
+    def __init__(self, cli: Any) -> None:
+        """Initialize the zone commands."""
+        super().__init__(cli, command_registry, "zone", "Manage zones.", "Manage zones")
+
+
+@command_registry.register_command(
+    prog="create",
+    description="Create new zone.",
+    short_desc="Create new zone.",
+    flags=[
+        Flag("zone", description="Zone name.", metavar="ZONE"),
+        Flag("email", description="Contact email.", metavar="EMAIL"),
+        Flag("ns", description="Nameservers of the zone.", nargs="+", metavar="NS"),
+        Flag("-force", action="store_true", description="Enable force."),
+    ],
+)
+def create(args: argparse.Namespace) -> None:
+    """Create a new zone.
+
+    :param args: argparse.Namespace (ns, force, zone, email)
+    """
+    Zone.create_zone(args.zone, args.email, args.ns, args.force)
+    OutputManager().add_ok(f"Created zone {args.zone}")
+
+
+@command_registry.register_command(
+    prog="delegation_create",
+    description=(
+        "Create new zone delegation. Requires force if ns or zone doesn't exist in MREG."
+    ),
+    short_desc="Create new zone delegation.",
+    flags=[
+        Flag("zone", description="Zone name.", metavar="ZONE"),
+        Flag("delegation", description="Delegation", metavar="DELEGATION"),
+        Flag("ns", description="Nameservers for the delegation.", nargs="+", metavar="NS"),
+        Flag("-comment", description="Comment with a description", metavar="COMMENT"),
+        Flag("-force", action="store_true", description="Enable force."),
+    ],
+)
+def delegation_create(args: argparse.Namespace) -> None:
+    """Create a new zone delegation.
+
+    :param args: argparse.Namespace (ns, force, zone, delegation, comment)
+    """
+    zone = Zone.get_zone_or_raise(args.zone)
+    zone.create_delegation(args.delegation, args.ns, args.comment, args.force)
+    OutputManager().add_ok(f"Created zone delegation {args.delegation}")
+
+
+@command_registry.register_command(
+    prog="delete",
+    description="Delete a zone",
+    short_desc="Delete a zone",
+    flags=[
+        Flag("zone", description="Zone name.", metavar="ZONE"),
+        Flag("-force", action="store_true", description="Enable force."),
+    ],
+)
+def zone_delete(args: argparse.Namespace) -> None:
+    """Delete a zone.
+
+    :param args: argparse.Namespace (zone, force)
+    """
+    zone = Zone.get_zone_or_raise(args.zone)
+    if zone.delete_zone(args.force):
+        OutputManager().add_ok(f"Deleted zone {zone.name}")
+    else:
+        raise DeleteError(f"Unable to delete zone {zone.name}")
+
+
+@command_registry.register_command(
+    prog="delegation_delete",
+    description="Delete a zone delegation",
+    short_desc="Delete a zone delegation",
+    flags=[
+        Flag("zone", description="Zone name.", metavar="ZONE"),
+        Flag("delegation", description="Delegation", metavar="DELEGATION"),
+    ],
+)
+def delegation_delete(args: argparse.Namespace) -> None:
+    """Delete a zone delegation.
+
+    :param args: argparse.Namespace (zone, delegation)
+    """
+    # NOTE: how to handle delegation that has delegation?
+    # i.e. uio.no -> pederhan.uio.no -> sub.pederhan.uio.no
+    # and we try to delete pederhan.uio.no?
+    zone = Zone.get_zone_or_raise(args.zone)
+    if zone.delete_delegation(args.delegation):
+        OutputManager().add_ok(f"Removed zone delegation {args.delegation}")
+    else:
+        raise DeleteError(f"Unable to delete delegation {args.delegation}")
+
+
+@command_registry.register_command(
+    prog="info",
+    description="Delete a zone",
+    short_desc="Delete a zone",
+    flags=[
+        Flag("zone", description="Zone name.", metavar="ZONE"),
+    ],
+)
+def info(args: argparse.Namespace) -> None:
+    """Show SOA info for a existing zone.
+
+    :param args: argparse.Namespace (zone)
+    """
+    zone = Zone.get_zone_or_raise(args.zone)
+    zone.output()
+
+
+@command_registry.register_command(
+    prog="list",
+    description="List zones",
+    short_desc="List zones",
+    flags=[
+        Flag(
+            "-forward",
+            action="store_true",
+            short_desc="List all forward zones",
+            description="List all forward zones",
+        ),
+        Flag(
+            "-reverse",
+            action="store_true",
+            short_desc="List all reverse zones",
+            description="List all reverse zones",
+        ),
+    ],
+)
+def zone_list(args: argparse.Namespace) -> None:
+    """List all zones.
+
+    :param args: argparse.Namespace (forward, reverse)
+    """
+    if not (args.forward or args.reverse):
+        raise InputFailure("Add either -forward or -reverse as argument")
+    Zone.output_zones(args.forward, args.reverse)
+
+
+@command_registry.register_command(
+    prog="delegation_list",
+    description="List a zone's delegations",
+    short_desc="List a zone's delegations",
+    flags=[
+        Flag("zone", description="Zone name.", metavar="ZONE"),
+    ],
+)
+def zone_delegation_list(args: argparse.Namespace) -> None:
+    """List a zone's delegations.
+
+    :param args: argparse.Namespace (zone)
+    """
+    zone = Zone.get_zone_or_raise(args.zone)
+    zone.output_delegations()
+
+
+@command_registry.register_command(
+    prog="delegation_comment_set",
+    description="Set a comment for zone delegation",
+    short_desc="Set a comment for zone delegation",
+    flags=[
+        Flag("zone", description="Zone name", metavar="ZONE"),
+        Flag("delegation", description="Delegation", metavar="DELEGATION"),
+        Flag("comment", description="Comment", metavar="COMMENT"),
+    ],
+)
+def zone_delegation_comment_set(args: argparse.Namespace) -> None:
+    """Set a delegation's comment.
+
+    :param args: argparse.Namespace (zone, delegation, comment)
+    """
+    zone = Zone.get_zone_or_raise(args.zone)
+    zone.set_delegation_comment(args.delegation, args.comment)
+    OutputManager().add_ok(f"Updated comment for {args.delegation}")
+
+
+@command_registry.register_command(
+    prog="delegation_comment_remove",
+    description="Remove a comment for zone delegation",
+    short_desc="Remove a comment for zone delegation",
+    flags=[
+        Flag("zone", description="Zone name", metavar="ZONE"),
+        Flag("delegation", description="Delegation", metavar="DELEGATION"),
+    ],
+)
+def zone_delegation_comment_remove(args: argparse.Namespace) -> None:
+    """Set a delegation's comment.
+
+    :param args: argparse.Namespace (zone, delegation)
+    """
+    zone = Zone.get_zone_or_raise(args.zone)
+    zone.set_delegation_comment(args.delegation, "")
+    OutputManager().add_ok(f"Removed comment for {args.delegation}")
+
+
+@command_registry.register_command(
+    prog="set_ns",
+    description="Update nameservers for an existing zone.",
+    short_desc="Update nameservers for an existing zone.",
+    flags=[
+        Flag("zone", description="Zone name.", metavar="ZONE"),
+        Flag("ns", description="Nameservers of the zone.", nargs="+", metavar="NS"),
+        Flag("-force", action="store_true", description="Enable force."),
+    ],
+)
+def set_ns(args: argparse.Namespace) -> None:
+    """Update nameservers for an existing zone.
+
+    If multiple nameservers are provided, the first one is set as the primary nameserver.
+
+    :param args: argparse.Namespace (zone, ns, force)
+    """
+    zone = Zone.get_zone_or_raise(args.zone)
+    zone.update_nameservers(args.ns, args.force)
+    OutputManager().add_ok(f"Updated nameservers for {args.zone}")
+
+
+@command_registry.register_command(
+    prog="set_soa",
+    description="Updated the SOA of a zone.",
+    short_desc="Updated the SOA of a zone.",
+    flags=[
+        Flag("zone", description="Zone name.", metavar="ZONE"),
+        Flag("-ns", description="Primary nameserver (SOA MNAME).", metavar="PRIMARY-NS"),
+        Flag("-email", description="Zone contact email.", metavar="EMAIL"),
+        Flag("-serialno", description="Serial number.", flag_type=int, metavar="SERIALNO"),
+        Flag("-refresh", description="Refresh time.", flag_type=int, metavar="REFRESH"),
+        Flag("-retry", description="Retry time.", flag_type=int, metavar="RETRY"),
+        Flag("-expire", description="Expire time.", flag_type=int, metavar="EXPIRE"),
+        Flag("-soa-ttl", description="SOA Time To Live", flag_type=int, metavar="TTL"),
+    ],
+)
+def set_soa(args: argparse.Namespace) -> None:
+    """Update the SOA of a zone.
+
+    :param args: argparse.Namespace (zone, ns, email, serialno, retry, expire, soa_ttl)
+    """
+    zone = Zone.get_zone_or_raise(args.zone)
+    zone.update_soa(
+        primary_ns=args.ns,
+        email=args.email,
+        serialno=args.serialno,
+        refresh=args.refresh,
+        retry=args.retry,
+        expire=args.expire,
+        soa_ttl=args.soa_ttl,
+    )
+    OutputManager().add_ok(f"Updated SOA for {args.zone}")
+
+
+@command_registry.register_command(
+    prog="set_default_ttl",
+    description="Set the default TTL of a zone.",
+    short_desc="Set the default TTL of a zone.",
+    flags=[
+        Flag("zone", description="Zone name.", metavar="ZONE"),
+        Flag("ttl", description="Default Time To Live.", flag_type=int, metavar="TTL"),
+    ],
+)
+def set_default_ttl(args: argparse.Namespace) -> None:
+    """Update the default TTL of a zone.
+
+    :param args: argparse.Namespace (zone, ttl)
+    """
+    zone = Zone.get_zone_or_raise(args.zone)
+    zone.set_default_ttl(args.ttl)
+    OutputManager().add_ok(f"Set default TTL for {args.zone}")

mreg_cli/config.py

@@ -0,0 +1,253 @@
+"""Logging.
+
+This module can be used to configure basic logging to stderr, with an optional
+filter level.
+
+When prompting for user input (verbosity, debug level), log levels can be
+translated according to a mapping:
+
+.. py:data:: LOGGING_VERBOSITY
+
+    0. :py:const:`logging.ERROR`
+    1. :py:const:`logging.WARNING`
+    2. :py:const:`logging.INFO`
+    3. :py:const:`logging.DEBUG`
+"""
+
+from __future__ import annotations
+
+import configparser
+import logging
+import os
+import sys
+from typing import Any, overload
+
+from mreg_cli.types import DefaultType, LogLevel
+
+logger = logging.getLogger(__name__)
+
+# Config file locations
+DEFAULT_CONFIG_PATH = tuple(
+    (
+        os.path.expanduser("~/.config/mreg-cli.conf"),
+        "/etc/mreg-cli.conf",
+        os.path.join(sys.prefix, "local", "share", "mreg-cli.conf"),
+        os.path.join(sys.prefix, "share", "mreg-cli.conf"),
+        # At last, look in ../data/ in case we're developing
+        os.path.join(os.path.dirname(__file__), "..", "data", "mreg-cli.conf"),
+    )
+)
+
+DEFAULT_LOG_FILE = os.path.expanduser("~/.mreg-cli.log")
+
+# Default logging format
+LOGGING_FORMAT = "%(asctime)s - %(levelname)-8s - %(name)s - %(message)s"
+
+
+class MregCliConfig:
+    """Configuration class for the mreg-cli.
+
+    This is a singleton class that is used to store configuration information.
+    Configuration is loaded with the following priority:
+    1. Command line options
+    2. Environment variables (prefixed with 'MREG_')
+    3. Configuration file
+    """
+
+    _instance = None
+    _is_logging = False
+    _logfile = None
+    _config_cmd: dict[str, str]
+    _config_file: dict[str, str]
+    _config_env: dict[str, str]
+
+    def __new__(cls) -> MregCliConfig:
+        """Create a new instance of the configuration class.
+
+        This ensures that only one instance of the configuration class is created.
+        """
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._config_file = {}
+            cls._instance._config_env = cls._load_env_config()
+            cls._instance._config_cmd = {}
+            cls._instance.get_config()
+
+        return cls._instance
+
+    @staticmethod
+    def _load_env_config() -> dict[str, str]:
+        """Load environment variables into the configuration, filtering with 'MREGCLI_' prefix."""
+        env_prefix = "MREGCLI_"
+        return {
+            key[len(env_prefix) :].lower(): value
+            for key, value in os.environ.items()
+            if key.startswith(env_prefix)
+        }
+
+    @overload
+    def get(self, key: str) -> str | None: ...
+
+    @overload
+    def get(self, key: str, default: DefaultType = ...) -> str | DefaultType: ...
+
+    def get(self, key: str, default: DefaultType | None = None) -> str | DefaultType | None:
+        """Get a configuration value with priority: cmdline, env, file.
+
+        :param str key: Configuration key.
+        :param default: Default value if key is not found.
+
+        :returns: Configuration value.
+        """
+        return self._config_cmd.get(
+            key, self._config_env.get(key, self._config_file.get(key, default))
+        )
+
+    def set_cmd_config(self, cmd_config: dict[str, Any]) -> None:
+        """Set command line configuration options.
+
+        :param Dict[str, Any] cmd_config: Dictionary of command line configurations.
+        """
+        self._config_cmd.update(cmd_config)
+
+    def get_config(self, reload: bool = False) -> None:
+        """Load the configuration file into the class.
+
+        :param bool reload: Reload the configuration from the config file.
+        """
+        if not self._config_file or reload:
+            configpath = self.get_config_file()
+            if configpath is not None:
+                cfgparser = configparser.ConfigParser()
+                cfgparser.read(configpath)
+                self._config_file = dict(cfgparser["mreg"].items())
+
+    def get_logging_level(self) -> str:
+        """Get the current logging level by name.
+
+        :returns: The logging level by name.
+        """
+        return logging.getLevelName(logging.getLogger().getEffectiveLevel())
+
+    def set_logging_level(self, level: LogLevel) -> None:
+        """Set the logging level.
+
+        :param str level: The logging level to set (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        """
+        logging.getLogger().setLevel(level)
+
+    def start_logging(
+        self, logfile: str = DEFAULT_LOG_FILE, level: str | LogLevel = "INFO"
+    ) -> None:
+        """Enable and configure logging.
+
+        :param str logfile: Path to the logfile, defaults to DEFAULT_LOG_FILE.
+        :param str level: Logging level, defaults to 'INFO'.
+        """
+        level = LogLevel(level)
+        if self._is_logging:
+            logging.shutdown()
+            self._is_logging = False
+        else:
+            logging.basicConfig(
+                filename=logfile,
+                level=logging.getLevelName(level),
+                format=LOGGING_FORMAT,
+                datefmt="%Y-%m-%d %H:%M:%S",
+            )
+
+        logging.getLogger().setLevel(level)
+        self._is_logging = True
+        self._logfile = logfile
+
+    def get_logging_status(self) -> bool:
+        """Get the logging status.
+
+        :returns: True if logging is enabled, False otherwise.
+        """
+        return self._is_logging
+
+    def print_logging_status(self) -> None:
+        """Print the logging status."""
+        if self._is_logging:
+            print(f"Logging enabled to {self._logfile}")
+        else:
+            print("Logging is not enabled")
+
+    def stop_logging(self) -> None:
+        """Stop logging."""
+        logging.shutdown()
+        self._is_logging = False
+        self._logfile = None
+
+    def get_config_file(self) -> str | None:
+        """Get the first config file found in DEFAULT_CONFIG_PATH.
+
+        :returns: path to config file, or None if no config file was found
+        """
+        for path in DEFAULT_CONFIG_PATH:
+            logger.debug("looking for config in %r", os.path.abspath(path))
+            if os.path.isfile(path):
+                logger.info("found config in %r", path)
+                return path
+        logger.debug("no config file found in config paths")
+        return None
+
+    def get_default_domain(self):
+        """Get the default domain from the application."""
+        return self.get("domain", "uio.no")
+
+    def get_default_logfile(self):
+        """Get the default logfile from the application."""
+        return self.get("logfile", DEFAULT_LOG_FILE)
+
+    def get_location_tags(self) -> list[str]:
+        """Get the location tags from the application."""
+        return self.get("location_tags", "").split(",")
+
+    def get_category_tags(self) -> list[str]:
+        """Get the category tags from the application."""
+        return self.get("category_tags", "").split(",")
+
+    # We handle url by itself because it's a required config option,
+    # it cannot be none once options, env, and config file are parsed.
+    def get_url(self) -> str:
+        """Get the default url from the application."""
+        url = self.get("url", self.get("default_url", "https://mreg.uio.no"))
+        if not url:
+            raise ValueError("No URL found in config, no defaults available!")
+        return url
+
+    def _calculate_column_width(self, data: dict[str, Any], min_width: int = 8) -> int:
+        """Calculate the maximum column width, ensuring a minimum width.
+
+        :param data: Dictionary of data for the column.
+        :param min_width: Minimum width of the column.
+        :returns: Calculated column width.
+        """
+        max_length = max((len(str(value)) for value in data.values()), default=0)
+        return max(max_length, min_width) + 2  # Adding 2 for padding
+
+    def print_config_table(self) -> None:
+        """Pretty print the configuration options in a dynamic table format."""
+        all_keys = set(self._config_cmd) | set(self._config_env) | set(self._config_file)
+        key_width = max(max(len(key) for key in all_keys), 8) + 2
+
+        # Calculate column widths
+        cmd_width = self._calculate_column_width(self._config_cmd)
+        env_width = self._calculate_column_width(self._config_env)
+        file_width = self._calculate_column_width(self._config_file)
+
+        # Print the table header
+        print("Configuration Options:")
+        header_format = f"{{:<{key_width}}} {{:<{cmd_width}}} {{:<{env_width}}} {{:<{file_width}}}"
+        print(header_format.format("Key", "Active", "Envir", "File"))
+        print("-" * (key_width + cmd_width + env_width + file_width))
+
+        # Print each row
+        row_format = f"{{:<{key_width}}} {{:<{cmd_width}}} {{:<{env_width}}} {{:<{file_width}}}"
+        for key in sorted(all_keys):
+            cmd_line_val = str(self._config_cmd.get(key, "-"))
+            env_var_val = str(self._config_env.get(key, "-"))
+            config_file_val = str(self._config_file.get(key, "-"))
+            print(row_format.format(key, cmd_line_val, env_var_val, config_file_val))