phlo-postgres 0.4.0__tar.gz → 0.14.0__tar.gz

{phlo_postgres-0.4.0 → phlo_postgres-0.14.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: phlo-postgres
-Version: 0.4.0
+Version: 0.14.0
 Summary: Postgres service plugin for Phlo
 Author-email: Phlo Team <team@phlo.dev>
 License: MIT
 Requires-Python: >=3.11
 Description-Content-Type: text/plain
-Requires-Dist: phlo>=0.1.0
+Requires-Dist: phlo<0.15,>=0.14.0
 Requires-Dist: psycopg2-binary>=2.9.11
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"

{phlo_postgres-0.4.0 → phlo_postgres-0.14.0}/pyproject.toml

@@ -7,13 +7,13 @@ requires = [
 
 [project]
 dependencies = [
-    "phlo>=0.1.0",
+    "phlo>=0.14.0,<0.15",
     "psycopg2-binary>=2.9.11",
 ]
 description = "Postgres service plugin for Phlo"
 name = "phlo-postgres"
 requires-python = ">=3.11"
-version = "0.4.0"
+version = "0.14.0"
 
 [[project.authors]]
 email = "team@phlo.dev"

{phlo_postgres-0.4.0 → phlo_postgres-0.14.0}/src/phlo_postgres/__init__.py

@@ -19,12 +19,14 @@ from phlo_postgres.plugin import PostgresServicePlugin
 from phlo_postgres.publish_target import PostgresPublishTarget
 from phlo_postgres.resource import PostgresResource
 from phlo_postgres.settings import PostgresSettings, get_settings
+from phlo_postgres.settings_store import PostgresSettingsStore
 
 __all__ = [
     "PostgresPublishTarget",
     "PostgresResource",
     "PostgresServicePlugin",
     "PostgresSettings",
+    "PostgresSettingsStore",
     "get_settings",
 ]
-__version__ = "0.4.0"
+__version__ = "0.14.0"

{phlo_postgres-0.4.0 → phlo_postgres-0.14.0}/src/phlo_postgres/authorization.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from phlo.cli.authorization import cli_surface_adapter_class
+from phlo.cli.authorization import CliSurfaceAdapter, cli_surface_adapter_class
 
 SURFACE_NAME = "phlo-postgres-cli"
 FRAMEWORK_TYPE = "cli"
@@ -37,5 +37,5 @@ PostgresCliSurfaceAdapter = cli_surface_adapter_class(
 )
 
 
-def get_postgres_cli_adapter() -> PostgresCliSurfaceAdapter:
+def get_postgres_cli_adapter() -> CliSurfaceAdapter:
     return PostgresCliSurfaceAdapter.get_instance()

{phlo_postgres-0.4.0 → phlo_postgres-0.14.0}/src/phlo_postgres/exporter_service.yaml

@@ -4,7 +4,7 @@ category: observability
 default: false
 profile: observability
 
-image: quay.io/prometheuscommunity/postgres-exporter:v0.15.0
+image: quay.io/prometheuscommunity/postgres-exporter:v0.20.1@sha256:ac5ec343104fae0e2d84a27bb8d69b38430a11910c5382cad85d478d2bab713e
 
 depends_on:
   - postgres

{phlo_postgres-0.4.0 → phlo_postgres-0.14.0}/src/phlo_postgres/plugin.py

@@ -16,11 +16,12 @@ Example:
 
 from __future__ import annotations
 
-from phlo.capabilities import PublishTargetSpec, ResourceSpec
+from phlo.capabilities import PublishTargetSpec, ResourceSpec, SettingsStoreSpec
 from phlo.plugins import PluginMetadata, ResourceProviderPlugin, service_plugin_class
 
 from phlo_postgres.publish_target import PostgresPublishTarget
 from phlo_postgres.resource import PostgresResource
+from phlo_postgres.settings_store import get_settings_stores
 
 
 PostgresServicePlugin = service_plugin_class(
@@ -128,3 +129,13 @@ class PostgresResourceProvider(ResourceProviderPlugin):
                 metadata={"target_system": "postgres", "role": "serving"},
             )
         ]
+
+    def get_settings_stores(self) -> list[SettingsStoreSpec]:
+        """Return settings store capability specs for durable Observatory settings.
+
+        Returns:
+            list[SettingsStoreSpec]: Capability spec wrapping a
+            :class:`~phlo_postgres.settings_store.PostgresSettingsStore`
+            that persists Observatory settings to PostgreSQL.
+        """
+        return get_settings_stores()

{phlo_postgres-0.4.0 → phlo_postgres-0.14.0}/src/phlo_postgres/service.yaml

@@ -6,7 +6,7 @@ default: true
 depends_on:
   - postgres-volume-setup
 
-image: postgres:16-alpine
+image: postgres:18.4-alpine3.24@sha256:9a8afca54e7861fd90fab5fdf4c42477a6b1cb7d293595148e674e0a3181de15
 
 compose:
   restart: unless-stopped
@@ -26,7 +26,7 @@ compose:
   ports:
     - "${POSTGRES_PORT:-10000}:5432"
   volumes:
-    - postgres-data:/var/lib/postgresql/data
+    - postgres-data:/var/lib/postgresql
   healthcheck:
     test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-phlo}"]
     interval: 10s
