dycw-postgres 0.2.0__py3-none-any.whl

dycw_postgres-0.2.0.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.3
+Name: dycw-postgres
+Version: 0.2.0
+Summary: Library to operate `postgres` and `pgbackrest`
+Author: Derek Wan
+Author-email: Derek Wan <d.wan@icloud.com>
+Requires-Dist: click>=8.3.1
+Requires-Dist: dycw-utilities>=0.189.1
+Requires-Dist: click==8.3.1 ; extra == 'cli'
+Requires-Dist: dycw-utilities==0.189.1 ; extra == 'cli'
+Requires-Python: >=3.12
+Provides-Extra: cli
+Description-Content-Type: text/markdown
+
+# `postgres`
+
+Library to operate `postgres` and `pgbackrest`

dycw_postgres-0.2.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+postgres/__init__.py,sha256=N_crolGv2j6N_FPy_bbFMnZY5zHKh-OfDj3bEJIIGOo,707
+postgres/_cli.py,sha256=K7ugaykYszy9SzQfYC08VCj5B7N-p1fQ83qs0clKPe8,1427
+postgres/_click.py,sha256=fy1wPvt9Qj8pwkS7CaoWH0W2nCxFjfQ-o9vANb2vXiQ,1396
+postgres/_constants.py,sha256=8fNn5L0BLmjshmiKz2sncf_xiWvbchNOPG5jNw3MITg,91
+postgres/_enums.py,sha256=s7Bli5hyBef2mufS-M5uJmRSp9oRmw87aqb5Spabg78,561
+postgres/_types.py,sha256=2b7Ys9QuOOxvkP_9-xFu4LjcbBw6r9PeKxSOoxgxVhQ,79
+postgres/_utilities.py,sha256=xhXKaXvtiB8_2w_Bz2cqwJnHREyyNglAoYPpoDNBFHY,2233
+postgres/commands/__init__.py,sha256=ERcOSbBeTHWQmIjZ9jv6Hf25OqrwsC-q2wmpzdPagHo,754
+postgres/commands/_backup.py,sha256=Rgen0KLjZLvYriQVPliVqIrV4caasS8QT_PlWy0gIVU,2682
+postgres/commands/_check.py,sha256=jccA2IxnCvPUvqRvA8_oAojBChgIOEx4buMN45dkcPA,1301
+postgres/commands/_info.py,sha256=kfKzNyNLfpgebobncTzsbkzDXuO-ayBVW8DNjfqdI5k,1907
+postgres/commands/_restore.py,sha256=WttJujZG2CgtaZxPJr_52HiAfCdZPQnxAB8TBsjTpqk,4056
+postgres/commands/_stanza_create.py,sha256=lBOr-hoEOd2X0f7i-OpgEWiUqEPdn-2obn18ZBWQnUY,1323
+postgres/commands/_start.py,sha256=J2_Tku1EwFHkGirOH_DAUYqrIrWLEVOmbn58UyGmwxE,1344
+postgres/commands/_stop.py,sha256=kMN78T6v4wjA_5NCZWN95wZfTVsnGEOul0CGGcTw4ao,1343
+postgres/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dycw_postgres-0.2.0.dist-info/WHEEL,sha256=QnGI6l9Psotmz6XrseXTYT5jnZRJeTk4SwJP4aLtfdI,80
+dycw_postgres-0.2.0.dist-info/entry_points.txt,sha256=NBa0-dhZS57irzZehip3Hh6fHyHwtD89AArmSol0a4k,300
+dycw_postgres-0.2.0.dist-info/METADATA,sha256=9x6Vgj9TrRJKtjQqs2cOHW-rTLIlzJgTYuyTovM4w3Q,488
+dycw_postgres-0.2.0.dist-info/RECORD,,

dycw_postgres-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.10.2
+Root-Is-Purelib: true
+Tag: py3-none-any

