pglift-cli 1.3.0__py3-none-any.whl

pglift_cli/pgbackrest/__init__.py

@@ -0,0 +1,101 @@
+# SPDX-FileCopyrightText: 2021 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+import subprocess
+from datetime import datetime
+from typing import Any
+
+import click
+
+from pglift import pgbackrest, postgresql, types
+from pglift.models import system
+from pglift.pgbackrest import base, models
+from pglift.pgbackrest import register_if as register_if  # noqa: F401
+
+from .. import _site, hookimpl
+from ..util import (
+    Command,
+    Obj,
+    OutputFormat,
+    async_command,
+    instance_identifier,
+    instance_identifier_option,
+    model_dump,
+    output_format_option,
+    print_json_for,
+    print_table_for,
+)
+
+
+@click.command(
+    "pgbackrest",
+    hidden=True,
+    cls=Command,
+    context_settings={"ignore_unknown_options": True},
+)
+@instance_identifier_option
+@click.argument("command", nargs=-1, type=click.UNPROCESSED)
+@click.pass_context
+def pgbackrest_proxy(
+    context: click.Context, /, command: tuple[str, ...], **kwargs: Any
+) -> None:
+    """Proxy to pgbackrest operations on an instance"""
+    s = context.obj.instance.service(models.Service)
+    settings = pgbackrest.get_settings(_site.SETTINGS)
+    cmd_args = base.make_cmd(s.stanza, settings, *command)
+    try:
+        subprocess.run(cmd_args, capture_output=False, check=True)  # nosec
+    except subprocess.CalledProcessError as e:
+        raise click.ClickException(str(e)) from e
+
+
+@click.command("restore", cls=Command)
+@instance_identifier(nargs=1)
+@click.option("--label", help="Label of backup to restore")
+@click.option("--date", type=click.DateTime(), help="Date of backup to restore")
+@click.pass_obj
+@async_command
+async def instance_restore(
+    obj: Obj, instance: system.Instance, label: str | None, date: datetime | None
+) -> None:
+    """Restore PostgreSQL INSTANCE"""
+    await postgresql.check_status(instance, types.Status.not_running)
+    if label is not None and date is not None:
+        raise click.BadArgumentUsage(
+            "--label and --date arguments are mutually exclusive"
+        ) from None
+    settings = pgbackrest.get_settings(_site.SETTINGS)
+    with obj.lock:
+        await base.restore(instance, settings, label=label, date=date)
+
+
+@click.command("backups", cls=Command)
+@output_format_option
+@instance_identifier(nargs=1)
+@async_command
+async def instance_backups(
+    instance: system.Instance, output_format: OutputFormat
+) -> None:
+    """List available backups for INSTANCE"""
+    settings = pgbackrest.get_settings(_site.SETTINGS)
+    backups = [b async for b in base.iter_backups(instance, settings)]
+    if output_format == OutputFormat.json:
+        print_json_for([model_dump(b) for b in backups])
+    else:
+        print_table_for(
+            backups, model_dump, title=f"Available backups for instance {instance}"
+        )
+
+
+@hookimpl
+def command() -> click.Command:
+    return pgbackrest_proxy
+
+
+@hookimpl
+def add_instance_commands(group: click.Group) -> None:
+    group.add_command(instance_backups)
+    group.add_command(instance_restore)

pglift_cli/pgbackrest/repo_path.py

@@ -0,0 +1,40 @@
+# SPDX-FileCopyrightText: 2024 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+import click
+
+from pglift import pgbackrest, types
+from pglift.models import system
+from pglift.pgbackrest import repo_path
+from pglift.pgbackrest.repo_path import register_if as register_if  # noqa: F401
+
+from .. import _site, hookimpl
+from ..util import Command, Obj, async_command, instance_identifier
+
+
+@click.command("backup", cls=Command)
+@instance_identifier(nargs=1)
+@click.option(
+    "--type",
+    "backup_type",
+    type=click.Choice(types.BACKUP_TYPES),
+    default=types.DEFAULT_BACKUP_TYPE,
+    help="Backup type",
+)
+@click.pass_obj
+@async_command
+async def instance_backup(
+    obj: Obj, instance: system.Instance, backup_type: types.BackupType
+) -> None:
+    """Back up PostgreSQL INSTANCE"""
+    settings = pgbackrest.get_settings(_site.SETTINGS)
+    with obj.lock:
+        await repo_path.backup(instance, settings, type=backup_type)
+
+
+@hookimpl
+def add_instance_commands(group: click.Group) -> None:
+    group.add_command(instance_backup)

