mreg-cli 1.0.0__py3-none-any.whl

mreg_cli/commands/group.py

@@ -0,0 +1,326 @@
+"""Hostgroups commands for mreg_cli."""
+
+from __future__ import annotations
+
+import argparse
+from typing import Any
+
+from mreg_cli.api.models import Host, HostGroup
+from mreg_cli.commands.base import BaseCommand
+from mreg_cli.commands.registry import CommandRegistry
+from mreg_cli.exceptions import CreateError, DeleteError, EntityNotFound, ForceMissing
+from mreg_cli.outputmanager import OutputManager
+from mreg_cli.types import Flag
+
+command_registry = CommandRegistry()
+
+
+class GroupCommands(BaseCommand):
+    """Group commands for the CLI."""
+
+    def __init__(self, cli: Any) -> None:
+        """Initialize the group commands."""
+        super().__init__(cli, command_registry, "group", "Manage hostgroups.", "Manage hostgroups")
+
+
+@command_registry.register_command(
+    prog="create",
+    description="Create a new host group",
+    short_desc="Create a new host group",
+    flags=[
+        Flag("name", description="Group name", metavar="NAME"),
+        Flag("description", description="Description", metavar="DESCRIPTION"),
+    ],
+)
+def create(args: argparse.Namespace) -> None:
+    """Create a new host group.
+
+    :param args: argparse.Namespace (name, description)
+    """
+    HostGroup.get_by_field_and_raise("name", args.name)
+    newgroup = HostGroup.create(params={"name": args.name, "description": args.description})
+    if not newgroup:
+        raise CreateError("Failed to create new group '{args.name}'")
+
+    OutputManager().add_ok(f"Created new group {newgroup.name}")
+
+
+@command_registry.register_command(
+    prog="info",
+    description="Shows group info with description, member count and owner(s)",
+    short_desc="Group info",
+    flags=[
+        Flag("name", description="Group name", nargs="+", metavar="NAME"),
+    ],
+)
+def info(args: argparse.Namespace) -> None:
+    """Show host group info.
+
+    :param args: argparse.Namespace (name)
+    """
+    for name in args.name:
+        HostGroup.get_by_name_or_raise(name).output()
+
+
+@command_registry.register_command(
+    prog="rename",
+    description="Rename a group",
+    short_desc="Rename a group",
+    flags=[
+        Flag("oldname", description="Existing name", metavar="OLDNAME"),
+        Flag("newname", description="New name", metavar="NEWNAME"),
+    ],
+)
+def rename(args: argparse.Namespace) -> None:
+    """Rename group.
+
+    :param args: argparse.Namespace (oldname, newname)
+    """
+    group = HostGroup.get_by_name_or_raise(args.oldname)
+    HostGroup.get_by_name_and_raise(args.newname)
+    group.rename(args.newname)
+    OutputManager().add_ok(f"Renamed group {args.oldname!r} to {args.newname!r}")
+
+
+@command_registry.register_command(
+    prog="list",
+    description="List group members",
+    short_desc="List group members",
+    flags=[
+        Flag("name", description="Group name", metavar="NAME"),
+        Flag("-expand", description="Expand group members", action="store_true"),
+    ],
+)
+def group_list(args: argparse.Namespace) -> None:
+    """List group members.
+
+    :param args: argparse.Namespace (name, expand)
+    """
+    group = HostGroup.get_by_name_or_raise(args.name)
+    group.output_members(expand=args.expand)
+
+
+@command_registry.register_command(
+    prog="delete",
+    description="Delete host group",
+    short_desc="Delete host group",
+    flags=[
+        Flag("name", description="Group name", metavar="NAME"),
+        Flag("-force", action="store_true", description="Enable force"),
+    ],
+)
+def group_delete(args: argparse.Namespace) -> None:
+    """Delete a host group.
+
+    :param args: argparse.Namespace (name, force)
+    """
+    group = HostGroup.get_by_name_or_raise(args.name)
+    if (group.hosts or group.groups) and not args.force:
+        raise ForceMissing("Group contains hosts or groups, must force")
+
+    if not group.delete():
+        raise DeleteError(f"Failed to delete group {args.name}")
+
+    OutputManager().add_ok(f"Deleted group {args.name!r}")
+
+
+@command_registry.register_command(
+    prog="group_add",
+    description="Add source group(s) to destination group",
+    short_desc="Add group(s) to group",
+    flags=[
+        Flag("dstgroup", description="destination group", metavar="DSTGROUP"),
+        Flag("srcgroup", description="source group", nargs="+", metavar="SRCGROUP"),
+    ],
+)
+def group_add(args: argparse.Namespace) -> None:
+    """Add group(s) to group.
+
+    :param args: argparse.Namespace (dstgroup, srcgroup)
+    """
+    sourcegroups = [HostGroup.get_by_name_or_raise(name) for name in args.srcgroup]
+    destgroup = HostGroup.get_by_name_or_raise(args.dstgroup)
+
+    for src in sourcegroups:
+        destgroup.add_group(src.name)
+        OutputManager().add_ok(f"Added group {src.name!r} to {destgroup.name!r}")
+
+
+@command_registry.register_command(
+    prog="group_remove",
+    description="Remove source group(s) from destination group",
+    short_desc="Remove group(s) from group",
+    flags=[
+        Flag("dstgroup", description="destination group", metavar="DSTGROUP"),
+        Flag("srcgroup", description="source group", nargs="+", metavar="SRCGROUP"),
+    ],
+)
+def group_remove(args: argparse.Namespace) -> None:
+    """Remove group(s) from group.
+
+    :param args: argparse.Namespace (dstgroup, srcgroup)
+    """
+    ownergroup = HostGroup.get_by_name_or_raise(args.dstgroup)
+
+    for name in args.srcgroup:
+        if not ownergroup.has_group(name):
+            raise EntityNotFound(f"Group {name!r} not a member in {ownergroup.name!r}")
+
+    for name in args.srcgroup:
+        ownergroup.remove_group(name)
+        OutputManager().add_ok(f"Removed group {name!r} from {ownergroup.name!r}")
+
+
+@command_registry.register_command(
+    prog="host_add",
+    description="Add host(s) to group",
+    short_desc="Add host(s) to group",
+    flags=[
+        Flag("group", description="group", metavar="GROUP"),
+        Flag("hosts", description="hosts", nargs="+", metavar="HOST"),
+    ],
+)
+def host_add(args: argparse.Namespace) -> None:
+    """Add host(s) to group.
+
+    :param args: argparse.Namespace (group, hosts)
+    """
+    hostgroup = HostGroup.get_by_name_or_raise(args.group)
+
+    for name in args.hosts:
+        host = Host.get_by_any_means_or_raise(name)
+        fqname = host.name.hostname
+        hostgroup.add_host(fqname)
+        OutputManager().add_ok(f"Added host {fqname!r} to {args.group!r}")
+
+
+@command_registry.register_command(
+    prog="host_remove",
+    description="Remove host(s) from group",
+    short_desc="Remove host(s) from group",
+    flags=[
+        Flag("group", description="group", metavar="GROUP"),
+        Flag("hosts", description="host", nargs="+", metavar="HOST"),
+    ],
+)
+def host_remove(args: argparse.Namespace) -> None:
+    """Remove host(s) from group.
+
+    :param args: argparse.Namespace (group, hosts)
+    """
+    hostgroup = HostGroup.get_by_name_or_raise(args.group)
+
+    to_remove: set[str] = set()
+    for name in args.hosts:
+        host = Host.get_by_any_means_or_raise(name)
+        fqname = host.name.hostname
+        if not hostgroup.has_host(fqname):
+            raise EntityNotFound(f"Host {name!r} ({fqname}) not a member in {args.group!r}")
+        to_remove.add(fqname)
+
+    for name in to_remove:
+        hostgroup.remove_host(name)
+        OutputManager().add_ok(f"Removed host {name!r} from {args.group!r}")
+
+
+@command_registry.register_command(
+    prog="host_list",
+    description="List host's group memberships",
+    short_desc="List host's group memberships",
+    flags=[
+        Flag("host", description="hostname", metavar="HOST"),
+        Flag(
+            "-traverse-hostgroups",
+            action="store_true",
+            description="Show memberships of all parent groups as well as direct groups.",
+            short_desc="Traverse hostgroups.",
+        ),
+    ],
+)
+def host_list(args: argparse.Namespace) -> None:
+    """List group memberships for host.
+
+    :param args: argparse.Namespace (host, traverse-hostgroups)
+    """
+    host = Host.get_by_any_means_or_raise(args.host)
+    HostGroup.output_multiple(host.hostgroups(traverse=args.traverse_hostgroups), multiline=True)
+
+
+@command_registry.register_command(
+    prog="owner_add",
+    description="Add owner(s) to group",
+    short_desc="Add owner(s) to group",
+    flags=[
+        Flag("group", description="group", metavar="GROUP"),
+        Flag("owners", description="owners", nargs="+", metavar="OWNER"),
+    ],
+)
+def owner_add(args: argparse.Namespace) -> None:
+    """Add owner(s) to group.
+
+    :param args: argparse.Namespace (group, owners)
+    """
+    hostgroup = HostGroup.get_by_name_or_raise(args.group)
+
+    for name in args.owners:
+        hostgroup.add_owner(name)
+        OutputManager().add_ok(f"Added owner {name!r} to {args.group!r}")
+
+
+@command_registry.register_command(
+    prog="owner_remove",
+    description="Remove owner(s) from group",
+    short_desc="Remove owner(s) from group",
+    flags=[
+        Flag("group", description="group", metavar="GROUP"),
+        Flag("owners", description="owner", nargs="+", metavar="OWNER"),
+    ],
+)
+def owner_remove(args: argparse.Namespace) -> None:
+    """Remove owner(s) from group.
+
+    :param args: argparse.Namespace (group, owners)
+    """
+    hostgroup = HostGroup.get_by_name_or_raise(args.group)
+
+    for name in args.owners:
+        if not hostgroup.has_owner(name):
+            raise EntityNotFound(f"Owner {name!r} not a member in {args.group!r}")
+
+    for name in args.owners:
+        hostgroup.remove_owner(name)
+        OutputManager().add_ok(f"Removed owner {name!r} from {args.group!r}")
+
+
+@command_registry.register_command(
+    prog="set_description",
+    description="Set description for group",
+    short_desc="Set description for group",
+    flags=[
+        Flag("name", description="Group", metavar="GROUP"),
+        Flag("description", description="Group description.", metavar="DESC"),
+    ],
+)
+def set_description(args: argparse.Namespace) -> None:
+    """Set description for group.
+
+    :param args: argparse.Namespace (name, description)
+    """
+    HostGroup.get_by_name_or_raise(args.name).set_description(args.description)
+    OutputManager().add_ok(f"Updated description to {args.description!r} for {args.name!r}")
+
+
+@command_registry.register_command(
+    prog="history",
+    description="Show history for group name",
+    short_desc="Show history for group name",
+    flags=[
+        Flag("name", description="Group name", metavar="NAME"),
+    ],
+)
+def history(args: argparse.Namespace) -> None:
+    """Show host history for name.
+
+    :param args: argparse.Namespace (name)
+    """
+    HostGroup.output_history(args.name)