dycw_postgres-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,10 @@
+[console_scripts]
+backup = postgres._cli:backup_cli
+check = postgres._cli:check_cli
+info = postgres._cli:info_cli
+postgres-cli = postgres._cli:group_cli
+restore = postgres._cli:restore_cli
+stanza-create = postgres._cli:stanza_create_cli
+start = postgres._cli:start_cli
+stop = postgres._cli:stop_cli
+

postgres/__init__.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from postgres._click import (
+    ClickRepo,
+    stanza_argument,
+    stanza_option,
+    type_default_option,
+    type_no_default_option,
+    user_option,
+    version_option,
+)
+from postgres._constants import POSTGRES_VERSION
+from postgres._enums import DEFAULT_TYPE, Type
+from postgres._types import Repo
+from postgres._utilities import run_or_as_user, to_repo_num
+
+__all__ = [
+    "DEFAULT_TYPE",
+    "POSTGRES_VERSION",
+    "ClickRepo",
+    "Repo",
+    "Type",
+    "run_or_as_user",
+    "stanza_argument",
+    "stanza_option",
+    "to_repo_num",
+    "type_default_option",
+    "type_no_default_option",
+    "user_option",
+    "version_option",
+]
+__version__ = "0.2.0"

postgres/_cli.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from click import group, version_option
+from utilities.click import CONTEXT_SETTINGS
+
+from postgres import __version__
+from postgres.commands._backup import make_backup_cmd
+from postgres.commands._check import make_check_cmd
+from postgres.commands._info import make_info_cmd
+from postgres.commands._restore import make_restore_cmd
+from postgres.commands._stanza_create import make_stanza_create_cmd
+from postgres.commands._start import make_start_cmd
+from postgres.commands._stop import make_stop_cmd
+
+backup_cli = make_backup_cmd()
+check_cli = make_check_cmd()
+info_cli = make_info_cmd()
+stanza_create_cli = make_stanza_create_cmd()
+restore_cli = make_restore_cmd()
+start_cli = make_start_cmd()
+stop_cli = make_stop_cmd()
+
+
+@group(**CONTEXT_SETTINGS)
+@version_option(version=__version__)
+def group_cli() -> None: ...
+
+
+_ = make_backup_cmd(cli=group_cli.command, name="backup")
+_ = make_check_cmd(cli=group_cli.command, name="check")
+_ = make_info_cmd(cli=group_cli.command, name="info")
+_ = make_restore_cmd(cli=group_cli.command, name="restore")
+_ = make_stanza_create_cmd(cli=group_cli.command, name="stanza-create")
+_ = make_start_cmd(cli=group_cli.command, name="start")
+_ = make_stop_cmd(cli=group_cli.command, name="stop")
+
+
+__all__ = [
+    "backup_cli",
+    "check_cli",
+    "group_cli",
+    "info_cli",
+    "restore_cli",
+    "stanza_create_cli",
+    "start_cli",
+    "stop_cli",
+]

postgres/_click.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, override
+
+from click import Context, Parameter, ParamType
+from utilities.click import Enum, Str, argument, option
+
+from postgres._constants import POSTGRES_VERSION
+from postgres._enums import DEFAULT_TYPE, Type
+
+if TYPE_CHECKING:
+    from postgres._types import Repo
+
+# parameters
+
+
+class ClickRepo(ParamType):
+    name = "repo"
+
+    @override
+    def __repr__(self) -> str:
+        return self.name.upper()
+
+    @override
+    def convert(
+        self, value: Repo, param: Parameter | None, ctx: Context | None
+    ) -> Repo:
+        _ = (param, ctx)
+        return value
+
+
+# options
+
+
+stanza_argument = argument("stanza", type=Str())
+stanza_option = option("--stanza", type=Str(), default=None, help="Stanza name")
+repo_option = option("--repo", type=ClickRepo(), default=None, help="Repo number/name")
+type_default_option, type_no_default_option = [
+    option("--type", "type_", type=Enum(Type), default=d, help="Backup type")
+    for d in [DEFAULT_TYPE, None]
+]
+user_option = option("--user", type=Str(), default=None, help="User to run as")
+version_option = option(
+    "--version", type=int, default=POSTGRES_VERSION, help="Postgres version"
+)
+
+
+__all__ = [
+    "ClickRepo",
+    "stanza_argument",
+    "stanza_option",
+    "type_default_option",
+    "type_no_default_option",
+    "user_option",
+    "version_option",
+]