@@ -47,6 +47,7 @@ env_vars:
   POSTGRES_PORT:
     default: 10000
     description: PostgreSQL host port
+
   # SSL/TLS
   POSTGRES_SSL_MODE:
     default: "prefer"

{phlo_postgres-0.4.0 → phlo_postgres-0.14.0}/src/phlo_postgres/settings.py

@@ -15,13 +15,14 @@ Example:
 
 from __future__ import annotations
 
-from functools import lru_cache
+from pathlib import Path
 from typing import Any
 from urllib.parse import quote_plus
 
 from pydantic import Field
 
 from phlo.config.base import BaseConfig
+from phlo.config.cache import project_root_cached
 from phlo.config.network import resolve_host
 
 
@@ -123,25 +124,27 @@ class PostgresSettings(BaseConfig):
         return f"postgresql://{user}:{password}@{self.postgres_host}:{self.postgres_port}{db_part}"
 
 
-@lru_cache(maxsize=1)
-def get_settings() -> PostgresSettings:
-    """Return cached PostgreSQL settings instance.
+@project_root_cached
+def get_settings(project_root: Path) -> PostgresSettings:
+    """Return cached PostgreSQL settings for the selected project root.
 
-    Provides a singleton-style access to PostgreSQL settings with LRU caching
-    to avoid repeated parsing of environment variables and configuration files.
+    Settings are cached per resolved project root, with up to 16 entries,
+    to avoid repeated parsing while isolating project configuration.
+
+    Args:
+        project_root: Resolved project root used for cache selection.
 
     Returns:
         PostgresSettings: Cached settings instance.
 
     Note:
-        The cache size of 1 ensures the same settings object is returned
-        throughout the process lifetime. Settings are loaded once on first
-        call and reused thereafter.
+        Calls for the same project root return the same settings object.
+        Call ``get_settings.cache_clear()`` after changing configuration.
 
     Example:
         >>> settings1 = get_settings()
         >>> settings2 = get_settings()
-        >>> settings1 is settings2  # Same cached instance
+        >>> settings1 is settings2  # Same cached instance for this root
         True
         >>>
         >>> # Access connection parameters

phlo_postgres-0.14.0/src/phlo_postgres/settings_store.py

