pglift-cli 1.3.0__py3-none-any.whl

pglift_cli/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2024 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import pluggy
+
+hookimpl = pluggy.HookimplMarker(__name__)

pglift_cli/__main__.py

@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: 2021 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+from .main import cli
+
+if __name__ == "__main__":
+    cli(prog_name="pglift")

pglift_cli/_settings.py

@@ -0,0 +1,44 @@
+# SPDX-FileCopyrightText: 2021 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from pathlib import Path
+from typing import Annotated
+
+from pydantic import Field
+
+from pglift.settings import Settings as BaseSettings
+from pglift.settings import SiteSettings as BaseSiteSettings
+from pglift.settings.base import BaseModel, LogPath, RunPath
+
+
+class CLISettings(BaseModel):
+    """Settings for pglift's command-line interface."""
+
+    logpath: Annotated[
+        Annotated[Path, LogPath],
+        Field(
+            description="Directory where temporary log files from command executions will be stored",
+            title="CLI log directory",
+        ),
+    ] = Path()
+
+    log_format: Annotated[
+        str, Field(description="Format for log messages when written to a file")
+    ] = "%(asctime)s %(levelname)-8s %(name)s - %(message)s"
+
+    date_format: Annotated[
+        str, Field(description="Date format in log messages when written to a file")
+    ] = "%Y-%m-%d %H:%M:%S"
+
+    lock_file: Annotated[
+        Path, RunPath, Field(description="Path to lock file dedicated to pglift")
+    ] = Path(".pglift.lock")
+
+
+class Settings(BaseSettings):
+    cli: Annotated[CLISettings, Field(default_factory=CLISettings)]
+
+
+class SiteSettings(Settings, BaseSiteSettings):
+    pass

pglift_cli/_site.py

@@ -0,0 +1,34 @@
+# SPDX-FileCopyrightText: 2024 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from typing import Final
+
+import click
+import pydantic
+
+from pglift import exceptions, plugin_manager
+from pglift.models import interface
+
+from . import hookspecs
+from ._settings import Settings, SiteSettings
+from .pm import PluginManager
+
+
+def _load_settings() -> Settings:
+    try:
+        return SiteSettings()
+    except (exceptions.SettingsError, pydantic.ValidationError) as e:
+        raise click.ClickException(f"invalid site settings\n{e}") from e
+    except exceptions.UnsupportedError as e:
+        raise click.ClickException(f"unsupported operation: {e}") from None
+
+
+SETTINGS: Final = _load_settings()
+DEFAULT_SETTINGS: Final = Settings()
+
+PLUGIN_MANAGER = PluginManager.get(SETTINGS, hookspecs)
+
+pm = plugin_manager(SETTINGS)
+INSTANCE_MODEL: Final = interface.Instance.composite(pm)
+ROLE_MODEL: Final = interface.Role.composite(pm)

pglift_cli/base.py

@@ -0,0 +1,53 @@
+# SPDX-FileCopyrightText: 2024 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+from collections import OrderedDict
+
+import click
+
+from pglift import hooks
+
+from . import _site, database
+from . import hookspecs as h
+from . import instance, pgconf, postgres, role
+
+
+class CLIGroup(click.Group):
+    """Group gathering main commands (defined here), commands from submodules
+    and commands from plugins.
+    """
+
+    submodules = OrderedDict(
+        [
+            ("instance", instance.cli),
+            ("pgconf", pgconf.cli),
+            ("role", role.cli),
+            ("database", database.cli),
+            ("postgres", postgres.cli),
+        ]
+    )
+
+    def list_commands(self, context: click.Context) -> list[str]:
+        main_commands = super().list_commands(context)
+        plugins_commands: list[str] = sorted(g.name for g in hooks(_site.PLUGIN_MANAGER, h.command))  # type: ignore[misc]
+        return main_commands + list(self.submodules) + plugins_commands
+
+    def get_command(self, context: click.Context, name: str) -> click.Command | None:
+        main_command = super().get_command(context, name)
+        if main_command is not None:
+            return main_command
+        try:
+            command = self.submodules[name]
+        except KeyError:
+            pass
+        else:
+            assert isinstance(command, click.Command), command
+            return command
+        for group in hooks(_site.PLUGIN_MANAGER, h.command):
+            assert isinstance(group, click.Command)
+            if group.name == name:
+                return group
+        return None

pglift_cli/console.py

@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: 2024 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from typing import Final
+
+from rich.console import Console
+
+console: Final = Console()

pglift_cli/database.py

