pglift-cli 1.3.0__py3-none-any.whl

pglift_cli/main.py

@@ -0,0 +1,277 @@
+# SPDX-FileCopyrightText: 2021 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+import logging
+import pathlib
+import sys
+import warnings
+from functools import partial
+from importlib.metadata import version
+from typing import Literal
+
+import click
+import click.exceptions
+import rich.logging
+import rich.text
+import rich.tree
+import yaml
+from rich.console import Console
+from rich.highlighter import NullHighlighter
+from rich.syntax import Syntax
+
+from pglift import install, ui
+from pglift._compat import assert_never
+
+from . import __name__ as pkgname
+from . import _site
+from ._settings import Settings
+from .base import CLIGroup
+from .console import console as console
+from .util import (
+    InteractiveUserInterface,
+    LogDisplayer,
+    Obj,
+    OutputFormat,
+    async_command,
+    output_format_option,
+)
+
+
+def completion(
+    context: click.Context,
+    param: click.Parameter,
+    value: Literal["bash", "fish", "zsh"],
+) -> None:
+    if not value or context.resilient_parsing:
+        return
+    shell_complete_class_map = {
+        "bash": click.shell_completion.BashComplete,
+        "fish": click.shell_completion.FishComplete,
+        "zsh": click.shell_completion.ZshComplete,
+    }
+    click.echo(
+        shell_complete_class_map[value](cli, {}, "pglift", "_PGLIFT_COMPLETE").source(),
+        nl=False,
+    )
+    context.exit()
+
+
+def print_version(context: click.Context, param: click.Parameter, value: bool) -> None:
+    if not value or context.resilient_parsing:
+        return
+    cli_version, lib_version = version(pkgname), version("pglift")
+    if cli_version == lib_version:
+        click.echo(f"pglift version {cli_version}")
+    else:
+        click.echo(
+            f"pglift version {version(pkgname)} (library version {version('pglift')})"
+        )
+    context.exit()
+
+
+def log_level(
+    context: click.Context, param: click.Parameter, value: str | None
+) -> int | None:
+    if value is None:
+        return None
+    return getattr(logging, value)  # type: ignore[no-any-return]
+
+
+@click.group(cls=CLIGroup)
+@click.option(
+    "-L",
+    "--log-level",
+    type=click.Choice(
+        ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"], case_sensitive=False
+    ),
+    default=None,
+    callback=log_level,
+    help="Set log threshold (default to INFO when logging to stderr or WARNING when logging to a file).",
+)
+@click.option(
+    "-l",
+    "--log-file",
+    type=click.Path(dir_okay=False, resolve_path=True, path_type=pathlib.Path),
+    metavar="LOGFILE",
+    help="Write logs to LOGFILE, instead of stderr.",
+)
+@click.option(
+    "--debug",
+    is_flag=True,
+    default=False,
+    hidden=True,
+    help="Set log level to DEBUG and eventually display tracebacks.",
+)
+@click.option(
+    "--interactive/--non-interactive",
+    default=True,
+    help=(
+        "Interactively prompt for confirmation when needed (the default), "
+        "or automatically pick the default option for all choices."
+    ),
+)
+@click.option(
+    "--version",
+    is_flag=True,
+    callback=print_version,
+    expose_value=False,
+    is_eager=True,
+    help="Show program version.",
+)
+@click.option(
+    "--completion",
+    type=click.Choice(["bash", "fish", "zsh"]),
+    callback=completion,
+    expose_value=False,
+    is_eager=True,
+    help="Output completion for specified shell and exit.",
+)
+@click.pass_context
+def cli(
+    context: click.Context,
+    log_level: int | None,
+    log_file: pathlib.Path | None,
+    debug: bool,
+    interactive: bool,
+) -> None:
+    """Deploy production-ready instances of PostgreSQL"""
+    if (cli_version := version(pkgname)) != (lib_version := version("pglift")):
+        warnings.warn(
+            f"possibly incompatible versions of the library and CLI packages: {lib_version}, {cli_version}",
+            RuntimeWarning,
+            stacklevel=1,
+        )
+    if not context.obj:
+        context.obj = Obj(
+            displayer=None if log_file else LogDisplayer(),
+            debug=debug,
+        )
+    else:
+        assert isinstance(context.obj, Obj), context.obj
+
+    ui_token: ui.Token | None = None
+    if interactive:
+        ui_token = ui.set(InteractiveUserInterface())
+
+    loggers = [logging.getLogger(n) for n in ("pglift", "dotenv", "filelock")]
+    for logger in loggers:
+        logger.setLevel(logging.DEBUG)
+    if debug:
+        log_level = logging.DEBUG
+    handler: logging.Handler | rich.logging.RichHandler
+    if log_file or not sys.stderr.isatty():
+        if log_file:
+            handler = logging.FileHandler(log_file)
+            context.call_on_close(handler.close)
+        else:
+            handler = logging.StreamHandler(sys.stderr)
+        cli_settings = _site.SETTINGS.cli
+        formatter = logging.Formatter(
+            fmt=cli_settings.log_format, datefmt=cli_settings.date_format
+        )
+        handler.setFormatter(formatter)
+        handler.setLevel(log_level or logging.WARNING)
+    else:
+        handler = rich.logging.RichHandler(
+            level=log_level or logging.INFO,
+            console=Console(stderr=True),
+            show_time=False,
+            show_path=False,
+            highlighter=NullHighlighter(),
+        )
+    for logger in loggers:
+        logger.addHandler(handler)
+    # Remove rich handler on close since this would pollute all tests stderr
+    # otherwise.
+    context.call_on_close(partial(logger.removeHandler, handler))
+    # Reset contextvars
+    if ui_token is not None:
+        context.call_on_close(partial(ui.reset, ui_token))
+
+
+@cli.command("site-settings", hidden=True)
+@click.option(
+    "--defaults/--no-defaults",
+    default=None,
+    help="Output only default settings, or only site configuration.",
+    show_default=True,
+)
+@click.option(
+    "--schema", is_flag=True, help="Print the JSON Schema of site settings model."
+)
+@output_format_option
+@click.pass_context
+def site_settings(
+    context: click.Context,
+    /,
+    defaults: bool | None,
+    schema: bool,
+    output_format: OutputFormat,
+) -> None:
+    """Show site settings.
+
+    Without any option, the combination of site configuration and default
+    values is shown.
+    With --defaults, only default values and those depending on the
+    environment are shown (not accounting for site configuration).
+    With --no-defaults, the site configuration is shown alone and default
+    values are excluded.
+    """
+    if schema:
+        value = Settings.model_json_schema()
+    else:
+        if defaults:
+            value = _site.DEFAULT_SETTINGS.model_dump(mode="json")
+        else:
+            value = _site.SETTINGS.model_dump(
+                mode="json", exclude_defaults=defaults is False
+            )
+    if output_format == OutputFormat.json:
+        console.print_json(data=value)
+    else:
+        assert output_format is None
+        output = yaml.safe_dump(value)
+        syntax = Syntax(output, "yaml", background_color="default")
+        console.print(syntax)
+
+
+@cli.command(
+    "site-configure",
+    hidden=True,
+)
+@click.option(
+    "--settings",
+    "settings_file",
+    type=click.Path(exists=True, path_type=pathlib.Path),
+    help="Custom settings file.",
+)
+@click.argument(
+    "action", type=click.Choice(["install", "uninstall", "check"]), default="install"
+)
+@click.pass_obj
+@click.pass_context
+@async_command
+async def site_configure(
+    context: click.Context,
+    obj: Obj,
+    action: Literal["install", "uninstall", "check"],
+    settings_file: pathlib.Path | None,
+) -> None:
+    """Manage installation of extra data files for pglift.
+
+    This is an INTERNAL command.
+    """
+    with obj.lock:
+        if action == "install":
+            env = {"SETTINGS": f"@{settings_file}"} if settings_file else {}
+            await install.do(_site.SETTINGS, env=env)
+        elif action == "uninstall":
+            await install.undo(_site.SETTINGS)
+        elif action == "check":
+            if not install.check(_site.SETTINGS):
+                context.exit(1)
+        else:
+            assert_never(action)