postgres/_constants.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+POSTGRES_VERSION = 17
+
+
+__all__ = ["POSTGRES_VERSION"]

postgres/_enums.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from enum import StrEnum, unique
+from typing import assert_never
+
+
+@unique
+class Type(StrEnum):
+    full = "full"
+    diff = "diff"
+    incr = "incr"
+
+    @property
+    def desc(self) -> str:
+        match self:
+            case Type.full:
+                return "full"
+            case Type.diff:
+                return "differential"
+            case Type.incr:
+                return "incremental"
+            case never:
+                assert_never(never)
+
+
+DEFAULT_TYPE = Type.incr
+
+
+__all__ = ["DEFAULT_TYPE", "Type"]

postgres/_types.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+type Repo = str | int
+
+
+__all__ = ["Repo"]

postgres/_utilities.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from shlex import join
+from typing import TYPE_CHECKING, assert_never
+
+from utilities.subprocess import run
+
+if TYPE_CHECKING:
+    from utilities.types import LoggerLike, PathLike, Retry, StrStrMapping
+
+    from postgres._types import Repo
+
+
+def to_repo_num(
+    *, repo: Repo | None = None, mapping: Mapping[str, int] | None = None
+) -> int:
+    """Convert a repo number/name to a number."""
+    match repo, mapping:
+        case int(), _:
+            return repo
+        case None, _:
+            return 1
+        case str(), Mapping():
+            return mapping[repo]
+        case str(), None:
+            msg = f"Repo {repo!r} is a string, but mappings were not provided"
+            raise ValueError(msg)
+        case never:
+            assert_never(never)
+
+
+##
+
+
+def run_or_as_user(
+    cmd: str,
+    /,
+    *args: str,
+    executable: str | None = None,
+    shell: bool = False,
+    cwd: PathLike | None = None,
+    env: StrStrMapping | None = None,
+    user: str | int | None = None,
+    print: bool = False,  # noqa: A002
+    print_stdout: bool = False,
+    print_stderr: bool = False,
+    suppress: bool = False,
+    retry: Retry | None = None,
+    retry_skip: Callable[[int, str, str], bool] | None = None,
+    logger: LoggerLike | None = None,
+) -> None:
+    if user is None:
+        run(
+            cmd,
+            *args,
+            executable=executable,
+            shell=shell,
+            cwd=cwd,
+            env=env,
+            print=print,
+            print_stdout=print_stdout,
+            print_stderr=print_stderr,
+            suppress=suppress,
+            retry=retry,
+            retry_skip=retry_skip,
+            logger=logger,
+        )
+    else:
+        run(
+            "su",
+            "-",
+            str(user),
+            executable=executable,
+            shell=shell,
+            cwd=cwd,
+            env=env,
+            input=join([cmd, *args]),
+            print=print,
+            print_stdout=print_stdout,
+            print_stderr=print_stderr,
+            suppress=suppress,
+            retry=retry,
+            retry_skip=retry_skip,
+            logger=logger,
+        )
+
+
+__all__ = ["to_repo_num"]