@@ -0,0 +1,224 @@
+"""PostgreSQL settings store capability for Observatory settings.
+
+This module is the sole owner of the durable Observatory settings
+implementation: psycopg2 usage, SQL table creation, DSN handling, and
+connection-failure sanitisation.  It registers a ``SettingsStoreSpec``
+with the phlo capability registry so that core's ``get_settings_service``
+can resolve it without importing this package directly.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from jsonschema import ValidationError, validate
+
+from phlo.capabilities import SettingsStoreSpec
+from phlo.logging import get_logger
+from phlo.plugins.observatory_settings import (
+    ObservatorySettingsStorageConfig,
+    SettingsRecord,
+    SettingsScope,
+    StorageUnavailableError,
+)
+from phlo_postgres.settings import get_settings as get_postgres_settings
+
+logger = get_logger(__name__)
+
+
+def _get_psycopg2():
+    try:
+        import psycopg2
+        import psycopg2.extras
+    except ModuleNotFoundError as exc:
+        raise ModuleNotFoundError(
+            "psycopg2 is required to use PostgreSQL-backed observatory settings storage."
+        ) from exc
+    return psycopg2
+
+
+class PostgresSettingsStore:
+    """Durable Observatory settings store backed by PostgreSQL.
+
+    The DSN is resolved at construction time from
+    :class:`ObservatorySettingsStorageConfig` (explicit override) or
+    :mod:`phlo_postgres.settings` (default).  No database connection is
+    opened until ``get`` or ``put`` is called, so a transient outage does
+    not poison the instance — the next call retries the connection.
+    """
+
+    def __init__(self) -> None:
+        config = ObservatorySettingsStorageConfig()
+        if config.observatory_settings_db_url:
+            self._db_url = config.observatory_settings_db_url
+        else:
+            postgres_settings = get_postgres_settings()
+            self._db_url = postgres_settings.get_postgres_connection_string()
+        self._table_ensured = False
+
+    def get(self, scope: SettingsScope, namespace: str) -> SettingsRecord | None:
+        """Get settings for a scope and namespace."""
+        psycopg2 = _get_psycopg2()
+        try:
+            with psycopg2.connect(self._db_url) as conn:
+                self._ensure_table(conn)
+                with conn.cursor() as cursor:
+                    cursor.execute(
+                        """
+                        SELECT settings, updated_at
+                        FROM phlo_settings
+                        WHERE scope = %s AND namespace = %s
+                        """,
+                        (scope.value, namespace),
+                    )
+                    row = cursor.fetchone()
+                    if not row:
+                        logger.debug(
+                            "observatory_settings_not_found",
+                            scope=scope.value,
+                            namespace=namespace,
+                        )
+                        return None
+                    settings, updated_at = row
+                    return SettingsRecord(
+                        scope=scope,
+                        namespace=namespace,
+                        settings=settings,
+                        updated_at=updated_at.isoformat() if updated_at else None,
+                    )
+        except Exception as exc:
+            if isinstance(exc, StorageUnavailableError):
+                raise
+            logger.warning("observatory_settings_storage_unavailable", scope=scope.value)
+            raise StorageUnavailableError("Settings storage is unavailable") from exc
+
+    def put(
+        self,
+        scope: SettingsScope,
+        namespace: str,
+        settings: dict[str, Any],
+        schema: dict[str, Any] | None = None,
+    ) -> SettingsRecord:
+        """Upsert settings for a scope and namespace."""
+        self._validate(settings, schema)
+        psycopg2 = _get_psycopg2()
+        json_settings = psycopg2.extras.Json(settings)
+        try:
+            with psycopg2.connect(self._db_url) as conn:
+                self._ensure_table(conn)
+                with conn.cursor() as cursor:
+                    cursor.execute(
+                        """
+                        INSERT INTO phlo_settings (scope, namespace, settings, updated_at)
+                        VALUES (%s, %s, %s, NOW())
+                        ON CONFLICT (scope, namespace)
+                        DO UPDATE SET settings = EXCLUDED.settings, updated_at = NOW()
+                        RETURNING settings, updated_at
+                        """,
+                        (scope.value, namespace, json_settings),
+                    )
+                    stored_settings, updated_at = cursor.fetchone()
+                    conn.commit()
+                    return SettingsRecord(
+                        scope=scope,
+                        namespace=namespace,
+                        settings=stored_settings,
+                        updated_at=updated_at.isoformat() if updated_at else None,
+                    )
+        except Exception as exc:
+            if isinstance(exc, (StorageUnavailableError, ValueError)):
+                raise
+            logger.warning("observatory_settings_storage_unavailable", scope=scope.value)
+            raise StorageUnavailableError("Settings storage is unavailable") from exc
+
+    def mutate(
+        self,
+        scope: SettingsScope,
+        namespace: str,
+        mutation: Callable[[dict[str, Any] | None], dict[str, Any]],
+    ) -> SettingsRecord:
+        """Apply ``mutation`` while holding the row lock for one settings record."""
+        psycopg2 = _get_psycopg2()
+        try:
+            with psycopg2.connect(self._db_url) as conn:
+                self._ensure_table(conn)
+                with conn.cursor() as cursor:
+                    # A row lock alone cannot lock an absent record. The advisory
+                    # transaction lock also serialises first-write migration and
+                    # mutation across independent API processes.
+                    cursor.execute(
+                        "SELECT pg_advisory_xact_lock(hashtext(%s))",
+                        (f"{scope.value}:{namespace}",),
+                    )
+                    cursor.execute(
+                        """
+                        SELECT settings FROM phlo_settings
+                        WHERE scope = %s AND namespace = %s
+                        FOR UPDATE
+                        """,
+                        (scope.value, namespace),
+                    )
+                    row = cursor.fetchone()
+                    settings = mutation(row[0] if row else None)
+                    cursor.execute(
+                        """
+                        INSERT INTO phlo_settings (scope, namespace, settings, updated_at)
+                        VALUES (%s, %s, %s, NOW())
+                        ON CONFLICT (scope, namespace)
+                        DO UPDATE SET settings = EXCLUDED.settings, updated_at = NOW()
+                        RETURNING settings, updated_at
+                        """,
+                        (scope.value, namespace, psycopg2.extras.Json(settings)),
+                    )
+                    stored_settings, updated_at = cursor.fetchone()
+                    conn.commit()
+                    return SettingsRecord(
+                        scope=scope,
+                        namespace=namespace,
+                        settings=stored_settings,
+                        updated_at=updated_at.isoformat() if updated_at else None,
+                    )
+        except Exception as exc:
+            if isinstance(exc, StorageUnavailableError):
+                raise
+            logger.warning("observatory_settings_storage_unavailable", scope=scope.value)
+            raise StorageUnavailableError("Settings storage is unavailable") from exc
+
+    def _validate(self, settings: dict[str, Any], schema: dict[str, Any] | None) -> None:
+        if not schema:
+            return
+        try:
+            validate(instance=settings, schema=schema)
+        except ValidationError as exc:
+            logger.warning("observatory_settings_validation_failed", error=str(exc))
+            raise ValueError(str(exc)) from exc
+
+    def _ensure_table(self, conn) -> None:
+        if self._table_ensured:
+            return
+        with conn.cursor() as cursor:
+            cursor.execute(
+                """
+                CREATE TABLE IF NOT EXISTS phlo_settings (
+                    scope TEXT NOT NULL,
+                    namespace TEXT NOT NULL,
+                    settings JSONB NOT NULL,
+                    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+                    PRIMARY KEY (scope, namespace)
+                )
+                """
+            )
+            conn.commit()
+        self._table_ensured = True
+        logger.debug("observatory_settings_table_ensured")
+
+
+def get_settings_stores() -> list[SettingsStoreSpec]:
+    """Return capability specs for the PostgreSQL settings store."""
+    return [
+        SettingsStoreSpec(
+            name="postgres",
+            provider=PostgresSettingsStore(),
+        )
+    ]

phlo_postgres-0.14.0/src/phlo_postgres/volume_setup.yaml

@@ -0,0 +1,24 @@
+name: postgres-volume-setup
+description: Initialize PostgreSQL data volume permissions
+category: core
+default: false
+
+image: alpine:3.24.1@sha256:28bd5fe8b56d1bd048e5babf5b10710ebe0bae67db86916198a6eec434943f8b
+
+compose:
+  restart: "no"
+  user: "0:0"
+  entrypoint: /bin/sh
+  command: >
+    -c "
+    if [ -f /var/lib/postgresql/PG_VERSION ]; then
+      echo 'PostgreSQL 16 data volume detected. Back it up with PostgreSQL 16, then restore it into a new PostgreSQL 18 volume before starting Phlo.' >&2;
+      exit 1;
+    fi &&
+    mkdir -p /var/lib/postgresql &&
+    chown -R 70:70 /var/lib/postgresql &&
+    chmod 700 /var/lib/postgresql &&
+    echo 'Postgres data volume ownership initialized'
+    "
+  volumes:
+    - postgres-data:/var/lib/postgresql

{phlo_postgres-0.4.0 → phlo_postgres-0.14.0}/src/phlo_postgres.egg-info/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: phlo-postgres
-Version: 0.4.0
+Version: 0.14.0
 Summary: Postgres service plugin for Phlo
 Author-email: Phlo Team <team@phlo.dev>
 License: MIT
 Requires-Python: >=3.11
 Description-Content-Type: text/plain
-Requires-Dist: phlo>=0.1.0
+Requires-Dist: phlo<0.15,>=0.14.0
 Requires-Dist: psycopg2-binary>=2.9.11
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"

{phlo_postgres-0.4.0 → phlo_postgres-0.14.0}/src/phlo_postgres.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ src/phlo_postgres/publish_target.py
 src/phlo_postgres/resource.py
 src/phlo_postgres/service.yaml
 src/phlo_postgres/settings.py
+src/phlo_postgres/settings_store.py
 src/phlo_postgres/volume_setup.yaml
 src/phlo_postgres.egg-info/PKG-INFO
 src/phlo_postgres.egg-info/SOURCES.txt
@@ -21,4 +22,5 @@ tests/test_authorization.py
 tests/test_integration_postgres.py
 tests/test_postgres_cli.py
 tests/test_postgres_plugin.py
-tests/test_resource.py
+tests/test_resource.py
+tests/test_settings_store.py

{phlo_postgres-0.4.0 → phlo_postgres-0.14.0}/src/phlo_postgres.egg-info/requires.txt

@@ -1,4 +1,4 @@
-phlo>=0.1.0
+phlo<0.15,>=0.14.0
 psycopg2-binary>=2.9.11
 
 [dev]

phlo_postgres-0.14.0/tests/test_postgres_plugin.py

@@ -0,0 +1,69 @@
+"""Tests for Postgres service and resource plugins."""
+
+from phlo.capabilities import PublishTargetSpec
+from phlo_postgres.plugin import (
+    PostgresExporterServicePlugin,
+    PostgresResourceProvider,
+    PostgresServicePlugin,
+    PostgresVolumeSetupServicePlugin,
+)
+from phlo_postgres.publish_target import PostgresPublishTarget
+
+
+def test_postgres_service_definition():
+    """Validate Postgres service definition fields."""
+    plugin = PostgresServicePlugin()
+    service_definition = plugin.service_definition
+
+    assert service_definition["name"] == "postgres"
+    assert service_definition["category"] == "core"
+
+
+def test_postgres_service_uses_pinned_upstream_image() -> None:
+    service_definition = PostgresServicePlugin().service_definition
+
+    assert service_definition["image"] == (
+        "postgres:18.4-alpine3.24@"
+        "sha256:9a8afca54e7861fd90fab5fdf4c42477a6b1cb7d293595148e674e0a3181de15"
+    )
+    assert "build" not in service_definition
+
+
+def test_postgres_volume_setup_rejects_pre_18_data_layout() -> None:
+    command = PostgresVolumeSetupServicePlugin().service_definition["compose"]["command"]
+
+    assert "/var/lib/postgresql/PG_VERSION" in command
+    assert "PostgreSQL 16 data volume detected" in command
+    assert "exit 1" in command
+
+
+def test_postgres_exporter_uses_pinned_upstream_image() -> None:
+    service_definition = PostgresExporterServicePlugin().service_definition
+
+    assert service_definition["image"] == (
+        "quay.io/prometheuscommunity/postgres-exporter:v0.20.1@"
+        "sha256:ac5ec343104fae0e2d84a27bb8d69b38430a11910c5382cad85d478d2bab713e"
+    )
+    assert "build" not in service_definition
+
+
+def test_postgres_resource_provider():
+    """Validate Postgres resource provider output."""
+    provider = PostgresResourceProvider()
+    resources = provider.get_resources()
+
+    assert len(resources) == 1
+    assert resources[0].name == "postgres"
+
+
+def test_postgres_resource_provider_exposes_publish_target() -> None:
+    provider = PostgresResourceProvider()
+    publish_targets = provider.get_publish_targets()
+
+    assert publish_targets == [
+        PublishTargetSpec(
+            name="postgres",
+            provider=PostgresPublishTarget(),
+            metadata={"target_system": "postgres", "role": "serving"},
+        )
+    ]

phlo_postgres-0.14.0/tests/test_settings_store.py

@@ -0,0 +1,174 @@
+"""Tests for the PostgreSQL settings store capability.
+
+Verifies that phlo-postgres owns all psycopg2/SQL/DSN behavior for the
+durable Observatory settings store, including connection failure
+sanitisation, same-process recovery, and DSN override.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from phlo.capabilities import SettingsStoreSpec
+from phlo.plugins.observatory_settings import (
+    SettingsScope,
+    SettingsStore,
+    StorageUnavailableError,
+)
+from phlo_postgres.plugin import PostgresResourceProvider
+from phlo_postgres.settings_store import PostgresSettingsStore, get_settings_stores
+
+
+# ---------------------------------------------------------------------------
+# Construction and DSN resolution
+# ---------------------------------------------------------------------------
+
+
+def test_postgres_settings_store_implements_settings_store_protocol() -> None:
+    with patch("phlo_postgres.settings_store.get_postgres_settings") as mock:
+        mock.return_value.get_postgres_connection_string.return_value = (
+            "postgresql://phlo:phlo@localhost:5432/phlo"
+        )
+        store = PostgresSettingsStore()
+    assert isinstance(store, SettingsStore)
+
+
+def test_postgres_settings_store_uses_default_dsn() -> None:
+    with patch("phlo_postgres.settings_store.get_postgres_settings") as mock:
+        mock.return_value.get_postgres_connection_string.return_value = (
+            "postgresql://phlo:phlo@localhost:5432/phlo"
+        )
+        store = PostgresSettingsStore()
+    assert store._db_url == "postgresql://phlo:phlo@localhost:5432/phlo"
+
+
+def test_postgres_settings_store_uses_dsn_override(monkeypatch) -> None:
+    """Explicit PHLO_OBSERVATORY_SETTINGS_DB_URL overrides default PostgresSettings DSN."""
+    monkeypatch.setenv("PHLO_OBSERVATORY_SETTINGS_DB_URL", "postgresql://override:5432/phlo")
+    with patch("phlo_postgres.settings_store.get_postgres_settings") as mock:
+        store = PostgresSettingsStore()
+        mock.assert_not_called()
+    assert store._db_url == "postgresql://override:5432/phlo"
+
+
+# ---------------------------------------------------------------------------
+# Capability registration
+# ---------------------------------------------------------------------------
+
+
+def test_get_settings_stores_returns_capability_spec() -> None:
+    with patch("phlo_postgres.settings_store.get_postgres_settings") as mock:
+        mock.return_value.get_postgres_connection_string.return_value = (
+            "postgresql://phlo:phlo@localhost:5432/phlo"
+        )
+        specs = get_settings_stores()
+    assert len(specs) == 1
+    assert isinstance(specs[0], SettingsStoreSpec)
+    assert specs[0].name == "postgres"
+    assert isinstance(specs[0].provider, PostgresSettingsStore)
+
+
+def test_postgres_resource_provider_exposes_settings_store() -> None:
+    with patch("phlo_postgres.settings_store.get_postgres_settings") as mock:
+        mock.return_value.get_postgres_connection_string.return_value = (
+            "postgresql://phlo:phlo@localhost:5432/phlo"
+        )
+        provider = PostgresResourceProvider()
+        specs = provider.get_settings_stores()
+    assert len(specs) == 1
+    assert specs[0].name == "postgres"
+    assert isinstance(specs[0].provider, SettingsStore)
+
+
+# ---------------------------------------------------------------------------
+# Connection failure → StorageUnavailableError (no DSN leak)
+# ---------------------------------------------------------------------------
+
+
+def test_connection_failure_raises_storage_unavailable() -> None:
+    """A psycopg2 connection failure must surface as StorageUnavailableError."""
+    with patch("phlo_postgres.settings_store.get_postgres_settings") as mock:
+        mock.return_value.get_postgres_connection_string.return_value = (
+            "postgresql://invalid:5432/phlo"
+        )
+        store = PostgresSettingsStore()
+
+    with (
+        patch("psycopg2.connect", side_effect=OSError("connection refused")),
+        pytest.raises(StorageUnavailableError, match="Settings storage is unavailable"),
+    ):
+        store.get(SettingsScope.GLOBAL, "observatory")
+
+
+def test_storage_unavailable_error_contains_no_dsn() -> None:
+    """The sanitised error must not contain the DSN or password."""
+    with patch("phlo_postgres.settings_store.get_postgres_settings") as mock:
+        mock.return_value.get_postgres_connection_string.return_value = (
+            "postgresql://user:secret@host:5432/db"
+        )
+        store = PostgresSettingsStore()
+
+    with patch("psycopg2.connect", side_effect=OSError("connection refused")):
+        try:
+            store.get(SettingsScope.GLOBAL, "observatory")
+            pytest.fail("expected StorageUnavailableError")
+        except StorageUnavailableError as exc:
+            msg = str(exc)
+            assert "user:secret" not in msg
+            assert "postgresql://" not in msg
+            assert "host:5432" not in msg
+
+
+# ---------------------------------------------------------------------------
+# Same-process recovery
+# ---------------------------------------------------------------------------
+
+
+def test_recovery_after_database_becomes_available() -> None:
+    """First call fails, second call succeeds in the same process."""
+    with patch("phlo_postgres.settings_store.get_postgres_settings") as mock:
+        mock.return_value.get_postgres_connection_string.return_value = (
+            "postgresql://localhost:5432/phlo"
+        )
+        store = PostgresSettingsStore()
+
+    mock_cursor = MagicMock()
+    mock_cursor.fetchone.return_value = ({"version": 1}, None)
+    mock_conn = MagicMock()
+    mock_conn.__enter__.return_value = mock_conn
+    mock_conn.__exit__.return_value = False
+    mock_conn.cursor.return_value.__enter__.return_value = mock_cursor
+    mock_conn.cursor.return_value.__exit__.return_value = False
+
+    call_count = {"n": 0}
+
+    def fake_connect(*_args, **_kwargs):
+        call_count["n"] += 1
+        if call_count["n"] == 1:
+            raise OSError("connection refused")
+        return mock_conn
+
+    with patch("psycopg2.connect", side_effect=fake_connect):
+        with pytest.raises(StorageUnavailableError):
+            store.get(SettingsScope.GLOBAL, "observatory")
+
+        record = store.get(SettingsScope.GLOBAL, "observatory")
+        assert record is not None
+        assert record.settings == {"version": 1}
+
+
+def test_put_connection_failure_raises_storage_unavailable() -> None:
+    """PUT must also surface connection failures as StorageUnavailableError."""
+    with patch("phlo_postgres.settings_store.get_postgres_settings") as mock:
+        mock.return_value.get_postgres_connection_string.return_value = (
+            "postgresql://invalid:5432/phlo"
+        )
+        store = PostgresSettingsStore()
+
+    with (
+        patch("psycopg2.connect", side_effect=OSError("connection refused")),
+        pytest.raises(StorageUnavailableError, match="Settings storage is unavailable"),
+    ):
+        store.put(SettingsScope.GLOBAL, "observatory", {"v": 1})

