pg-stand 0.2.2__tar.gz → 0.2.4__tar.gz

{pg_stand-0.2.2/src/pg_stand.egg-info → pg_stand-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pg-stand
-Version: 0.2.2
+Version: 0.2.4
 Summary: Declarative Docker testbed manager for PostgreSQL
 Author-email: O2eg <oleg.ispu@yandex.ru>
 License-Expression: MIT
@@ -259,9 +259,10 @@ avoided; the runtime selects a compatible image family automatically.
 Every managed image installs PgBouncer 1.25.2, `iproute2`, `lshw`, OpenSSH server, `procps`,
 `sysstat`, `util-linux`, plus the `pg_wait_sampling` and `pg_stat_kcache` packages. Every node
 runs independent PgBouncer processes for session pooling on container port 6432 and transaction
-pooling on container port 6433. Every application
-database from `app_01` through `app_10` automatically gets `pg_stat_statements`,
-`pg_wait_sampling`, `pg_buffercache`, and `pg_stat_kcache`. The `auto_explain` module is also
+pooling on container port 6433. Every connectable database, including `app_01` through
+`app_10`, `postgres`, and `template1`, automatically gets `pg_stat_statements`,
+`pg_wait_sampling`, `pg_buffercache`, and `pg_stat_kcache`. New databases created from
+`template1` inherit these extensions; `template0` remains pristine. The `auto_explain` module is also
 loaded through
 `shared_preload_libraries`. Planning tracking for `pg_stat_statements` and `pg_stat_kcache` is
 enabled only on PostgreSQL 13 and newer.
@@ -503,6 +504,8 @@ stand is stopped or removed. `stop` and `down` release the lock. A failed partia
 the lock when it has already started a database node, so another stand cannot start around the
 failure. Destructive storage cleanup retains the lock until mounted data and credentials are no
 longer being changed, which prevents a concurrent `up` from racing with deletion.
+`plan` reports `blocked` when the active lease belongs to another stand or project
+directory, before suggesting `up` or an apply operation.
 
 Persistent container and network names must end with `-pg-stand-managed`. Every resource also
 has mandatory project, project-directory instance, managed, resource-kind, node, and

{pg_stand-0.2.2 → pg_stand-0.2.4}/README.md

@@ -219,9 +219,10 @@ avoided; the runtime selects a compatible image family automatically.
 Every managed image installs PgBouncer 1.25.2, `iproute2`, `lshw`, OpenSSH server, `procps`,
 `sysstat`, `util-linux`, plus the `pg_wait_sampling` and `pg_stat_kcache` packages. Every node
 runs independent PgBouncer processes for session pooling on container port 6432 and transaction
-pooling on container port 6433. Every application
-database from `app_01` through `app_10` automatically gets `pg_stat_statements`,
-`pg_wait_sampling`, `pg_buffercache`, and `pg_stat_kcache`. The `auto_explain` module is also
+pooling on container port 6433. Every connectable database, including `app_01` through
+`app_10`, `postgres`, and `template1`, automatically gets `pg_stat_statements`,
+`pg_wait_sampling`, `pg_buffercache`, and `pg_stat_kcache`. New databases created from
+`template1` inherit these extensions; `template0` remains pristine. The `auto_explain` module is also
 loaded through
 `shared_preload_libraries`. Planning tracking for `pg_stat_statements` and `pg_stat_kcache` is
 enabled only on PostgreSQL 13 and newer.
@@ -463,6 +464,8 @@ stand is stopped or removed. `stop` and `down` release the lock. A failed partia
 the lock when it has already started a database node, so another stand cannot start around the
 failure. Destructive storage cleanup retains the lock until mounted data and credentials are no
 longer being changed, which prevents a concurrent `up` from racing with deletion.
+`plan` reports `blocked` when the active lease belongs to another stand or project
+directory, before suggesting `up` or an apply operation.
 
 Persistent container and network names must end with `-pg-stand-managed`. Every resource also
 has mandatory project, project-directory instance, managed, resource-kind, node, and

{pg_stand-0.2.2 → pg_stand-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pg-stand"
-version = "0.2.2"
+version = "0.2.4"
 description = "Declarative Docker testbed manager for PostgreSQL"
 readme = "README.md"
 requires-python = ">=3.10"

{pg_stand-0.2.2 → pg_stand-0.2.4}/src/pg_stand/__init__.py

@@ -2,6 +2,6 @@
 
 from pg_stand.config import MANAGED_POSTGRES_PARAMETERS
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"
 
 __all__ = ["MANAGED_POSTGRES_PARAMETERS", "__version__"]

{pg_stand-0.2.2 → pg_stand-0.2.4}/src/pg_stand/runtime.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import shlex
 import time
 from collections.abc import Callable
@@ -15,7 +16,6 @@ from pg_stand.config import MANAGED_RESOURCE_SUFFIX, NodeConfig, StandConfig
 from pg_stand.credentials import credential_paths, credentials_status, ensure_credentials
 from pg_stand.database_credentials import (
     APPLICATION_ACCOUNTS,
-    APPLICATION_DATABASES,
     DEFAULT_REPLICATION_USER,
     DatabaseCredentials,
     read_database_credentials,
@@ -393,6 +393,11 @@ class _StandManagerCore:
                 nano_cpus=int(node.cpu_limit * 1_000_000_000),
                 mem_limit=node.memory_limit,
                 restart_policy={"Name": "unless-stopped"},
+                # Without an init process the postmaster is PID 1 and adopts orphaned
+                # children (docker exec/ssh pipelines). PostgreSQL 18 treats an unknown
+                # child exiting with a non-zero status as a backend crash and restarts
+                # the whole cluster (observed 2026-09-11 on pg-trace: exit code 141).
+                init=True,
             )
         except APIError as exc:
             raise DockerRuntimeError(
@@ -460,8 +465,16 @@ class _StandManagerCore:
                     "/bin/sh",
                     "-ceu",
                     """process=$(cat /proc/1/comm)
+if [ "$process" = "docker-init" ]; then
+  # Its first child is the entrypoint, which execs the final server. Later
+  # children may include the temporary initdb server adopted by docker-init.
+  for child in $(cat /proc/1/task/1/children); do
+    process=$(cat "/proc/$child/comm")
+    break
+  done
+fi
 if [ "$process" != "postgres" ]; then
-  echo "container PID 1 is $process, waiting for final postgres process"
+  echo "container main process is $process, waiting for final postgres process"
   exit 1
 fi
 exec pg_isready --username "$1" --dbname postgres
@@ -563,7 +576,11 @@ exec pg_isready --username "$1" --dbname postgres
                 f"image {self.config.postgres.image_name} lacks diagnostic extensions: "
                 + ", ".join(missing)
             )
-        for database in APPLICATION_DATABASES:
+        # Include postgres and template1, so databases created later inherit the
+        # same diagnostic support. Keep template0 pristine and non-connectable
+        # databases untouched.
+        databases = self._diagnostic_databases(container)
+        for database in databases:
             for extension in DIAGNOSTIC_EXTENSIONS:
                 self._psql(
                     container,
@@ -582,6 +599,16 @@ exec pg_isready --username "$1" --dbname postgres
                 "unexpected shared_preload_libraries order: " + ",".join(actual_preloads)
             )
 
+    def _diagnostic_databases(self, container: Any) -> list[str]:
+        value = self._psql(
+            container,
+            "select coalesce(json_agg(datname order by datname), '[]'::json)::text "
+            "from pg_catalog.pg_database where datallowconn and datname <> 'template0'",
+            database=self.config.postgres.database,
+            synchronous_commit_off=True,
+        )
+        return json.loads(value)
+
     def _ensure_superuser_password(self, container: Any) -> None:
         self._psql(
             container,

{pg_stand-0.2.2 → pg_stand-0.2.4}/src/pg_stand/runtime_observe.py

@@ -8,7 +8,7 @@ from datetime import datetime, timezone
 from typing import Any
 
 from pg_stand.config import NodeConfig
-from pg_stand.database_credentials import APPLICATION_ACCOUNTS, APPLICATION_DATABASES
+from pg_stand.database_credentials import APPLICATION_ACCOUNTS
 from pg_stand.errors import DockerRuntimeError
 from pg_stand.runtime_common import (
     CONFIG_HASH_LABEL,
@@ -412,7 +412,8 @@ class ObservationMixin:
                 }
             )
             missing_by_database: dict[str, list[str]] = {}
-            for database in APPLICATION_DATABASES:
+            diagnostic_databases = self._diagnostic_databases(container)
+            for database in diagnostic_databases:
                 extension_output = self._psql(
                     container,
                     "select extname from pg_catalog.pg_extension where extname = any (array["
@@ -428,9 +429,10 @@ class ObservationMixin:
                 {
                     "id": f"node.{node_name}.extensions",
                     "status": "healthy" if not missing_by_database else "degraded",
-                    "summary": "all diagnostic extensions are installed in all 10 databases"
+                    "summary": "diagnostic extensions are installed in all connectable databases"
                     if not missing_by_database
-                    else "diagnostic extensions are missing from application databases",
+                    else "diagnostic extensions are missing from connectable databases",
+                    "databases": diagnostic_databases,
                     "missing_by_database": missing_by_database,
                 }
             )

{pg_stand-0.2.2 → pg_stand-0.2.4}/src/pg_stand/runtime_state.py

@@ -182,6 +182,12 @@ class StateStorageMixin:
             "desired_state_hash": self.config.config_hash,
             "applied_state_hash": state.get("config_hash") if state else None,
         }
+        if self._find_active_lock() is not None:
+            try:
+                self._assert_current_stand_is_active()
+            except DockerRuntimeError as exc:
+                result.update(required_action="blocked", can_apply=False, reason=str(exc))
+                return self._finalize_plan(result)
         if state is None:
             result.update(
                 {

{pg_stand-0.2.2 → pg_stand-0.2.4/src/pg_stand.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pg-stand
-Version: 0.2.2
+Version: 0.2.4
 Summary: Declarative Docker testbed manager for PostgreSQL
 Author-email: O2eg <oleg.ispu@yandex.ru>
 License-Expression: MIT
@@ -259,9 +259,10 @@ avoided; the runtime selects a compatible image family automatically.
 Every managed image installs PgBouncer 1.25.2, `iproute2`, `lshw`, OpenSSH server, `procps`,
 `sysstat`, `util-linux`, plus the `pg_wait_sampling` and `pg_stat_kcache` packages. Every node
 runs independent PgBouncer processes for session pooling on container port 6432 and transaction
-pooling on container port 6433. Every application
-database from `app_01` through `app_10` automatically gets `pg_stat_statements`,
-`pg_wait_sampling`, `pg_buffercache`, and `pg_stat_kcache`. The `auto_explain` module is also
+pooling on container port 6433. Every connectable database, including `app_01` through
+`app_10`, `postgres`, and `template1`, automatically gets `pg_stat_statements`,
+`pg_wait_sampling`, `pg_buffercache`, and `pg_stat_kcache`. New databases created from
+`template1` inherit these extensions; `template0` remains pristine. The `auto_explain` module is also
 loaded through
 `shared_preload_libraries`. Planning tracking for `pg_stat_statements` and `pg_stat_kcache` is
 enabled only on PostgreSQL 13 and newer.
@@ -503,6 +504,8 @@ stand is stopped or removed. `stop` and `down` release the lock. A failed partia
 the lock when it has already started a database node, so another stand cannot start around the
 failure. Destructive storage cleanup retains the lock until mounted data and credentials are no
 longer being changed, which prevents a concurrent `up` from racing with deletion.
+`plan` reports `blocked` when the active lease belongs to another stand or project
+directory, before suggesting `up` or an apply operation.
 
 Persistent container and network names must end with `-pg-stand-managed`. Every resource also
 has mandatory project, project-directory instance, managed, resource-kind, node, and

{pg_stand-0.2.2 → pg_stand-0.2.4}/tests/test_runtime.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import json
 import shutil
+import subprocess
 from dataclasses import replace
 from datetime import datetime, timezone
 from pathlib import Path
@@ -37,6 +38,8 @@ from pg_stand.runtime import (
     standby_postgres_command,
 )
 from pg_stand.runtime_common import (
+    DIAGNOSTIC_EXTENSIONS,
+    DIAGNOSTIC_PRELOADS,
     IMAGE_BASE_LABEL,
     IMAGE_FAMILY_LABEL,
     IMAGE_MAJOR_LABEL,
@@ -51,6 +54,37 @@ ROOT = Path(__file__).resolve().parents[1]
 ASSET_ROOT = ROOT / "src" / "pg_stand"
 
 
+def test_diagnostic_extensions_cover_existing_and_future_databases(tmp_path: Path) -> None:
+    config = load_config(ASSET_ROOT / "configs" / "single.yaml", project_directory=tmp_path)
+    manager = StandManager(config, client=object())
+    container = object()
+    databases = ["app_01", "custom\ndb", "postgres", "template1"]
+
+    def psql(_container, sql, **kwargs):
+        if "pg_available_extensions" in sql:
+            return "\n".join(DIAGNOSTIC_EXTENSIONS)
+        if "pg_catalog.pg_database" in sql:
+            assert "datallowconn" in sql and "datname <> 'template0'" in sql
+            return json.dumps(databases)
+        if sql == "show shared_preload_libraries":
+            return ",".join(DIAGNOSTIC_PRELOADS)
+        return ""
+
+    manager._exec = MagicMock()
+    manager._psql = MagicMock(side_effect=psql)
+    manager._ensure_diagnostic_extensions(container)
+    installed = {
+        (call.kwargs["database"], call.args[1])
+        for call in manager._psql.call_args_list
+        if call.args[1].startswith("create extension")
+    }
+    assert installed == {
+        (database, f'create extension if not exists "{extension}"')
+        for database in databases
+        for extension in DIAGNOSTIC_EXTENSIONS
+    }
+
+
 @pytest.fixture(scope="session")
 def credential_template(tmp_path_factory: pytest.TempPathFactory) -> Path:
     project = tmp_path_factory.mktemp("credential-template")
@@ -277,6 +311,47 @@ def test_readiness_waits_for_final_postgres_pid_one() -> None:
     assert "/proc/1/comm" in command[2]
 
 
+@pytest.mark.parametrize(
+    ("pid_one", "children", "child_processes", "ready"),
+    [
+        ("postgres", "", {}, True),
+        ("docker-init", "7 ", {"7": "postgres"}, True),
+        ("docker-init", "7 84 ", {"7": "bash", "84": "postgres"}, False),
+        ("docker-init", "", {}, False),
+        ("bash", "84 ", {"84": "postgres"}, False),
+    ],
+)
+def test_readiness_checks_final_server_behind_docker_init(
+    tmp_path: Path, pid_one: str, children: str, child_processes: dict[str, str], ready: bool
+) -> None:
+    config = load_config(ASSET_ROOT / "configs" / "single.yaml", environment={})
+    manager = StandManager(config, client=object())
+    container = MagicMock(status="running")
+    container.exec_run.return_value = SimpleNamespace(exit_code=0, output=b"ready")
+    manager._wait_for_postgres(container, timeout_seconds=5)
+    command = container.exec_run.call_args.args[0]
+
+    proc = tmp_path / "proc"
+    (proc / "1/task/1").mkdir(parents=True)
+    (proc / "1/comm").write_text(pid_one + "\n")
+    (proc / "1/task/1/children").write_text(children)
+    for pid, process in child_processes.items():
+        (proc / pid).mkdir()
+        (proc / pid / "comm").write_text(process + "\n")
+    probe = tmp_path / "pg_isready"
+    probe.write_text('#!/bin/sh\nprintf "%s\\n" "$@"\n')
+    probe.chmod(0o755)
+    script = command[2].replace("/proc/", "./proc/").replace("exec pg_isready", "exec ./pg_isready")
+    result = subprocess.run(
+        [*command[:2], script, *command[3:]], cwd=tmp_path, text=True, capture_output=True
+    )
+    assert (result.returncode == 0) is ready, result.stderr
+    if ready:
+        assert result.stdout.splitlines() == ["--username", "postgres", "--dbname", "postgres"]
+    else:
+        assert "waiting for final postgres process" in result.stdout
+
+
 def test_active_lock_rejects_a_second_project() -> None:
     config = load_config(ASSET_ROOT / "configs" / "single.yaml", environment={})
     client = MagicMock()
@@ -325,6 +400,40 @@ def test_active_lock_is_created_with_exclusive_managed_identity() -> None:
     assert kwargs["labels"][RESOURCE_KIND_LABEL] == "active-lock"
 
 
+@pytest.mark.parametrize("applied", [False, True])
+def test_plan_reports_foreign_active_stand_before_claiming_it_can_apply(
+    tmp_path: Path,
+    applied: bool,
+) -> None:
+    config = load_config(ASSET_ROOT / "configs" / "single.yaml", project_directory=tmp_path)
+    client = MagicMock()
+    client.networks.list.return_value = [
+        _Resource(
+            {
+                "Labels": {
+                    PROJECT_LABEL: "another-stand",
+                    MANAGED_LABEL: "true",
+                    RESOURCE_KIND_LABEL: "active-lock",
+                }
+            },
+            name=ACTIVE_LOCK_NETWORK,
+        ),
+    ]
+    manager = StandManager(config, client=client)
+    if applied:
+        manager._record_applied_state()
+    blocked = manager.plan()
+    assert blocked["required_action"] == "blocked"
+    assert blocked["can_apply"] is False
+    assert "another-stand" in blocked["reason"]
+    client.networks.create.assert_not_called()
+    client.containers.run.assert_not_called()
+    client.networks.list.return_value = []
+    available = manager.plan()
+    assert available["required_action"] == ("none" if applied else "up")
+    assert available["plan_hash"] != blocked["plan_hash"]
+
+
 @pytest.mark.parametrize(
     ("version", "pgdata", "data_mount"),
     [