postgres/commands/__init__.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from postgres.commands._backup import backup, make_backup_cmd
+from postgres.commands._check import check, make_check_cmd
+from postgres.commands._info import info, make_info_cmd
+from postgres.commands._restore import make_restore_cmd, restore
+from postgres.commands._stanza_create import make_stanza_create_cmd, stanza_create
+from postgres.commands._start import make_start_cmd, start
+from postgres.commands._stop import make_stop_cmd, stop
+
+__all__ = [
+    "backup",
+    "check",
+    "info",
+    "make_backup_cmd",
+    "make_check_cmd",
+    "make_info_cmd",
+    "make_restore_cmd",
+    "make_stanza_create_cmd",
+    "make_start_cmd",
+    "make_stop_cmd",
+    "restore",
+    "stanza_create",
+    "start",
+    "stop",
+]

postgres/commands/_backup.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from click import command
+from utilities.click import CONTEXT_SETTINGS
+from utilities.core import always_iterable, is_pytest, set_up_logging, to_logger
+
+from postgres import __version__
+from postgres._click import (
+    repo_option,
+    stanza_argument,
+    type_default_option,
+    user_option,
+)
+from postgres._enums import DEFAULT_TYPE
+from postgres._utilities import run_or_as_user, to_repo_num
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Mapping
+
+    from click import Command
+    from utilities.types import MaybeIterable
+
+    from postgres._enums import Type
+    from postgres._types import Repo
+
+
+_LOGGER = to_logger(__name__)
+
+
+##
+
+
+def backup(
+    stanza: str,
+    /,
+    *,
+    repo: MaybeIterable[Repo] | None = None,
+    repo_mapping: Mapping[str, int] | None = None,
+    type_: Type = DEFAULT_TYPE,
+    user: str | None = None,
+) -> None:
+    if repo is None:
+        _backup_core(stanza, type_=type_, user=user)
+    else:
+        for repo_i in always_iterable(repo):
+            _backup_core(
+                stanza, repo=repo_i, repo_mapping=repo_mapping, type_=type_, user=user
+            )
+
+
+def _backup_core(
+    stanza: str,
+    /,
+    *,
+    repo: Repo | None = None,
+    repo_mapping: Mapping[str, int] | None = None,
+    type_: Type = DEFAULT_TYPE,
+    user: str | None = None,
+) -> None:
+    args: list[str] = ["pgbackrest"]
+    if repo is None:
+        _LOGGER.info("%s backup %r to default repo...", type_.desc.title(), stanza)
+        repo_num = repo
+    else:
+        _LOGGER.info("%s backup %r to repo %r...", type_.desc.title(), stanza, repo)
+        repo_num = to_repo_num(repo=repo, mapping=repo_mapping)
+        args.append(f"--repo={repo_num}")
+    args.extend([f"--stanza={stanza}", f"--type={type_.value}", "backup"])
+    run_or_as_user(*args, user=user, print=True, logger=_LOGGER)
+    if repo is None:
+        _LOGGER.info("Finished %s backup %r to default repo", type_.desc, stanza)
+    else:
+        _LOGGER.info("Finished %s backup %r to repo %r", type_.desc, stanza, repo)
+
+
+##
+
+
+def make_backup_cmd(
+    *, cli: Callable[..., Command] = command, name: str | None = None
+) -> Command:
+    @stanza_argument
+    @type_default_option
+    @repo_option
+    @user_option
+    def func(*, stanza: str, type_: Type, repo: Repo | None, user: str | None) -> None:
+        if is_pytest():
+            return
+        set_up_logging(__name__, root=True, log_version=__version__)
+        backup(stanza, repo=repo, type_=type_, user=user)
+
+    return cli(name=name, help="Backup a database cluster", **CONTEXT_SETTINGS)(func)
+
+
+__all__ = ["backup", "make_backup_cmd"]