pglift_cli/pgconf.py

@@ -0,0 +1,151 @@
+# SPDX-FileCopyrightText: 2021 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any
+
+import click
+import pgtoolkit.conf
+
+from pglift import h, hook, instances, postgresql
+from pglift.models import system
+from pglift.types import ConfigChanges, Status
+
+from .util import Group, Obj, async_command, instance_identifier_option, pass_instance
+
+
+@click.group(cls=Group)
+@instance_identifier_option
+def cli(**kwargs: Any) -> None:
+    """Manage configuration of a PostgreSQL instance."""
+
+
+def show_configuration_changes(
+    changes: ConfigChanges, parameters: Iterable[str] | None = None
+) -> None:
+    for param, (old, new) in sorted(changes.items()):
+        click.secho(f"{param}: {old} -> {new}", err=True, fg="green")
+    if parameters is None:
+        return
+    if unchanged := set(parameters) - set(changes):
+        click.secho(
+            f"changes in {', '.join(map(repr, sorted(unchanged)))} not applied",
+            err=True,
+            fg="red",
+        )
+        click.secho(
+            " hint: either these changes have no effect (values already set) "
+            "or specified parameters are already defined in an un-managed file "
+            "(e.g. 'postgresql.conf')",
+            err=True,
+            fg="blue",
+        )
+
+
+@cli.command("show")
+@click.argument("parameter", nargs=-1)
+@pass_instance
+def show(instance: system.Instance, parameter: tuple[str]) -> None:
+    """Show configuration (all parameters or specified ones).
+
+    Only uncommented parameters are shown when no PARAMETER is specified. When
+    specific PARAMETERs are queried, commented values are also shown.
+    """
+    config = instance.config()
+    for entry in config.entries.values():
+        if parameter:
+            if entry.name in parameter:
+                if entry.commented:
+                    click.echo(f"# {entry.name} = {entry.serialize()}")
+                else:
+                    click.echo(f"{entry.name} = {entry.serialize()}")
+        elif not entry.commented:
+            click.echo(f"{entry.name} = {entry.serialize()}")
+
+
+def validate_configuration_parameters(
+    context: click.Context, param: click.Parameter, value: tuple[str]
+) -> dict[str, str]:
+    items = {}
+    for v in value:
+        try:
+            key, val = v.split("=", 1)
+        except ValueError:
+            raise click.BadParameter(v) from None
+        items[key] = val
+    return items
+
+
+@cli.command("set")
+@click.argument(
+    "parameters",
+    metavar="<PARAMETER>=<VALUE>...",
+    nargs=-1,
+    callback=validate_configuration_parameters,
+    required=True,
+)
+@pass_instance
+@click.pass_obj
+@async_command
+async def set_(obj: Obj, instance: system.Instance, parameters: dict[str, Any]) -> None:
+    """Set configuration items."""
+    with obj.lock:
+        status = await postgresql.status(instance)
+        manifest = await instances._get(instance, status)
+        manifest.settings.update(parameters)
+        changes = await instances.configure(
+            instance, manifest, _is_running=status == Status.running
+        )
+        show_configuration_changes(changes, parameters.keys())
+
+
+@cli.command("remove")
+@click.argument("parameters", nargs=-1, required=True)
+@pass_instance
+@click.pass_obj
+@async_command
+async def remove(obj: Obj, instance: system.Instance, parameters: tuple[str]) -> None:
+    """Remove configuration items."""
+    with obj.lock:
+        status = await postgresql.status(instance)
+        manifest = await instances._get(instance, status)
+        for p in parameters:
+            try:
+                del manifest.settings[p]
+            except KeyError:
+                raise click.ClickException(
+                    f"{p!r} not found in managed configuration"
+                ) from None
+        changes = await instances.configure(
+            instance, manifest, _is_running=status == Status.running
+        )
+        show_configuration_changes(changes, parameters)
+
+
+@cli.command("edit")
+@pass_instance
+@click.pass_obj
+@async_command
+async def edit(obj: Obj, instance: system.Instance) -> None:
+    """Edit managed configuration."""
+    with obj.lock:
+        actual_config = hook(
+            instance._settings, h.postgresql_editable_conf, instance=instance
+        )
+        edited = click.edit(text=actual_config)
+        if edited is None:
+            click.echo("no change", err=True)
+            return
+        config = pgtoolkit.conf.parse_string(edited)
+        values = config.as_dict()
+        status = await postgresql.status(instance)
+        manifest = await instances._get(instance, status)
+        manifest.settings.clear()
+        manifest.settings.update(values)
+        changes = await instances.configure(
+            instance, manifest, _is_running=status == Status.running
+        )
+        show_configuration_changes(changes)