pglift_cli/model.py

@@ -0,0 +1,346 @@
+# SPDX-FileCopyrightText: 2024 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+import enum
+import functools
+import inspect
+import logging
+import typing
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Iterator, Sequence
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Any, ClassVar, TypeVar
+
+import click
+import pydantic
+from pydantic.fields import FieldInfo
+from pydantic.v1.utils import deep_update, lenient_issubclass
+
+from pglift import exceptions
+from pglift._compat import zip
+from pglift.models.helpers import Operation, is_optional, optional_type
+from pglift.types import CLIConfig, StrEnum, field_annotation
+
+logger = logging.getLogger(__name__)
+
+ModelType = type[pydantic.BaseModel]
+T = TypeVar("T", bound=pydantic.BaseModel)
+Callback = Callable[..., Any]
+ClickDecorator = Callable[[Callback], Callback]
+DEFAULT = object()
+
+
+def as_parameters(
+    model_type: ModelType, operation: Operation, *, parse_model: bool = True
+) -> ClickDecorator:
+    """Attach click parameters (arguments or options) built from a pydantic
+    model to the command.
+
+    The argument in callback function must match the base name (lower-case) of
+    the pydantic model class. Otherwise, a TypeError is raised.
+    """
+
+    def decorator(f: Callback) -> Callback:
+        modelnames_and_argnames, paramspecs = zip(
+            *reversed(list(_paramspecs_from_model(model_type, operation))), strict=True
+        )
+
+        def params_to_modelargs(kwargs: dict[str, Any]) -> dict[str, Any]:
+            args = {}
+            for modelname, argname in modelnames_and_argnames:
+                value = kwargs.pop(argname)
+                if value is DEFAULT:
+                    continue
+                args[modelname] = value
+            return args
+
+        if parse_model:
+            s = inspect.signature(f)
+            model_argname = model_type.__name__.lower()
+            try:
+                model_param = s.parameters[model_argname]
+            except KeyError as e:
+                raise TypeError(
+                    f"expecting a '{model_argname}: {model_type.__name__}' parameter in '{f.__name__}{s}'"
+                ) from e
+            ptype = model_param.annotation
+            if isinstance(ptype, str):
+                # The annotation is "stringized"; we thus follow the wrapper
+                # chain as suggested in Python how-to about annotations.
+                # Implementation is simplified version of inspect.get_annotations().
+                w = f
+                while True:
+                    if hasattr(w, "__wrapped__"):
+                        w = w.__wrapped__
+                    elif isinstance(w, functools.partial):
+                        w = w.func
+                    else:
+                        break
+                if hasattr(w, "__globals__"):
+                    f_globals = w.__globals__
+                ptype = eval(ptype, f_globals, None)  # nosec: B307
+            if ptype not in (
+                model_type,
+                inspect.Signature.empty,
+            ) and not issubclass(model_type, ptype):
+                raise TypeError(
+                    f"expecting a '{model_argname}: {model_type.__name__}' parameter in '{f.__name__}{s}'; got {model_param.annotation}"
+                )
+
+            @functools.wraps(f)
+            def callback(**kwargs: Any) -> Any:
+                args = params_to_modelargs(kwargs)
+                with catch_validationerror(*paramspecs):
+                    model = parse_params_as(model_type, args)
+                kwargs[model_argname] = model
+                return f(**kwargs)
+
+        else:
+
+            @functools.wraps(f)
+            def callback(**kwargs: Any) -> Any:
+                args = params_to_modelargs(kwargs)
+                values = unnest(model_type, args)
+                kwargs.update(values)
+                with catch_validationerror(*paramspecs):
+                    return f(**kwargs)
+
+        cb = callback
+        for p in paramspecs:
+            cb = p.decorator(cb)
+        return cb
+
+    return decorator
+
+
+def parse_params_as(model_type: type[T], params: dict[str, Any]) -> T:
+    obj = unnest(model_type, params)
+    return model_type.model_validate(obj)
+
+
+def unnest(model_type: type[T], params: dict[str, Any]) -> dict[str, Any]:
+    if is_optional(model_type):
+        model_type = optional_type(model_type)
+    known_fields: dict[str, FieldInfo] = {}
+    for fname, f in model_type.model_fields.items():
+        if config := field_annotation(f, CLIConfig):
+            if config.hide:
+                continue
+        known_fields[(f.alias or fname)] = f
+    obj: dict[str, Any] = {}
+    for k, v in params.items():
+        if v is None:
+            continue
+        if k in known_fields:
+            obj[k] = v
+        elif "_" in k:
+            p, subk = k.split("_", 1)
+            try:
+                field = known_fields[p]
+            except KeyError as e:
+                raise ValueError(k) from e
+            assert field.annotation is not None
+            nested = unnest(field.annotation, {subk: v})
+            obj[p] = deep_update(obj.get(p, {}), nested)
+        else:
+            raise ValueError(k)
+    return obj
+
+
+@dataclass(frozen=True)
+class ParamSpec(ABC):
+    """Intermediate representation for a future click.Parameter."""
+
+    param_decls: Sequence[str]
+    attrs: dict[str, Any]
+    loc: tuple[str, ...]
+
+    objtype: ClassVar = click.Parameter
+
+    @property
+    @abstractmethod
+    def decorator(self) -> ClickDecorator:
+        """The click decorator for this parameter."""
+
+    def match_loc(self, loc: tuple[str | int, ...]) -> bool:
+        """Return True if this parameter spec matches a 'loc' tuple (from
+        pydantic.ValidationError).
+        """
+        return self.loc == loc
+
+    def badparameter_exception(self, message: str) -> click.BadParameter:
+        return click.BadParameter(
+            message, None, param=self.objtype(self.param_decls, **self.attrs)
+        )
+
+
+class ArgumentSpec(ParamSpec):
+    """Intermediate representation for a future click.Argument."""
+
+    objtype: ClassVar = click.Argument
+
+    def __post_init__(self) -> None:
+        assert (
+            len(self.param_decls) == 1
+        ), f"expecting exactly one parameter declaration: {self.param_decls}"
+
+    @property
+    def decorator(self) -> ClickDecorator:
+        return click.argument(*self.param_decls, **self.attrs)
+
+
+class OptionSpec(ParamSpec):
+    """Intermediate representation for a future click.Option."""
+
+    objtype: ClassVar = click.Option
+
+    @property
+    def decorator(self) -> ClickDecorator:
+        return click.option(*self.param_decls, **self.attrs)
+
+
+@dataclass(frozen=True)
+class _Parent:
+    argname: str
+    required: bool
+
+
+def _paramspecs_from_model(
+    model_type: ModelType,
+    operation: Operation,
+    *,
+    _parents: tuple[_Parent, ...] = (),
+) -> Iterator[tuple[tuple[str, str], ParamSpec]]:
+    """Yield parameter declarations for click corresponding to fields of a
+    pydantic model type.
+    """
+
+    def default(ctx: click.Context, param: click.Argument, value: Any) -> Any:
+        if (param.multiple and value == ()) or (value == param.default):
+            return DEFAULT
+        return value
+
+    for fname, field in model_type.model_fields.items():
+        modelname = argname = field.alias or fname
+        if config := field_annotation(field, CLIConfig):
+            if config.hide:
+                continue
+            if config.name is not None:
+                argname = config.name
+        if (
+            operation == "update"
+            and isinstance(field.json_schema_extra, dict)
+            and field.json_schema_extra.get("readOnly")
+        ):
+            continue
+        ftype = field.annotation
+        assert ftype is not None
+        if is_optional(ftype):
+            ftype = optional_type(ftype)
+        origin_type = typing.get_origin(ftype)
+        if origin_type is typing.Annotated:
+            ftype = typing.get_args(ftype)[0]
+            assert ftype is not None
+        nested = lenient_issubclass(origin_type or ftype, pydantic.BaseModel)
+        required = field.is_required()
+        if not nested and not _parents and required:
+            yield (modelname, argname), ArgumentSpec(
+                (argname.replace("_", "-"),), {"type": ftype}, loc=(modelname,)
+            )
+        else:
+            metavar: str | None
+            if config and config.metavar is not None:
+                metavar = config.metavar
+            else:
+                metavar = argname
+            if metavar is not None:
+                metavar = metavar.upper()
+            argparts = tuple(p.argname for p in _parents) + tuple(argname.split("_"))
+            fname = f"--{'-'.join(argparts)}"
+            description = None
+            if field.description:
+                description = field.description
+                description = description[0].upper() + description[1:]
+            attrs: dict[str, Any] = {}
+            if origin_type is typing.Literal:
+                choices = list(typing.get_args(ftype))
+                if len(choices) == 1:  # const
+                    continue
+                if config and config.choices is not None:
+                    choices = config.choices
+                attrs["type"] = click.Choice(choices)
+                metavar = None
+            elif lenient_issubclass(ftype, enum.Enum):
+                if config and config.choices is not None:
+                    choices = config.choices
+                else:
+                    choices = choices_from_enum(ftype)
+                attrs["type"] = click.Choice(choices)
+            elif nested:
+                yield from _paramspecs_from_model(
+                    ftype, operation, _parents=_parents + (_Parent(argname, required),)
+                )
+                continue
+            elif lenient_issubclass(origin_type or ftype, list):
+                if operation != "create":
+                    continue
+                attrs["multiple"] = True
+                try:
+                    (itemtype,) = ftype.__args__
+                except ValueError:
+                    pass
+                else:
+                    if lenient_issubclass(itemtype, enum.Enum):
+                        attrs["type"] = click.Choice(choices_from_enum(itemtype))
+                    else:
+                        attrs["metavar"] = metavar
+            elif lenient_issubclass(ftype, pydantic.SecretStr):
+                attrs["prompt"] = (
+                    description.rstrip(".") if description is not None else True
+                )
+                attrs["prompt_required"] = False
+                attrs["confirmation_prompt"] = True
+                attrs["hide_input"] = True
+            elif lenient_issubclass(ftype, bool):
+                fname = f"{fname}/--no-{fname[2:]}"
+                # Use None to distinguish unspecified option from the default value.
+                attrs["default"] = None
+            else:
+                attrs["metavar"] = metavar
+            if description is not None:
+                if description[-1] not in ".?":
+                    description += "."
+                attrs["help"] = description
+            if field.is_required() and all(p.required for p in _parents):
+                attrs["required"] = True
+            argname = "_".join(argparts)
+            loc = tuple(p.argname for p in _parents) + (modelname,)
+            modelname = "_".join(loc)
+            yield (modelname, argname), OptionSpec(
+                (fname,), {"callback": default, **attrs}, loc=loc
+            )
+
+
+def choices_from_enum(e: type[enum.Enum]) -> list[Any]:
+    if lenient_issubclass(e, StrEnum):
+        return list(e)
+    else:
+        return [v.value for v in e]
+
+
+@contextmanager
+def catch_validationerror(*paramspec: ParamSpec) -> Iterator[None]:
+    try:
+        yield None
+    except (exceptions.ValidationError, pydantic.ValidationError) as e:
+        errors = e.errors()
+        for pspec in paramspec:
+            for err in errors:
+                if pspec.match_loc(err["loc"]):
+                    raise pspec.badparameter_exception(err["msg"]) from None
+        logger.debug("a validation error occurred", exc_info=True)
+        raise click.ClickException(str(e)) from None

pglift_cli/patroni.py

@@ -0,0 +1,37 @@
+# SPDX-FileCopyrightText: 2021 Dalibo
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+from pglift import patroni
+from pglift.models import system
+from pglift.patroni import impl
+from pglift.patroni import register_if as register_if  # noqa: F401
+
+from . import _site, hookimpl
+from .util import Group, instance_identifier_option, pass_instance
+
+
+@click.group("patroni", cls=Group)
+@instance_identifier_option
+def cli(**kwargs: Any) -> None:
+    """Handle Patroni service for an instance."""
+
+
+@cli.command("logs")
+@pass_instance
+def logs(instance: system.Instance) -> None:
+    """Output Patroni logs."""
+    settings = patroni.get_settings(_site.SETTINGS)
+    for line in impl.logs(instance.qualname, settings):
+        click.echo(line, nl=False)
+
+
+@hookimpl
+def command() -> click.Group:
+    return cli