phlo_postgres-0.4.0/src/phlo_postgres/volume_setup.yaml

@@ -1,20 +0,0 @@
-name: postgres-volume-setup
-description: Initialize PostgreSQL data volume permissions
-category: core
-default: false
-
-image: alpine:3.20
-
-compose:
-  restart: "no"
-  user: "0:0"
-  entrypoint: /bin/sh
-  command: >
-    -c "
-    mkdir -p /var/lib/postgresql/data &&
-    chown -R 70:70 /var/lib/postgresql/data &&
-    chmod 700 /var/lib/postgresql/data &&
-    echo 'Postgres data volume ownership initialized'
-    "
-  volumes:
-    - postgres-data:/var/lib/postgresql/data

phlo_postgres-0.4.0/tests/test_postgres_plugin.py

@@ -1,36 +0,0 @@
-"""Tests for Postgres service and resource plugins."""
-
-from phlo.capabilities import PublishTargetSpec
-from phlo_postgres.plugin import PostgresResourceProvider, PostgresServicePlugin
-from phlo_postgres.publish_target import PostgresPublishTarget
-
-
-def test_postgres_service_definition():
-    """Validate Postgres service definition fields."""
-    plugin = PostgresServicePlugin()
-    service_definition = plugin.service_definition
-
-    assert service_definition["name"] == "postgres"
-    assert service_definition["category"] == "core"
-
-
-def test_postgres_resource_provider():
-    """Validate Postgres resource provider output."""
-    provider = PostgresResourceProvider()
-    resources = provider.get_resources()
-
-    assert len(resources) == 1
-    assert resources[0].name == "postgres"
-
-
-def test_postgres_resource_provider_exposes_publish_target() -> None:
-    provider = PostgresResourceProvider()
-    publish_targets = provider.get_publish_targets()
-
-    assert publish_targets == [
-        PublishTargetSpec(
-            name="postgres",
-            provider=PostgresPublishTarget(),
-            metadata={"target_system": "postgres", "role": "serving"},
-        )
-    ]