pglift-cli 1.3.0__tar.gz

pglift_cli-1.3.0/.gitignore

@@ -0,0 +1,23 @@
+# SPDX-FileCopyrightText: 2021 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+docs/_build
+build/
+*/dist/
+.eggs/
+*.egg-info/
+*.egg
+*.py[cod]
+__pycache__/
+*.so
+*~
+
+.cache
+.coverage
+.pybuild
+.pytest_cache
+.mypy_cache
+.tox
+
+htmlcov

pglift_cli-1.3.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.1
+Name: pglift_cli
+Version: 1.3.0
+Summary: Command-line interface for pglift
+Project-URL: Documentation, https://pglift.readthedocs.io/
+Project-URL: Source, https://gitlab.com/dalibo/pglift/
+Project-URL: Tracker, https://gitlab.com/dalibo/pglift/-/issues/
+Author-email: Dalibo SCOP <contact@dalibo.com>
+License: GPLv3
+Keywords: administration,command-line,deployment,postgresql
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Database
+Classifier: Topic :: System :: Systems Administration
+Classifier: Typing :: Typed
+Requires-Python: <4,>=3.9
+Requires-Dist: click!=8.1.0,!=8.1.4,>=8.0.0
+Requires-Dist: filelock!=3.12.1,>=3.9.0
+Requires-Dist: pluggy
+Requires-Dist: psycopg>=3.1
+Requires-Dist: pydantic>=2.5.0
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: rich>=11.0.0
+Provides-Extra: dev
+Requires-Dist: pglift-cli[test,typing]; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: anyio; extra == 'test'
+Requires-Dist: patroni[etcd]>=2.1.5; extra == 'test'
+Requires-Dist: port-for; extra == 'test'
+Requires-Dist: prysk[pytest-plugin]>=0.14.0; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: trustme; extra == 'test'
+Provides-Extra: typing
+Requires-Dist: mypy>=1.8.0; extra == 'typing'
+Requires-Dist: types-pyyaml>=6.0.12.10; extra == 'typing'
+Description-Content-Type: text/markdown
+
+<!--
+SPDX-FileCopyrightText: 2024 Dalibo
+
+SPDX-License-Identifier: GPL-3.0-or-later
+-->
+
+This package provides the command-line interface for [pglift][]. It is a
+dependency package and should not be installed directly but rather through the
+``cli`` *optional dependency* (aka "extra") of the pglift package, e.g.:
+
+    $ pip install "pglift[cli]"
+
+[pglift]: https://pglift.readthedocs.io/

pglift_cli-1.3.0/README.md

@@ -0,0 +1,13 @@
+<!--
+SPDX-FileCopyrightText: 2024 Dalibo
+
+SPDX-License-Identifier: GPL-3.0-or-later
+-->
+
+This package provides the command-line interface for [pglift][]. It is a
+dependency package and should not be installed directly but rather through the
+``cli`` *optional dependency* (aka "extra") of the pglift package, e.g.:
+
+    $ pip install "pglift[cli]"
+
+[pglift]: https://pglift.readthedocs.io/

pglift_cli-1.3.0/hatch.toml

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2021 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+[version]
+source = "vcs"
+raw-options = { root = ".."}

pglift_cli-1.3.0/pyproject.toml

@@ -0,0 +1,79 @@
+# SPDX-FileCopyrightText: 2024 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pglift_cli"
+description = "Command-line interface for pglift"
+readme = "README.md"
+requires-python = ">=3.9, <4"
+license = { text = "GPLv3" }
+authors = [{ name = "Dalibo SCOP", email = "contact@dalibo.com" }]
+keywords = [
+    "postgresql",
+    "deployment",
+    "administration",
+    "command-line",
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "Topic :: System :: Systems Administration",
+    "Topic :: Database",
+    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3 :: Only",
+    "Typing :: Typed",
+]
+dynamic = ["version"]
+
+dependencies = [
+    "PyYAML >= 6.0.1",
+    "click >= 8.0.0, != 8.1.0, != 8.1.4",
+    "filelock >= 3.9.0, != 3.12.1",
+    "pluggy",
+    "psycopg >= 3.1",
+    "pydantic >= 2.5.0",
+    "rich >= 11.0.0",
+]
+
+[project.optional-dependencies]
+test = [
+    "anyio",
+    "patroni[etcd] >= 2.1.5",
+    "port-for",
+    "prysk[pytest-plugin] >= 0.14.0",
+    "pytest",
+    "pytest-cov",
+    "trustme",
+]
+typing = [
+    "mypy >= 1.8.0",
+    "types-PyYAML >= 6.0.12.10",
+]
+dev = [
+    "pglift_cli[test,typing]",
+]
+
+[project.urls]
+Documentation = "https://pglift.readthedocs.io/"
+Source = "https://gitlab.com/dalibo/pglift/"
+Tracker = "https://gitlab.com/dalibo/pglift/-/issues/"
+
+[project.entry-points.pglift]
+"pglift_cli.patroni" = "pglift_cli.patroni"
+"pglift_cli.pgbackrest" = "pglift_cli.pgbackrest"
+"pglift_cli.pgbackrest.repo_path" = "pglift_cli.pgbackrest.repo_path"
+"pglift_cli.prometheus" = "pglift_cli.prometheus"
+
+[project.scripts]
+pglift = "pglift_cli.main:cli"

pglift_cli-1.3.0/src/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-1.3.0/src/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-1.3.0/src/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-1.3.0/src/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-1.3.0/src/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-1.3.0/src/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-1.3.0/src/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-1.3.0/src/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