postgresql-charms-single-kernel 16.3.10__tar.gz → 16.3.12__tar.gz

{postgresql_charms_single_kernel-16.3.10 → postgresql_charms_single_kernel-16.3.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: postgresql-charms-single-kernel
-Version: 16.3.10
+Version: 16.3.12
 Summary: Shared and reusable code for PostgreSQL-related charms
 Author: Canonical Data Platform
 Author-email: Canonical Data Platform <data-platform@lists.launchpad.net>

{postgresql_charms_single_kernel-16.3.10 → postgresql_charms_single_kernel-16.3.12}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "postgresql-charms-single-kernel"
 description = "Shared and reusable code for PostgreSQL-related charms"
-version = "16.3.10"
+version = "16.3.12"
 readme = "README.md"
 classifiers = [
     "Development Status :: 3 - Alpha",
@@ -157,12 +157,12 @@ exclude = [
 ]
 
 [dependency-groups]
-format = ["ruff==0.16.8"]
+format = ["ruff==0.16.10"]
 lint = [
     "codespell==2.4.3",
-    "ty==0.0.82",
+    "ty==0.0.84",
 ]
 unit = [
-    "coverage[toml]==7.16.1",
+    "coverage[toml]==7.16.2",
     "pytest==9.1.1",
 ]

{postgresql_charms_single_kernel-16.3.10 → postgresql_charms_single_kernel-16.3.12}/pyproject.toml.orig

@@ -4,7 +4,7 @@
 [project]
 name = "postgresql-charms-single-kernel"
 description = "Shared and reusable code for PostgreSQL-related charms"
-version = "16.3.10"
+version = "16.3.12"
 readme = "README.md"
 license = {file = "LICENSE"}
 authors = [
@@ -63,14 +63,14 @@ module-root = ""
 
 [dependency-groups]
 format = [
-    "ruff==0.16.8"
+    "ruff==0.16.10"
 ]
 lint = [
     "codespell==2.4.3",
-    "ty==0.0.82"
+    "ty==0.0.84"
 ]
 unit = [
-    "coverage[toml]==7.16.1",
+    "coverage[toml]==7.16.2",
     "pytest==9.1.1"
 ]
 

{postgresql_charms_single_kernel-16.3.10 → postgresql_charms_single_kernel-16.3.12}/single_kernel_postgresql/charms/abstract_charm.py

@@ -3,20 +3,26 @@
 """Skeleton for the abstract charm."""
 
 from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
 
 from data_platform_helpers.advanced_statuses import StatusHandler
 from ops import StatusBase
 from ops.charm import CharmBase
 
 from single_kernel_postgresql.core.state import CharmState
+from single_kernel_postgresql.events.async_replication import PostgreSQLAsyncReplication
 from single_kernel_postgresql.events.database import DatabaseEventsHandler
 from single_kernel_postgresql.events.ldap import LDAP
 from single_kernel_postgresql.events.postgresql import PostgreSQLEventsHandler
 from single_kernel_postgresql.events.tls import TLS
+from single_kernel_postgresql.events.watcher import WatcherEventsHandler
 from single_kernel_postgresql.lib.charms.data_platform_libs.v0.data_interfaces import (
     DatabaseProvides,
 )
 from single_kernel_postgresql.lib.charms.data_platform_libs.v0.s3 import S3Requirer
+from single_kernel_postgresql.managers.async_replication import (
+    AsyncReplicationManager,
+)
 from single_kernel_postgresql.managers.cluster import ClusterManager
 from single_kernel_postgresql.managers.config import ConfigManager
 from single_kernel_postgresql.managers.database import DatabaseManager
@@ -28,6 +34,9 @@ from ..config.enums import Substrates
 from ..config.literals import DATABASE, S3_RELATION_NAME
 from ..utils.postgresql import PostgreSQL
 
+if TYPE_CHECKING:
+    from single_kernel_postgresql.managers.k8s import K8sManager
+
 
 class AbstractPostgreSQLCharm(CharmBase, ABC):
     """An abstract PostgreSQL charm."""
@@ -60,6 +69,38 @@ class AbstractPostgreSQLCharm(CharmBase, ABC):
         self.patroni_manager = PatroniManager(state=self.state, workload=self.workload)
         self.cluster_manager = ClusterManager(state=self.state, workload=self.workload)
 
+        # Substrate-only K8s API seam: the K8s charm builds it by overriding
+        # build_k8s_manager(); VM charms need no K8s API access. Built here so the
+        # async-replication subsystem (below) can consume it.
+        k8s_manager = self.build_k8s_manager()
+
+        # Async-replication subsystem: the manager owns the data plane and the
+        # promotion/standby flows; the handler owns the observers and the public facade.
+        watcher = self._async_watcher()
+        self.async_replication_manager = AsyncReplicationManager(
+            state=self.state,
+            workload=self.workload,
+            patroni_manager=self.patroni_manager,
+            update_config=self.update_config,
+            set_unit_status=self.set_unit_status,
+            set_primary_status_message=self.set_primary_status_message,
+            set_app_status=self._recompute_async_app_status,
+            create_pgdata=self.create_pgdata,
+            fix_leader_annotation=self.fix_leader_annotation,
+            re_emit_relation_changed=self._re_emit_async_relation_changed,
+            k8s_manager=k8s_manager,
+            watcher=watcher,
+        )
+        self.async_replication = PostgreSQLAsyncReplication(
+            self,
+            self.state,
+            self.async_replication_manager,
+            self.patroni_manager,
+            self.workload,
+            k8s_manager=k8s_manager,
+            watcher=watcher,
+        )
+
         # Client-relation subsystem: the charm is the composition root, as with the
         # other managers; the handler owns only the observers and guard/defer decisions.
         self.database_manager = DatabaseManager(
@@ -94,6 +135,7 @@ class AbstractPostgreSQLCharm(CharmBase, ABC):
             self.config_manager,
             self.patroni_manager,
         )
+        self.watcher_handler = WatcherEventsHandler(self, self.workload, self.state)
 
         # Status Handler
         self.status_handler = StatusHandler(
@@ -146,6 +188,16 @@ class AbstractPostgreSQLCharm(CharmBase, ABC):
         """Restart the monitoring and LDAP-sync sidecar services."""
         pass
 
+    @abstractmethod
+    def set_app_status(self, status: StatusBase) -> None:
+        """Set the application status through the charm's own status gates."""
+        pass
+
+    @abstractmethod
+    def set_primary_status_message(self) -> None:
+        """Recompute the unit's primary/standby status message."""
+        pass
+
     @abstractmethod
     def set_unit_status(self, status: StatusBase) -> None:
         """Set the unit status without overriding a higher-priority refresh status."""
@@ -156,6 +208,34 @@ class AbstractPostgreSQLCharm(CharmBase, ABC):
         """Re-render the Patroni configuration and apply it."""
         pass
 
+    # Async-replication wiring helpers. The manager is constructed before the handler,
+    # so the framework-facing plumbing is re-exposed through these late-binding bridges;
+    # create_pgdata/fix_leader_annotation are K8s-only and default to no-ops the K8s
+    # charm overrides.
+    def _recompute_async_app_status(self) -> None:
+        """Recompute the async-replication app status through the handler."""
+        self.async_replication.set_app_status()
+
+    def _re_emit_async_relation_changed(self) -> None:
+        """Re-emitting the async relation-changed event goes through the handler."""
+        self.async_replication._re_emit_async_relation_changed_event()
+
+    def _async_watcher(self) -> "WatcherEventsHandler | None":
+        """Overridable hook supplying the VM watcher bridge (K8s has none)."""
+        return None
+
+    def build_k8s_manager(self) -> "K8sManager | None":
+        """Overridable hook supplying the K8s API seam (K8s charm only)."""
+        return None
+
+    def create_pgdata(self) -> None:
+        """Create the PostgreSQL data directories (K8s only; overridden there)."""
+        return None
+
+    def fix_leader_annotation(self) -> bool:
+        """Fix the leader annotation (K8s only; overridden there)."""
+        return False
+
     @property
     @abstractmethod
     def primary_endpoint(self) -> str | None:

{postgresql_charms_single_kernel-16.3.10 → postgresql_charms_single_kernel-16.3.12}/single_kernel_postgresql/charms/k8s_charm.py

@@ -5,6 +5,7 @@
 """PostgreSQL Kubernetes Charm."""
 
 import logging
+from typing import cast
 
 from ops import StatusBase
 
@@ -21,13 +22,24 @@ logger = logging.getLogger(__name__)
 class PostgreSQLK8sCharm(AbstractPostgreSQLCharm):
     """PostgreSQL K8s Charm."""
 
+    # Built by build_k8s_manager() while the abstract __init__ wires the
+    # async-replication subsystem; never None on the K8s substrate.
+    k8s_manager: K8sManager
+
     def __init__(self, *args):
         """Initialize the PostgreSQL Kubernetes Charm."""
         super().__init__(*args)
         assert isinstance(self.workload, K8sWorkload), (  # noqa: S101
             "Workload must be an instance of K8sWorkload"
         )
-        self.k8s_manager = K8sManager(self.state, self.workload)
+
+    def build_k8s_manager(self) -> K8sManager:
+        """Build the K8s API seam the async-replication subsystem consumes."""
+        self.k8s_manager = K8sManager(
+            self.state,
+            cast("K8sWorkload", self.workload),
+        )
+        return self.k8s_manager
 
     @property
     def postgresql(self) -> PostgreSQL:
@@ -88,6 +100,21 @@ class PostgreSQLK8sCharm(AbstractPostgreSQLCharm):
         """Re-render the Patroni configuration and apply it."""
         return self.config_manager.update_config(self.postgresql)
 
+    def set_app_status(self, status: StatusBase) -> None:
+        """Set the application status; the production charm gates this on its own state."""
+        self.app.status = status
+
+    def set_primary_status_message(self) -> None:
+        """Recompute the unit's primary/standby status message."""
+
+    def fix_leader_annotation(self) -> bool:
+        """Fix the leader annotation; the production charm owns the real implementation."""
+        return False
+
+    def create_pgdata(self) -> None:
+        """Create the PostgreSQL data directories (ported from the K8s charm)."""
+        self.workload.init_storage()
+
     @property
     def primary_endpoint(self) -> str | None:
         """Address of the cluster primary's Service."""

{postgresql_charms_single_kernel-16.3.10 → postgresql_charms_single_kernel-16.3.12}/single_kernel_postgresql/charms/vm_charm.py

@@ -79,6 +79,13 @@ class PostgreSQLVMCharm(AbstractPostgreSQLCharm):
         """Re-render the Patroni configuration and apply it."""
         return self.config_manager.update_config(self.postgresql)
 
+    def set_app_status(self, status: StatusBase) -> None:
+        """Set the application status; the production charm gates this on its own state."""
+        self.app.status = status
+
+    def set_primary_status_message(self) -> None:
+        """Recompute the unit's primary/standby status message."""
+
     @property
     def primary_endpoint(self) -> str | None:
         """Address of the cluster primary, or None when there is not one."""

{postgresql_charms_single_kernel-16.3.10 → postgresql_charms_single_kernel-16.3.12}/single_kernel_postgresql/config/literals.py

@@ -42,6 +42,8 @@ VM_PGBACKREST_LOGS_PATH = "var/log/pgbackrest"
 
 ## K8s Paths
 K8S_DATA_PATH = "var/lib/pg/data"
+K8S_ARCHIVE_PATH = "var/lib/pg/archive"
+K8S_TEMP_STORAGE_PATH = "var/lib/pg/temp"
 K8S_PGBACKREST_LOGS_PATH = "16/main/pgbackrest_logs"
 
 ## Shared Paths
@@ -134,6 +136,10 @@ ALL_CLIENT_RELATIONS = [DATABASE]
 REPLICATION_CONSUMER_RELATION = "replication"
 REPLICATION_OFFER_RELATION = "replication-offer"
 
+# Async replication peer-data key holding the id of the labelless shared cluster-credentials
+# secret the owner persists: referenced by id everywhere, never by label (DPE-10203).
+ASYNC_SHARED_SECRET_ID_KEY = "async-replication-secret-id"  # noqa: S105 — a databag key name, not a credential
+
 # TLS files
 TLS_KEY_FILE = "key.pem"
 TLS_CA_FILE = "ca.pem"
@@ -192,8 +198,6 @@ VM_ROTATE_LOGS_LOG_FILE = "/var/log/rotate_logs.log"
 
 ## K8s restore storage paths (must match the metadata.yaml storage locations)
 K8S_LOGS_STORAGE_PATH = "var/lib/pg/logs"
-K8S_ARCHIVE_PATH = "var/lib/pg/archive"
-K8S_TEMP_STORAGE_PATH = "var/lib/pg/temp"
 K8S_WAL_DIR = "pg_wal"
 K8S_TEMP_TABLESPACE_DIR = "pgsql_tmp"
 K8S_PG_LOGS_PATH = "16/main/pg_logs"
@@ -207,3 +211,7 @@ K8S_PGBACKREST_LOGS_SYMLINK_PATH = "var/log/pgbackrest"
 VM_PATRONICTL_EXECUTABLE = "charmed-postgresql.patronictl"
 PATRONICTL_REMOVE_CONFIRMATION = "Yes I am aware"
 RESTORE_REPEAT_CAUSE = "restore-backup"
+
+# Watcher relation
+RAFT_PORT = 2222
+RAFT_PARTNER_PREFIX = "partner_node_status_server_"

{postgresql_charms_single_kernel-16.3.10 → postgresql_charms_single_kernel-16.3.12}/single_kernel_postgresql/core/peer_relation.py

@@ -9,7 +9,7 @@ import json
 from collections.abc import MutableMapping
 from functools import cached_property
 
-from ops import ActiveStatus, Application, BlockedStatus, Relation, Unit
+from ops import ActiveStatus, Application, BlockedStatus, ModelError, Relation, Unit
 
 from single_kernel_postgresql.config.enums import Substrates
 from single_kernel_postgresql.config.literals import (
@@ -27,22 +27,19 @@ from single_kernel_postgresql.lib.charms.data_platform_libs.v0.data_interfaces i
 )
 
 
-class PostgreSQLPeer(RelationState):
-    """State/Relation data collection for a PostgreSQL unit."""
+class PeerRelationState(RelationState):
+    """Common state for the unit and application sides of the peer relation."""
 
-    data_interface: DataPeerUnitData
-    unit: Unit
+    data_interface: DataPeerData
 
     def __init__(
         self,
         relation: Relation | None,
-        data_interface: DataPeerUnitData,
-        component: Unit,
+        data_interface: DataPeerData,
+        component: Unit | Application,
     ):
-        """Initialize the PostgreSQLPeer object."""
         super().__init__(relation, data_interface, component)
         self.data_interface = data_interface
-        self.unit = component
 
     def get_secret(self, key: str) -> str | None:
         """Get the secret value for 'key' from the peer relation data."""
@@ -62,6 +59,23 @@ class PostgreSQLPeer(RelationState):
             return
         self.data_interface.delete_relation_data(self.relation.id, [key])
 
+
+class PostgreSQLPeer(PeerRelationState):
+    """State/Relation data collection for a PostgreSQL unit."""
+
+    data_interface: DataPeerUnitData
+    unit: Unit
+
+    def __init__(
+        self,
+        relation: Relation | None,
+        data_interface: DataPeerUnitData,
+        component: Unit,
+    ):
+        """Initialize the PostgreSQLPeer object."""
+        super().__init__(relation, data_interface, component)
+        self.unit = component
+
     @property
     def is_app_leader(self) -> bool:
         """Check if the current unit is the leader of the application."""
@@ -384,7 +398,7 @@ class PostgreSQLPeer(RelationState):
         return peer_addrs
 
 
-class PostgreSQLApplication(RelationState):
+class PostgreSQLApplication(PeerRelationState):
     """An PostgreSQL Application is the peer application state.
 
     This class defines state/relation data for a single PostgreSQL application.
@@ -403,7 +417,6 @@ class PostgreSQLApplication(RelationState):
         """Initialize the PostgreSQLApplication object."""
         super().__init__(relation, data_interface, component)
         self.app = component
-        self.data_interface = data_interface
         self.substrate = substrate
 
     @property
@@ -498,8 +511,17 @@ class PostgreSQLApplication(RelationState):
 
     @cached_property
     def planned_units(self) -> int:
-        """Get the number of planned units for the application."""
-        return self.app.planned_units()
+        """Get the number of planned units for the application.
+
+        ops implements ``Application.planned_units()`` via ``goal-state``, which fails
+        ("saas application ... not found") while a cross-model SAAS force-removed during a
+        dead-DC teardown still lingers in goal-state. Fall back to the count of currently
+        known units so the hook reconciles instead of crashing every caller (DPE-10203).
+        """
+        try:
+            return self.app.planned_units()
+        except ModelError:
+            return len(self.relation.units) + 1 if self.relation else 1
 
     @property
     def members_ips(self) -> set[str]:
@@ -674,24 +696,6 @@ class PostgreSQLApplication(RelationState):
             return
         self.relation.data[self.app]["restore-to-time"] = value
 
-    def get_secret(self, key: str) -> str | None:
-        """Get the secret value for 'key' from the peer relation data."""
-        if not self.relation:
-            return None
-        return self.data_interface.get_secret(self.relation.id, key)
-
-    def set_secret(self, key: str, value: str) -> None:
-        """Set the secret value for 'key' in the peer relation data."""
-        if not self.relation:
-            return
-        self.data_interface.set_secret(self.relation.id, key, value)
-
-    def remove_secret(self, key: str) -> None:
-        """Remove the secret value for 'key' from the peer relation data."""
-        if not self.relation:
-            return
-        self.data_interface.delete_relation_data(self.relation.id, [key])
-
     @cached_property
     def data(self) -> MutableMapping[str, str]:
         """Escape hatch method to access the peer data directly."""