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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: postgresql-charms-single-kernel
-Version: 16.3.9
+Version: 16.3.10
 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.9 → postgresql_charms_single_kernel-16.3.10}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "postgresql-charms-single-kernel"
 description = "Shared and reusable code for PostgreSQL-related charms"
-version = "16.3.9"
+version = "16.3.10"
 readme = "README.md"
 classifiers = [
     "Development Status :: 3 - Alpha",

{postgresql_charms_single_kernel-16.3.9 → postgresql_charms_single_kernel-16.3.10}/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.9"
+version = "16.3.10"
 readme = "README.md"
 license = {file = "LICENSE"}
 authors = [

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

@@ -188,3 +188,22 @@ RAFT_PARTNER_PREFIX = "partner_node_status_server_"
 VM_PATRONI_SERVICE_NAME = f"snap.{POSTGRESQL_SNAP_NAME}.patroni.service"
 VM_PATRONI_SERVICE_DEFAULT_PATH = f"/etc/systemd/system/{VM_PATRONI_SERVICE_NAME}"
 VM_PGBACKREST_SERVICE_NAME = "pgbackrest-service"
+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"
+K8S_PATRONI_LOGS_PATH = "16/main/patroni_logs"
+K8S_DEBIAN_DATA_SYMLINK = "var/lib/postgresql/16"
+K8S_POSTGRESQL_LOGS_SYMLINK_PATH = "var/log/postgresql"
+K8S_PATRONI_LOGS_SYMLINK_PATH = "var/log/patroni"
+K8S_PGBACKREST_LOGS_SYMLINK_PATH = "var/log/pgbackrest"
+
+## Restore
+VM_PATRONICTL_EXECUTABLE = "charmed-postgresql.patronictl"
+PATRONICTL_REMOVE_CONFIRMATION = "Yes I am aware"
+RESTORE_REPEAT_CAUSE = "restore-backup"

{postgresql_charms_single_kernel-16.3.9 → postgresql_charms_single_kernel-16.3.10}/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 Application, BlockedStatus, Relation, Unit
+from ops import ActiveStatus, Application, BlockedStatus, Relation, Unit
 
 from single_kernel_postgresql.config.enums import Substrates
 from single_kernel_postgresql.config.literals import (
@@ -68,7 +68,27 @@ class PostgreSQLPeer(RelationState):
         return self.unit.is_leader()
 
     @property
-    def is_blocked(self) -> bool:
+    def is_active_status(self) -> bool:
+        """Returns whether the unit is in an active state."""
+        return isinstance(self.unit.status, ActiveStatus)
+
+    @property
+    def rotate_logs_pid(self) -> int | None:
+        """Get the rotate-logs process PID from the unit peer relation data."""
+        if not self.relation:
+            return None
+        stored = self.relation.data[self.unit].get("rotate-logs-pid")
+        return int(stored) if stored else None
+
+    @rotate_logs_pid.setter
+    def rotate_logs_pid(self, value: int | None) -> None:
+        """Set or clear the rotate-logs process PID in the unit peer relation data."""
+        if not self.relation:
+            return
+        self.relation.data[self.unit]["rotate-logs-pid"] = str(value) if value else ""
+
+    @property
+    def is_blocked_status(self) -> bool:
         """Returns whether the unit is in a blocked state."""
         return isinstance(self.unit.status, BlockedStatus)
 
@@ -251,6 +271,20 @@ class PostgreSQLPeer(RelationState):
             return
         self.relation.data[self.unit]["stanza"] = value
 
+    @property
+    def s3_initialization_start(self) -> str | None:
+        """Get the s3-initialization-start timestamp from the unit peer relation data."""
+        if not self.relation:
+            return None
+        return self.relation.data[self.unit].get("s3-initialization-start")
+
+    @s3_initialization_start.setter
+    def s3_initialization_start(self, value: str) -> None:
+        """Set the s3-initialization-start timestamp in the unit peer relation data."""
+        if not self.relation:
+            return
+        self.relation.data[self.unit]["s3-initialization-start"] = value
+
     @property
     def s3_initialization_done(self) -> str | None:
         """Get the s3-initialization-done marker from the unit peer relation data."""

postgresql_charms_single_kernel-16.3.10/single_kernel_postgresql/events/backup.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+# Copyright 2026 Canonical Ltd.
+# See LICENSE file for licensing details.
+
+"""Handler for backup-related charm events.
+
+The charm is the composition root: the handler receives the managers and owns
+only the observers and the mapping of manager results/exceptions onto action
+results, unit statuses and defers. No business logic lives here.
+"""
+
+import logging
+from typing import TYPE_CHECKING
+
+from ops import MaintenanceStatus, Object
+from ops.charm import ActionEvent
+from ops.pebble import ExecError
+from tenacity import RetryError
+
+from single_kernel_postgresql.config.exceptions import ListBackupsError
+from single_kernel_postgresql.managers.backup import BackupManager
+from single_kernel_postgresql.utils.backup import STANDBY_CLUSTER_LIST_BACKUPS_ERROR_MESSAGE
+
+if TYPE_CHECKING:
+    from single_kernel_postgresql.charms.abstract_charm import AbstractPostgreSQLCharm
+    from single_kernel_postgresql.core.state import CharmState
+    from single_kernel_postgresql.managers.restore import RestoreManager
+
+logger = logging.getLogger(__name__)
+
+
+class BackupEventsHandler(Object):
+    """Class implementing backup-related charm events handling."""
+
+    backup_manager: BackupManager
+
+    def __init__(
+        self,
+        charm: "AbstractPostgreSQLCharm",
+        state: "CharmState",
+        backup_manager: BackupManager,
+        restore_manager: "RestoreManager",
+    ) -> None:
+        super().__init__(charm, key="backup_events")
+        self.charm = charm
+        self.state = state
+        self.backup_manager = backup_manager
+        self.restore_manager = restore_manager
+
+        # s3 relation handles the config options for s3 backups
+        self.framework.observe(
+            self.state.s3_requirer.on.credentials_changed, self._on_s3_credential_changed
+        )
+        # When the leader unit is being removed, s3_client.on.credentials_gone is performed
+        # on it (and only on it). After a new leader is elected, the S3 connection must be
+        # reinitialized.
+        self.framework.observe(self.charm.on.leader_elected, self._on_s3_credential_changed)
+        self.framework.observe(
+            self.state.s3_requirer.on.credentials_gone, self._on_s3_credential_gone
+        )
+        self.framework.observe(self.charm.on.create_backup_action, self._on_create_backup_action)
+        self.framework.observe(self.charm.on.list_backups_action, self._on_list_backups_action)
+        self.framework.observe(self.charm.on.restore_action, self._on_restore_action)
+
+    def _on_s3_credential_changed(self, event) -> None:
+        """Call the stanza initialization when the credentials or the connection info change."""
+        proceed, defer = self.backup_manager.credential_changed_checks()
+        if not proceed:
+            # The charms defer on every branch that deferred there: credentials
+            # arriving too early, mid-PITR, mid-restore, or on a unit that
+            # cannot initialise yet must be retried later, not dropped.
+            if defer:
+                event.defer()
+            return
+
+        # Start the pgBackRest service for the check_stanza to be successful. It's
+        # required to run on all the units if the tls is enabled.
+        try:
+            self.backup_manager.start_stop_pgbackrest_service()
+        except RetryError:
+            logger.debug("Cannot initialise service yet.")
+            event.defer()
+            return
+
+        self.backup_manager.reset_s3_initialization_markers()
+
+        if self.backup_manager.is_primary and self.state.peer.s3_initialization_done is None:
+            self.backup_manager.initialise_s3_repository()
+
+    def _on_s3_credential_gone(self, _) -> None:
+        """Clear the stanza and the S3 initialization markers when credentials are gone."""
+        self.backup_manager.clear_s3_state()
+
+    def _on_create_backup_action(self, event: ActionEvent) -> None:
+        """Request that pgBackRest creates a backup."""
+        backup_type = event.params.get("type", "full")
+        # The manager owns the creating-backup status bracket: the charms set
+        # Maintenance only after validation and the metadata upload, and reset
+        # Active only once the run started — never on a gate failure.
+        ok, message = self.backup_manager.create_backup(backup_type)
+        if not ok:
+            logger.error(f"Backup failed: {message}")
+            event.fail(message)
+        else:
+            event.set_results({"backup-status": "backup created"})
+
+    def _on_list_backups_action(self, event: ActionEvent) -> None:
+        """List the previously created backups."""
+        if self.backup_manager.is_standby_cluster:
+            logger.warning(STANDBY_CLUSTER_LIST_BACKUPS_ERROR_MESSAGE)
+            event.fail(STANDBY_CLUSTER_LIST_BACKUPS_ERROR_MESSAGE)
+            return
+
+        are_backup_settings_ok, validation_message = self.backup_manager.are_backup_settings_ok()
+        if not are_backup_settings_ok:
+            logger.warning(validation_message)
+            event.fail(validation_message)
+            return
+
+        try:
+            formatted_list = self.backup_manager.generate_backup_list_output()
+            event.set_results({"backups": formatted_list})
+        except (ListBackupsError, ExecError) as e:
+            # The K8s charm catches ExecError here (pgbackrest failures raise
+            # instead of returning a code); the message matches both charms.
+            logger.exception(e)
+            event.fail(f"Failed to list PostgreSQL backups with error: {e!s}")
+
+    def _on_restore_action(self, event: ActionEvent) -> None:
+        """Request that pgBackRest restores a backup."""
+        backup_id = event.params.get("backup-id")
+        restore_to_time = event.params.get("restore-to-time")
+        logger.info(
+            f"A restore with backup-id {backup_id}"
+            f"{f' to time point {restore_to_time}' if restore_to_time else ''}"
+            f" has been requested on the unit"
+        )
+
+        can_restore, error_message = self.restore_manager.pre_restore_checks(
+            backup_id, restore_to_time
+        )
+        if not can_restore:
+            event.fail(error_message)
+            return
+
+        # Validate the provided backup id and restore to time.
+        logger.info("Validating provided backup-id and restore-to-time")
+        try:
+            restore_stanza_timeline, is_backup_id_real, error_message = (
+                self.restore_manager.resolve_restore_target(backup_id, restore_to_time)
+            )
+        except ListBackupsError as e:
+            logger.exception(e)
+            error_message = "Failed to retrieve backups list"
+            logger.error(f"Restore failed: {error_message}")
+            event.fail(error_message)
+            return
+        if restore_stanza_timeline is None:
+            logger.error(f"Restore failed: {error_message}")
+            event.fail(error_message)
+            return
+
+        self.charm.set_unit_status(MaintenanceStatus("restoring backup"))
+        ok, message = self.restore_manager.restore(
+            restore_stanza_timeline, backup_id, restore_to_time, is_backup_id_real
+        )
+        if not ok:
+            logger.error(f"Restore failed: {message}")
+            event.fail(message)
+            return
+
+        event.set_results({"restore-status": "restore started"})

{postgresql_charms_single_kernel-16.3.9 → postgresql_charms_single_kernel-16.3.10}/single_kernel_postgresql/events/postgresql.py

@@ -6,7 +6,7 @@
 
 import logging
 from datetime import datetime
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING
 
 from ops import (
     InstallEvent,
@@ -30,12 +30,11 @@ from single_kernel_postgresql.managers.cluster import ClusterManager
 from single_kernel_postgresql.managers.config import ConfigManager
 from single_kernel_postgresql.managers.patroni import PatroniManager
 from single_kernel_postgresql.managers.tls import TLSManager
-from single_kernel_postgresql.workload.base import BaseWorkload
+from single_kernel_postgresql.workload.base import BaseWorkload, PebbleLayerSpec
 from single_kernel_postgresql.workload.vm import VMWorkload
 
 if TYPE_CHECKING:
     from single_kernel_postgresql.charms.abstract_charm import AbstractPostgreSQLCharm
-    from single_kernel_postgresql.charms.k8s_charm import PostgreSQLK8sCharm
 
 logger = logging.getLogger(__name__)
 
@@ -124,7 +123,6 @@ class PostgreSQLEventsHandler(Object):
 
     def _on_postgresql_pebble_ready(self, event: WorkloadEvent) -> None:
         """Event handler for PostgreSQL container on PebbleReadyEvent."""
-        charm = cast("PostgreSQLK8sCharm", self.charm)
         # TODO: Safeguard against refresh
         if self.state.endpoint in self.state.endpoints:
             # TODO: Fix pod by adding services
@@ -152,7 +150,7 @@ class PostgreSQLEventsHandler(Object):
             self.tls_manager.configure_internal_peer_cert()
 
         # Start the database service
-        charm.k8s_manager.update_pebble_layers()
+        self.workload.update_pebble_layers(PebbleLayerSpec.from_state(self.state))
 
         # Assert the member is up and running before marking it as initialised.
         if not self.patroni_manager.member_started:
@@ -192,7 +190,7 @@ class PostgreSQLEventsHandler(Object):
 
         # Doesn't try to bootstrap the cluster if it's in a blocked state
         # caused, for example, because a failed installation of packages.
-        if self.state.peer.is_blocked:
+        if self.state.peer.is_blocked_status:
             logger.debug("Early exit on_start: Unit blocked")
             return False