postgres/commands/_check.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from click import command
+from utilities.click import CONTEXT_SETTINGS
+from utilities.core import is_pytest, set_up_logging, to_logger
+
+from postgres import __version__
+from postgres._click import stanza_option, user_option
+from postgres._utilities import run_or_as_user
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from click import Command
+
+
+_LOGGER = to_logger(__name__)
+
+
+##
+
+
+def check(*, stanza: str | None = None, user: str | None = None) -> None:
+    _LOGGER.info("Checking configuration...")
+    args: list[str] = ["pgbackrest"]
+    if stanza is not None:
+        args.append(f"--stanza={stanza}")
+    run_or_as_user(*args, user=user, print=True, logger=_LOGGER)
+    _LOGGER.info("Finished checking configuration")
+
+
+##
+
+
+def make_check_cmd(
+    *, cli: Callable[..., Command] = command, name: str | None = None
+) -> Command:
+    @stanza_option
+    @user_option
+    def func(*, stanza: str | None, user: str | None) -> None:
+        if is_pytest():
+            return
+        set_up_logging(__name__, root=True, log_version=__version__)
+        check(stanza=stanza, user=user)
+
+    return cli(name=name, help="Check the configuration", **CONTEXT_SETTINGS)(func)
+
+
+__all__ = ["check", "make_check_cmd"]

postgres/commands/_info.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from click import command
+from utilities.click import CONTEXT_SETTINGS
+from utilities.core import is_pytest, set_up_logging, to_logger
+
+from postgres import __version__
+from postgres._click import (
+    repo_option,
+    stanza_option,
+    type_no_default_option,
+    user_option,
+)
+from postgres._utilities import run_or_as_user, to_repo_num
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Mapping
+
+    from click import Command
+
+    from postgres._enums import Type
+    from postgres._types import Repo
+
+
+_LOGGER = to_logger(__name__)
+
+
+##
+
+
+def info(
+    *,
+    repo: Repo | None = None,
+    repo_mapping: Mapping[str, int] | None = None,
+    stanza: str | None = None,
+    type_: Type | None = None,
+    user: str | None = None,
+) -> None:
+    _LOGGER.info("Getting info...")
+    args: list[str] = ["pgbackrest"]
+    if repo is not None:
+        repo_num = to_repo_num(repo=repo, mapping=repo_mapping)
+        args.append(f"--repo={repo_num}")
+    if stanza is not None:
+        args.append(f"--stanza={stanza}")
+    if type_ is not None:
+        args.append(f"--type={type_.value}")
+    run_or_as_user(*args, user=user, print=True, logger=_LOGGER)
+    _LOGGER.info("Finished getting info")
+
+
+##
+
+
+def make_info_cmd(
+    *, cli: Callable[..., Command] = command, name: str | None = None
+) -> Command:
+    @repo_option
+    @stanza_option
+    @type_no_default_option
+    @user_option
+    def func(
+        *, repo: Repo | None, stanza: str | None, type_: Type | None, user: str | None
+    ) -> None:
+        if is_pytest():
+            return
+        set_up_logging(__name__, root=True, log_version=__version__)
+        info(repo=repo, stanza=stanza, type_=type_, user=user)
+
+    return cli(
+        name=name, help="Retrieve information about backups", **CONTEXT_SETTINGS
+    )(func)
+
+
+__all__ = ["info", "make_info_cmd"]