pglift_cli/pm.py

@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: 2024 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+from pglift.pm import PluginManager as BasePluginManager
+
+from . import __name__ as pkgname
+
+
+class PluginManager(BasePluginManager):
+    ns = pkgname
+    modules = (
+        "patroni",
+        "pgbackrest",
+        "pgbackrest.repo_path",
+        "prometheus",
+    )

pglift_cli/postgres.py

@@ -0,0 +1,30 @@
+# SPDX-FileCopyrightText: 2021 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+import click
+
+from pglift.cmd import execute_program
+from pglift.exceptions import InstanceNotFound
+from pglift.models import system
+
+from . import _site
+
+
+def instance_from_qualname(
+    context: click.Context, param: click.Parameter, value: str
+) -> system.PostgreSQLInstance:
+    try:
+        return system.PostgreSQLInstance.from_qualname(value, _site.SETTINGS)
+    except (ValueError, InstanceNotFound) as e:
+        raise click.BadParameter(str(e), context) from None
+
+
+@click.command("postgres", hidden=True)
+@click.argument("instance", callback=instance_from_qualname)
+def cli(instance: system.Instance) -> None:
+    """Start postgres for specified INSTANCE, identified as <version>-<name>."""
+    cmd = [str(instance.bindir / "postgres"), "-D", str(instance.datadir)]
+    execute_program(cmd)

pglift_cli/prometheus.py