mreg_cli/commands/help.py

@@ -0,0 +1,77 @@
+"""Help command for the CLI."""
+
+from __future__ import annotations
+
+import argparse
+from typing import Any
+
+from mreg_cli.commands.base import BaseCommand
+from mreg_cli.commands.registry import CommandRegistry
+from mreg_cli.config import MregCliConfig
+
+command_registry = CommandRegistry()
+
+
+class HelpCommands(BaseCommand):
+    """Help commands for the CLI."""
+
+    def __init__(self, cli: Any) -> None:
+        """Initialize the help commands."""
+        super().__init__(
+            cli,
+            command_registry,
+            "help",
+            "Show general help for the cli. Use `help -h` to see subtopics.",
+            "Help",
+            callback=lambda _: cli.parser.print_help(),
+        )
+
+
+@command_registry.register_command("filtering", "Show help for filtering.", "Filtering Help")
+def filtering_help(_: argparse.Namespace) -> None:
+    """Show help for filtering."""
+    print(
+        """`mreg-cli` support output filtering via the operators `|` and `|!`.
+
+The `|` operator is used to filter the output to only render the lines
+matching the regular expression specified after the operator. Using `|!`
+will show the lines _not_ matching.
+
+Note that if recording to a file, filters will be applied to the output
+as it would be to the terminal.
+
+Some examples:
+
+# No filtering
+mreg> host info one.example.com
+Name:         one.example.com
+Contact:      me@example.com
+A_Records     IP                           MAC
+              192.168.1.2                  aa:bb:cc:dd:ee:ff
+TTL:          (Default)
+TXT:          v=spf1 -all
+
+# Filter to only show lines containing "example"
+mreg> host info one.example.com | example
+Name:         one.example.com
+Contact:      me@example.com
+
+# Filter to only show lines containing "me" followed by "com"
+mreg> host info one.example.com | me.*com
+Contact:      me@example.com
+
+# Filter to only show lines _not_ containing "me" followed by "com"
+mreg> host info one.example.com |! me.*com
+Name:         one.example.com
+A_Records     IP                           MAC
+              192.168.1.2                  aa:bb:cc:dd:ee:ff
+TTL:          (Default)
+TXT:          v=spf1 -all
+"""
+    )
+
+
+@command_registry.register_command("configuration", "Show configuration", "Show configuration")
+def configuration_help(_: argparse.Namespace) -> None:
+    """Show configuration."""
+    MregCliConfig().print_config_table()