@@ -0,0 +1,260 @@
+# SPDX-FileCopyrightText: 2021 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+import functools
+from collections.abc import Sequence
+from pathlib import Path
+from typing import IO, Any
+
+import click
+import psycopg
+from pydantic.v1.utils import deep_update
+
+from pglift import databases, postgresql, privileges, task
+from pglift.models import interface, system
+
+from . import 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,
+)
+
+
+@click.group("database", cls=Group)
+@instance_identifier_option
+@click.option(
+    "--schema",
+    is_flag=True,
+    callback=functools.partial(print_schema, model=interface.Database),
+    expose_value=False,
+    is_eager=True,
+    help="Print the JSON schema of database model and exit.",
+)
+@click.option(
+    "--ansible-argspec",
+    is_flag=True,
+    callback=functools.partial(print_argspec, model=interface.Database),
+    expose_value=False,
+    is_eager=True,
+    hidden=True,
+    help="Print the Ansible argspec of database model and exit.",
+)
+def cli(**kwargs: Any) -> None:
+    """Manage databases."""
+
+
+@cli.command("create")
+@model.as_parameters(interface.Database, "create")
+@pass_instance
+@click.pass_obj
+@async_command
+async def create(
+    obj: Obj, instance: system.Instance, database: interface.Database
+) -> None:
+    """Create a database in a PostgreSQL instance"""
+    with obj.lock:
+        async with postgresql.running(instance):
+            if await databases.exists(instance, database.name):
+                raise click.ClickException("database already exists")
+            async with task.async_transaction():
+                await databases.apply(instance, database)
+
+
+@cli.command("alter")  # type: ignore[arg-type]
+@model.as_parameters(interface.Database, "update", parse_model=False)
+@click.argument("dbname")
+@pass_instance
+@click.pass_obj
+@async_command
+async def alter(
+    obj: Obj, instance: system.Instance, dbname: str, **changes: Any
+) -> None:
+    """Alter a database in a PostgreSQL instance"""
+    with obj.lock:
+        async with postgresql.running(instance):
+            values = (await databases.get(instance, dbname)).model_dump(by_alias=True)
+            values = deep_update(values, changes)
+            altered = interface.Database.model_validate(values)
+            await databases.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 database"""
+    database = interface.Database.parse_yaml(file)
+    if dry_run:
+        ret = interface.ApplyResult(change_state=None)
+    else:
+        with obj.lock:
+            async with postgresql.running(instance):
+                ret = await databases.apply(instance, database)
+    if output_format == OutputFormat.json:
+        print_json_for(ret)
+
+
+@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 database"""
+    async with postgresql.running(instance):
+        db = await databases.get(instance, name)
+    if output_format == OutputFormat.json:
+        print_json_for(model_dump(db))
+    else:
+        print_table_for(
+            [db],
+            functools.partial(model_dump, exclude={"extensions", "schemas"}),
+            box=None,
+        )
+
+
+@cli.command("list")
+@output_format_option
+@click.argument("dbname", nargs=-1)
+@pass_instance
+@async_command
+async def ls(
+    instance: system.Instance, dbname: Sequence[str], output_format: OutputFormat
+) -> None:
+    """List databases (all or specified ones)
+
+    Only queried databases are shown when DBNAME is specified.
+    """
+
+    async with postgresql.running(instance):
+        dbs = await databases.ls(instance, dbnames=dbname)
+    if output_format == OutputFormat.json:
+        print_json_for([model_dump(db) for db in dbs])
+    else:
+        print_table_for(dbs, model_dump)
+
+
+@cli.command("drop")
+@model.as_parameters(interface.DatabaseDropped, "create")
+@pass_instance
+@click.pass_obj
+@async_command
+async def drop(
+    obj: Obj, instance: system.Instance, databasedropped: interface.DatabaseDropped
+) -> None:
+    """Drop a database"""
+    with obj.lock:
+        async with postgresql.running(instance):
+            await databases.drop(instance, databasedropped)
+
+
+@cli.command("privileges")
+@click.argument("name")
+@click.option("-r", "--role", "roles", multiple=True, help="Role 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,
+    roles: Sequence[str],
+    defaults: bool,
+    output_format: OutputFormat,
+) -> None:
+    """List privileges on a database."""
+    async with postgresql.running(instance):
+        await databases.get(instance, name)  # check existence
+        try:
+            prvlgs = await privileges.get(
+                instance, databases=(name,), roles=roles, 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)
+
+
+@cli.command("run")
+@click.argument("sql_command")
+@click.option(
+    "-d", "--database", "dbnames", multiple=True, help="Database to run command on"
+)
+@click.option(
+    "-x",
+    "--exclude-database",
+    "exclude_dbnames",
+    multiple=True,
+    help="Database to not run command on",
+)
+@output_format_option
+@pass_instance
+@async_command
+async def run(
+    instance: system.Instance,
+    sql_command: str,
+    dbnames: Sequence[str],
+    exclude_dbnames: Sequence[str],
+    output_format: OutputFormat,
+) -> None:
+    """Run given command on databases of a PostgreSQL instance"""
+    async with postgresql.running(instance):
+        try:
+            result = await databases.run(
+                instance,
+                sql_command,
+                dbnames=dbnames,
+                exclude_dbnames=exclude_dbnames,
+            )
+        except psycopg.ProgrammingError as e:
+            raise click.ClickException(str(e)) from None
+    if output_format == OutputFormat.json:
+        print_json_for(result)
+    else:
+        for dbname, rows in result.items():
+            print_table_for(rows, lambda m: m, title=f"Database {dbname}")
+
+
+@cli.command("dump")
+@click.option(
+    "-o",
+    "--output",
+    metavar="DIRECTORY",
+    type=click.Path(exists=True, file_okay=False, dir_okay=True, path_type=Path),
+    help="Write dump file(s) to DIRECTORY instead of configured 'dumps_directory'.",
+)
+@click.argument("dbname")
+@pass_instance
+@async_command
+async def dump(instance: system.Instance, dbname: str, output: Path | None) -> None:
+    """Dump a database"""
+    async with postgresql.running(instance):
+        await databases.dump(instance, dbname, output)

pglift_cli/hookspecs.py

@@ -0,0 +1,24 @@
+# SPDX-FileCopyrightText: 2024 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+import click
+import pluggy
+
+from . import __name__ as pkgname
+
+hookspec = pluggy.HookspecMarker(pkgname)
+
+
+@hookspec
+def command() -> click.Command:
+    """Return command-line entry point as click Command (or Group) for the plugin."""
+    raise NotImplementedError
+
+
+@hookspec
+def add_instance_commands(group: click.Group) -> None:
+    """Extend instance commands 'group' with extra commands from the plugin."""
+    raise NotImplementedError