postgres/commands/_restore.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from click import Command, command
+from utilities.click import CONTEXT_SETTINGS, Str, argument, option
+from utilities.core import is_pytest, set_up_logging, to_logger
+from utilities.subprocess import run
+from utilities.types import PathLike
+
+from postgres import __version__
+from postgres._click import repo_option, stanza_argument, user_option, version_option
+from postgres._constants import POSTGRES_VERSION
+from postgres._types import Repo
+from postgres._utilities import run_or_as_user, to_repo_num
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Mapping
+
+    from utilities.types import PathLike
+
+    from postgres._types import Repo
+
+
+_LOGGER = to_logger(__name__)
+
+
+##
+
+
+def restore(
+    cluster: str,
+    stanza: str,
+    /,
+    *,
+    version: int = POSTGRES_VERSION,
+    repo: Repo | None = None,
+    repo_mapping: Mapping[str, int] | None = None,
+    target_timeline: int | None = None,
+    user: str | None = None,
+) -> None:
+    _LOGGER.info("Restoring Postgres...")
+    _stop_cluster(cluster, version=version)
+    _delete_data(cluster, version=version)
+    _run_restore(
+        stanza,
+        repo=repo,
+        repo_mapping=repo_mapping,
+        target_timeline=target_timeline,
+        user=user,
+    )
+    _start_cluster(cluster, version=version)
+    _LOGGER.info("Finished restoring Postgres")
+
+
+def _stop_cluster(cluster: str, /, *, version: int = POSTGRES_VERSION) -> None:
+    _LOGGER.info("Stopping cluster %r...", cluster)
+    run("pg_ctlcluster", str(version), cluster, "stop", suppress=True)
+
+
+def _delete_data(
+    name: str, /, *, version: int = POSTGRES_VERSION, __root: PathLike | None = None
+) -> None:
+    _LOGGER.info("Deleting %r data files...", name)
+    root = Path("/") if __root is None else Path(__root)
+    path = root / f"var/lib/postgresql/{version}/{name}"
+    run("find", str(path), "-mindepth", "1", "-delete")
+
+
+def _run_restore(
+    stanza: str,
+    /,
+    *,
+    repo: Repo | None = None,
+    repo_mapping: Mapping[str, int] | None = None,
+    target_timeline: int | None = None,
+    user: str | None = None,
+) -> None:
+    args: list[str] = ["pgbackrest"]
+    if repo is None:
+        _LOGGER.info("Restoring default repo to %r...", stanza)
+    else:
+        _LOGGER.info("Restoring repo %r to %r...", repo, stanza)
+        repo_num = to_repo_num(repo=repo, mapping=repo_mapping)
+        args.append(f"--repo={repo_num}")
+    args.append(f"--stanza={stanza}")
+    if target_timeline is not None:
+        args.append(f"--target_timeline={target_timeline}")
+    args.append("restore")
+    run_or_as_user(*args, user=user, print=True, logger=_LOGGER)
+    if repo is None:
+        _LOGGER.info("Finished restoring default repo to %r...", stanza)
+    else:
+        _LOGGER.info("Finished restoring repo %r to %r", repo, stanza)
+
+
+def _start_cluster(name: str, /, *, version: int = POSTGRES_VERSION) -> None:
+    _LOGGER.info("Starting cluster %r...", name)
+    run("pg_ctlcluster", str(version), name, "start")
+
+
+##
+
+
+def make_restore_cmd(
+    *, cli: Callable[..., Command] = command, name: str | None = None
+) -> Command:
+    @argument("cluster", type=Str())
+    @stanza_argument
+    @version_option
+    @repo_option
+    @option(
+        "--target-timeline", type=int, default=None, help="Recover along a timeline"
+    )
+    @user_option
+    def func(
+        *,
+        cluster: str,
+        stanza: str,
+        version: int,
+        repo: Repo | None,
+        target_timeline: int | None,
+        user: str | None,
+    ) -> None:
+        if is_pytest():
+            return
+        set_up_logging(__name__, root=True, log_version=__version__)
+        restore(
+            cluster,
+            stanza,
+            version=version,
+            repo=repo,
+            target_timeline=target_timeline,
+            user=user,
+        )
+
+    return cli(name=name, help="Restore a database cluster", **CONTEXT_SETTINGS)(func)
+
+
+__all__ = ["make_restore_cmd", "restore"]