mreg_cli/commands/host.py

@@ -0,0 +1,54 @@
+"""The base host command module.
+
+There are a huge amount of commands in this module, so it is broken up into
+submodules. This base module contains the registry that the submodules
+add their commands to.
+"""
+
+from __future__ import annotations
+
+import importlib
+import os
+import pkgutil
+from typing import Any
+
+from mreg_cli.commands.base import BaseCommand
+from mreg_cli.commands.registry import CommandRegistry
+from mreg_cli.exceptions import InternalError
+
+registry = CommandRegistry()
+
+
+class HostCommands(BaseCommand):
+    """Host command module to register all subcommands."""
+
+    def __init__(self, cli: Any) -> None:
+        """Initialize the Host commands."""
+        super().__init__(cli, registry, "host", "Manage Hosts.", "Host Management")
+
+    # This is a class method that overrides the inherited method in a rather
+    # hacky way. The reason for this is that the host class is large enough
+    # that it is broken up into submodules, and each submodule registers its
+    # commands with the host class. This is done by importing the command
+    # registry directly from the host command module.
+    # The current design avoids circular imports, and removes the need to
+    # explicitly import each submodule by name in this scope.
+    def register_all_commands(self) -> None:
+        """Register all host subcommands from different modules."""
+        self._import_submodules()
+        super().register_all_commands()
+
+    def _import_submodules(self) -> None:
+        """Dynamically import all submodules in the host_submodules package."""
+        package_name = "mreg_cli.commands.host_submodules"
+        package = importlib.import_module(package_name)
+
+        # Get the directory path of the package
+        if package.__file__ is None:
+            raise InternalError(f"Unable to initalize host submodules from {package_name}")
+
+        package_dir = os.path.dirname(package.__file__)
+
+        # Import all submodules
+        for _, module_name, _ in pkgutil.iter_modules([package_dir]):
+            importlib.import_module(f"{package_name}.{module_name}")

mreg_cli/commands/host_submodules/__init__.py

@@ -0,0 +1,28 @@
+"""Submodules for the host command.
+
+The host command has a lot of subcommands, so they are broken up into
+submodules. Each of these modules registers their commands with the
+:py:class:`mreg_cli.commands.host.HostCommands` class, which is the main
+command class for the host command.
+
+This is done by importing the command registry directly from the host
+command module, which is a bit hacky, but it works.
+
+Note: This design will imply circular imports, so the core host command
+imports the submodules after it has been initialized.
+"""
+
+# We have to import each of the submodules explictly here in order to
+# ensure they are included when we build binaries with PyInstaller.
+# We also cannot do `from . import *`. Each module must be specified.
+from __future__ import annotations
+
+from . import a_aaaa, bacnet, cname, core, rr
+
+__all__ = [
+    "a_aaaa",
+    "bacnet",
+    "cname",
+    "core",
+    "rr",
+]