@@ -0,0 +1,138 @@
+# SPDX-FileCopyrightText: 2021 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+from functools import partial
+from typing import IO
+
+import click
+
+from pglift import exceptions, prometheus, task
+from pglift.models import interface
+from pglift.prometheus import impl, models
+from pglift.prometheus import register_if as register_if  # noqa: F401
+
+from . import _site, hookimpl, model
+from .util import (
+    Group,
+    Obj,
+    OutputFormat,
+    async_command,
+    dry_run_option,
+    foreground_option,
+    output_format_option,
+    print_argspec,
+    print_json_for,
+    print_schema,
+)
+
+
+@click.group("postgres_exporter", cls=Group)
+@click.option(
+    "--schema",
+    is_flag=True,
+    callback=partial(print_schema, model=models.PostgresExporter),
+    expose_value=False,
+    is_eager=True,
+    help="Print the JSON schema of postgres_exporter model and exit.",
+)
+@click.option(
+    "--ansible-argspec",
+    is_flag=True,
+    callback=partial(print_argspec, model=models.PostgresExporter),
+    expose_value=False,
+    is_eager=True,
+    hidden=True,
+    help="Print the Ansible argspec of postgres_exporter model and exit.",
+)
+def cli() -> None:
+    """Handle Prometheus postgres_exporter"""
+
+
+@cli.command("apply")
+@click.option("-f", "--file", type=click.File("r"), metavar="MANIFEST", required=True)
+@output_format_option
+@dry_run_option
+@click.pass_obj
+@async_command
+async def apply(
+    obj: Obj, file: IO[str], output_format: OutputFormat, dry_run: bool
+) -> None:
+    """Apply manifest as a Prometheus postgres_exporter."""
+    exporter = models.PostgresExporter.parse_yaml(file)
+    if dry_run:
+        ret = interface.ApplyResult(change_state=None)
+    else:
+        settings = prometheus.get_settings(_site.SETTINGS)
+        with obj.lock:
+            ret = await impl.apply(exporter, _site.SETTINGS, settings)
+    if output_format == OutputFormat.json:
+        print_json_for(ret)
+
+
+@cli.command("install")
+@model.as_parameters(models.PostgresExporter, "create")
+@click.pass_obj
+@async_command
+async def install(obj: Obj, postgresexporter: models.PostgresExporter) -> None:
+    """Install the service for a (non-local) instance."""
+    settings = prometheus.get_settings(_site.SETTINGS)
+    with obj.lock:
+        async with task.async_transaction():
+            await impl.apply(postgresexporter, _site.SETTINGS, settings)
+
+
+@cli.command("uninstall")
+@click.argument("name")
+@click.pass_obj
+@async_command
+async def uninstall(obj: Obj, name: str) -> None:
+    """Uninstall the service."""
+    with obj.lock:
+        await impl.drop(_site.SETTINGS, name)
+
+
+@cli.command("start")
+@click.argument("name")
+@foreground_option
+@click.pass_obj
+@async_command
+async def start(obj: Obj, name: str, foreground: bool) -> None:
+    """Start postgres_exporter service NAME.
+
+    The NAME argument is a local identifier for the postgres_exporter
+    service. If the service is bound to a local instance, it should be
+    <version>-<name>.
+    """
+    settings = prometheus.get_settings(_site.SETTINGS)
+    with obj.lock:
+        service = impl.system_lookup(name, settings)
+        if service is None:
+            raise exceptions.InstanceNotFound(name)
+        await impl.start(_site.SETTINGS, service, foreground=foreground)
+
+
+@cli.command("stop")
+@click.argument("name")
+@click.pass_obj
+@async_command
+async def stop(obj: Obj, name: str) -> None:
+    """Stop postgres_exporter service NAME.
+
+    The NAME argument is a local identifier for the postgres_exporter
+    service. If the service is bound to a local instance, it should be
+    <version>-<name>.
+    """
+    settings = prometheus.get_settings(_site.SETTINGS)
+    with obj.lock:
+        service = impl.system_lookup(name, settings)
+        if service is None:
+            raise exceptions.InstanceNotFound(name)
+        await impl.stop(_site.SETTINGS, service)
+
+
+@hookimpl
+def command() -> click.Group:
+    return cli

pglift_cli/role.py