postgres/commands/_stanza_create.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from click import command
+from utilities.click import CONTEXT_SETTINGS
+from utilities.core import is_pytest, set_up_logging, to_logger
+
+from postgres import __version__
+from postgres._click import stanza_argument, user_option
+from postgres._utilities import run_or_as_user
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from click import Command
+
+
+_LOGGER = to_logger(__name__)
+
+
+##
+
+
+def stanza_create(stanza: str, /, *, user: str | None = None) -> None:
+    _LOGGER.info("Creating stanza...")
+    run_or_as_user(
+        "pgbackrest",
+        f"--stanza={stanza}",
+        "stanza-create",
+        user=user,
+        print=True,
+        logger=_LOGGER,
+    )
+    _LOGGER.info("Finished creating stanza")
+
+
+##
+
+
+def make_stanza_create_cmd(
+    *, cli: Callable[..., Command] = command, name: str | None = None
+) -> Command:
+    @stanza_argument
+    @user_option
+    def func(*, stanza: str, user: str | None) -> None:
+        if is_pytest():
+            return
+        set_up_logging(__name__, root=True, log_version=__version__)
+        stanza_create(stanza, user=user)
+
+    return cli(name=name, help="Create the required stanza data", **CONTEXT_SETTINGS)(
+        func
+    )
+
+
+__all__ = ["make_stanza_create_cmd", "stanza_create"]

postgres/commands/_start.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from click import command
+from utilities.click import CONTEXT_SETTINGS
+from utilities.core import is_pytest, set_up_logging, to_logger
+
+from postgres import __version__
+from postgres._click import stanza_option, user_option
+from postgres._utilities import run_or_as_user
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from click import Command
+
+
+_LOGGER = to_logger(__name__)
+
+
+##
+
+
+def start(*, stanza: str | None = None, user: str | None = None) -> None:
+    _LOGGER.info("Starting 'pgbackrest'...")
+    args: list[str] = ["pgbackrest"]
+    if stanza is None:
+        args.append(f"--stanza={stanza}")
+    args.append("start")
+    run_or_as_user(*args, user=user, print=True, logger=_LOGGER)
+    _LOGGER.info("Finished starting 'pgbackrest'")
+
+
+##
+
+
+def make_start_cmd(
+    *, cli: Callable[..., Command] = command, name: str | None = None
+) -> Command:
+    @stanza_option
+    @user_option
+    def func(*, stanza: str | None, user: str | None) -> None:
+        if is_pytest():
+            return
+        set_up_logging(__name__, root=True, log_version=__version__)
+        start(stanza=stanza, user=user)
+
+    return cli(name=name, help="Allow pgBackRest processes to run", **CONTEXT_SETTINGS)(
+        func
+    )
+
+
+__all__ = ["make_start_cmd", "start"]

postgres/commands/_stop.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from click import command
+from utilities.click import CONTEXT_SETTINGS
+from utilities.core import is_pytest, set_up_logging, to_logger
+
+from postgres import __version__
+from postgres._click import stanza_option, user_option
+from postgres._utilities import run_or_as_user
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from click import Command
+
+
+_LOGGER = to_logger(__name__)
+
+
+##
+
+
+def stop(*, stanza: str | None = None, user: str | None = None) -> None:
+    _LOGGER.info("Stopping 'pgbackrest'...")
+    args: list[str] = ["pgbackrest"]
+    if stanza is None:
+        args.append(f"--stanza={stanza}")
+    args.append("stop")
+    run_or_as_user(*args, user=user, print=True, logger=_LOGGER)
+    _LOGGER.info("Finished stopping 'pgbackrest'")
+
+
+##
+
+
+def make_stop_cmd(
+    *, cli: Callable[..., Command] = command, name: str | None = None
+) -> Command:
+    @stanza_option
+    @user_option
+    def func(*, stanza: str | None, user: str | None) -> None:
+        if is_pytest():
+            return
+        set_up_logging(__name__, root=True, log_version=__version__)
+        stop(stanza=stanza, user=user)
+
+    return cli(
+        name=name, help="Stop pgBackRest processes from running", **CONTEXT_SETTINGS
+    )(func)
+
+
+__all__ = ["make_stop_cmd", "stop"]