@@ -0,0 +1,197 @@
+# SPDX-FileCopyrightText: 2021 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from functools import partial
+from typing import IO, Any
+
+import click
+from pydantic.v1.utils import deep_update
+
+from pglift import postgresql, privileges, roles
+from pglift.models import interface, system
+
+from . import _site, model
+from .util import (
+    Group,
+    Obj,
+    OutputFormat,
+    async_command,
+    dry_run_option,
+    instance_identifier_option,
+    model_dump,
+    output_format_option,
+    pass_instance,
+    print_argspec,
+    print_json_for,
+    print_schema,
+    print_table_for,
+)
+
+
+def print_role_schema(
+    context: click.Context, param: click.Parameter, value: bool
+) -> None:
+    return print_schema(context, param, value, model=_site.ROLE_MODEL)
+
+
+def print_role_argspec(
+    context: click.Context, param: click.Parameter, value: bool
+) -> None:
+    print_argspec(context, param, value, model=_site.ROLE_MODEL)
+
+
+@click.group("role", cls=Group)
+@instance_identifier_option
+@click.option(
+    "--schema",
+    is_flag=True,
+    callback=print_role_schema,
+    expose_value=False,
+    is_eager=True,
+    help="Print the JSON schema of role model and exit.",
+)
+@click.option(
+    "--ansible-argspec",
+    is_flag=True,
+    callback=print_role_argspec,
+    expose_value=False,
+    is_eager=True,
+    hidden=True,
+    help="Print the Ansible argspec of role model and exit.",
+)
+def cli(**kwargs: Any) -> None:
+    """Manage roles."""
+
+
+@cli.command("create")
+@model.as_parameters(_site.ROLE_MODEL, "create")
+@pass_instance
+@click.pass_obj
+@async_command
+async def create(obj: Obj, instance: system.Instance, role: interface.Role) -> None:
+    """Create a role in a PostgreSQL instance"""
+    with obj.lock:
+        async with postgresql.running(instance):
+            if await roles.exists(instance, role.name):
+                raise click.ClickException("role already exists")
+            await roles.apply(instance, role)
+
+
+@cli.command("alter")  # type: ignore[arg-type]
+@model.as_parameters(_site.ROLE_MODEL, "update", parse_model=False)
+@click.argument("rolname")
+@pass_instance
+@click.pass_obj
+@async_command
+async def alter(
+    obj: Obj, instance: system.Instance, rolname: str, **changes: Any
+) -> None:
+    """Alter a role in a PostgreSQL instance"""
+    with obj.lock:
+        async with postgresql.running(instance):
+            values = (await roles.get(instance, rolname)).model_dump(by_alias=True)
+            values = deep_update(values, changes)
+            altered = _site.ROLE_MODEL.model_validate(values)
+            await roles.apply(instance, altered)
+
+
+@cli.command("apply", hidden=True)
+@click.option("-f", "--file", type=click.File("r"), metavar="MANIFEST", required=True)
+@output_format_option
+@dry_run_option
+@pass_instance
+@click.pass_obj
+@async_command
+async def apply(
+    obj: Obj,
+    instance: system.Instance,
+    file: IO[str],
+    output_format: OutputFormat,
+    dry_run: bool,
+) -> None:
+    """Apply manifest as a role"""
+    role = _site.ROLE_MODEL.parse_yaml(file)
+    if dry_run:
+        ret = interface.ApplyResult(change_state=None)
+    else:
+        with obj.lock:
+            async with postgresql.running(instance):
+                ret = await roles.apply(instance, role)
+    if output_format == OutputFormat.json:
+        print_json_for(ret)
+
+
+@cli.command("list")
+@output_format_option
+@pass_instance
+@async_command
+async def ls(instance: system.Instance, output_format: OutputFormat) -> None:
+    """List roles in instance"""
+    async with postgresql.running(instance):
+        rls = await roles.ls(instance)
+    if output_format == OutputFormat.json:
+        print_json_for([model_dump(r) for r in rls])
+    else:
+        print_table_for(rls, partial(model_dump, exclude={"pgpass"}))
+
+
+@cli.command("get")
+@output_format_option
+@click.argument("name")
+@pass_instance
+@async_command
+async def get(
+    instance: system.Instance, name: str, output_format: OutputFormat
+) -> None:
+    """Get the description of a role"""
+    async with postgresql.running(instance):
+        r = await roles.get(instance, name)
+    if output_format == OutputFormat.json:
+        print_json_for(model_dump(r))
+    else:
+        print_table_for([r], model_dump, box=None)
+
+
+@cli.command("drop")
+@model.as_parameters(interface.RoleDropped, "create")
+@pass_instance
+@async_command
+async def drop(instance: system.Instance, roledropped: interface.RoleDropped) -> None:
+    """Drop a role"""
+    async with postgresql.running(instance):
+        await roles.drop(instance, roledropped)
+
+
+@cli.command("privileges")
+@click.argument("name")
+@click.option(
+    "-d", "--database", "databases", multiple=True, help="Database to inspect"
+)
+@click.option("--default", "defaults", is_flag=True, help="Display default privileges")
+@output_format_option
+@pass_instance
+@async_command
+async def list_privileges(
+    instance: system.Instance,
+    name: str,
+    databases: Sequence[str],
+    defaults: bool,
+    output_format: OutputFormat,
+) -> None:
+    """List privileges of a role."""
+    async with postgresql.running(instance):
+        await roles.get(instance, name)  # check existence
+        try:
+            prvlgs = await privileges.get(
+                instance, databases=databases, roles=(name,), defaults=defaults
+            )
+        except ValueError as e:
+            raise click.ClickException(str(e)) from None
+    if output_format == OutputFormat.json:
+        print_json_for([model_dump(p) for p in prvlgs])
+    else:
+        print_table_for(prvlgs, model_dump)