Merge branch 'main' into dpe-4533-flaky-test

Author: dragomirp

docs/how-to/h-monitor/h-enable-tracing.md

@@ -48,7 +48,7 @@ Integrate `tempo-k8s` with the COS charms as follows:
 ```shell
 juju integrate tempo-k8s:grafana-dashboard grafana:grafana-dashboard
 juju integrate tempo-k8s:grafana-source grafana:grafana-source
-juju integrate tempo-k8s:ingress traefik:traefik
+juju integrate tempo-k8s:ingress traefik:traefik-route
 juju integrate tempo-k8s:metrics-endpoint prometheus:metrics-endpoint
 juju integrate tempo-k8s:logging loki:logging
 ```

src/charm.py

@@ -294,9 +294,7 @@ def get_secret(self, scope: Scopes, key: str) -> Optional[str]:
             return None
         secret_key = self._translate_field_to_secret_key(key)
         # Old translation in databag is to be taken
-        if key != secret_key and (
-            result := self.peer_relation_data(scope).fetch_my_relation_field(peers.id, key)
-        ):
+        if result := self.peer_relation_data(scope).fetch_my_relation_field(peers.id, key):
             return result
 
         return self.peer_relation_data(scope).get_secret(peers.id, secret_key)
@@ -312,10 +310,7 @@ def set_secret(self, scope: Scopes, key: str, value: Optional[str]) -> Optional[
         peers = self.model.get_relation(PEER)
         secret_key = self._translate_field_to_secret_key(key)
         # Old translation in databag is to be deleted
-        if key != secret_key and self.peer_relation_data(scope).fetch_my_relation_field(
-            peers.id, key
-        ):
-            self.peer_relation_data(scope).delete_relation_data(peers.id, [key])
+        self.peer_relation_data(scope).delete_relation_data(peers.id, [key])
         self.peer_relation_data(scope).set_secret(peers.id, secret_key, value)
 
     def remove_secret(self, scope: Scopes, key: str) -> None:
@@ -1091,10 +1086,18 @@ def _on_start(self, event: StartEvent) -> None:
         # On replicas, only prepare for starting the instance later.
         if not self.unit.is_leader():
             self._start_replica(event)
+            self._restart_services_after_reboot()
             return
 
         # Bootstrap the cluster in the leader unit.
         self._start_primary(event)
+        self._restart_services_after_reboot()
+
+    def _restart_services_after_reboot(self):
+        """Restart the Patroni and pgBackRest after a reboot."""
+        if self._unit_ip in self.members_ips:
+            self._patroni.start_patroni()
+            self.backup.start_stop_pgbackrest_service()
 
     def _setup_exporter(self) -> None:
         """Set up postgresql_exporter options."""

src/constants.py

@@ -38,7 +38,10 @@
 SNAP_PACKAGES = [
     (
         POSTGRESQL_SNAP_NAME,
-        {"revision": {"aarch64": "114", "x86_64": "115"}, "channel": "14/stable"},
+        {
+            "revision": {"aarch64": "121", "x86_64": "120"},
+            "channel": "14/stable",
+        },
     )
 ]
 

src/dependency.json

@@ -9,6 +9,6 @@
     "dependencies": {},
     "name": "charmed-postgresql",
     "upgrade_supported": "^14",
-    "version": "14.11"
+    "version": "14.12"
   }
 }

tests/unit/test_charm.py

@@ -1,6 +1,7 @@
 # Copyright 2021 Canonical Ltd.
 # See LICENSE file for licensing details.
 import itertools
+import json
 import logging
 import platform
 import subprocess
@@ -558,6 +559,9 @@ def test_enable_disable_extensions(harness, caplog):
 @patch_network_get(private_address="1.1.1.1")
 def test_on_start(harness):
     with (
+        patch(
+            "charm.PostgresqlOperatorCharm._restart_services_after_reboot"
+        ) as _restart_services_after_reboot,
         patch(
             "charm.PostgresqlOperatorCharm._set_primary_status_message"
         ) as _set_primary_status_message,
@@ -617,33 +621,41 @@ def test_on_start(harness):
         harness.charm.on.start.emit()
         _bootstrap_cluster.assert_called_once()
         _oversee_users.assert_not_called()
+        _restart_services_after_reboot.assert_called_once()
         assert isinstance(harness.model.unit.status, BlockedStatus)
         # Set an initial waiting status (like after the install hook was triggered).
         harness.model.unit.status = WaitingStatus("fake message")
 
         # Test the event of an error happening when trying to create the default postgres user.
+        _restart_services_after_reboot.reset_mock()
         _member_started.return_value = True
         harness.charm.on.start.emit()
         _postgresql.create_user.assert_called_once()
         _oversee_users.assert_not_called()
+        _restart_services_after_reboot.assert_called_once()
         assert isinstance(harness.model.unit.status, BlockedStatus)
 
         # Set an initial waiting status again (like after the install hook was triggered).
         harness.model.unit.status = WaitingStatus("fake message")
 
         # Then test the event of a correct cluster bootstrapping.
+        _restart_services_after_reboot.reset_mock()
         harness.charm.on.start.emit()
         assert _postgresql.create_user.call_count == 4  # Considering the previous failed call.
         _oversee_users.assert_called_once()
         _enable_disable_extensions.assert_called_once()
         _set_primary_status_message.assert_called_once()
+        _restart_services_after_reboot.assert_called_once()
 
 
 @patch_network_get(private_address="1.1.1.1")
 def test_on_start_replica(harness):
     with (
         patch("charm.snap.SnapCache") as _snap_cache,
         patch("charm.Patroni.get_postgresql_version") as _get_postgresql_version,
+        patch(
+            "charm.PostgresqlOperatorCharm._restart_services_after_reboot"
+        ) as _restart_services_after_reboot,
         patch("charm.Patroni.configure_patroni_on_unit") as _configure_patroni_on_unit,
         patch(
             "charm.Patroni.member_started",
@@ -674,25 +686,30 @@ def test_on_start_replica(harness):
         harness.charm._peers.data[harness.charm.app].update({"cluster_initialised": ""})
         harness.charm.on.start.emit()
         _defer.assert_called_once()
+        _restart_services_after_reboot.assert_called_once()
 
         # Set an initial waiting status again (like after a machine restart).
         harness.model.unit.status = WaitingStatus("fake message")
 
         # Mark the cluster as initialised and with the workload up and running.
+        _restart_services_after_reboot.reset_mock()
         harness.charm._peers.data[harness.charm.app].update({"cluster_initialised": "True"})
         _member_started.return_value = True
         harness.charm.on.start.emit()
         _configure_patroni_on_unit.assert_not_called()
+        _restart_services_after_reboot.assert_called_once()
         assert isinstance(harness.model.unit.status, ActiveStatus)
 
         # Set an initial waiting status (like after the install hook was triggered).
         harness.model.unit.status = WaitingStatus("fake message")
 
         # Check that the unit status doesn't change when the workload is not running.
         # In that situation only Patroni is configured in the unit (but not started).
+        _restart_services_after_reboot.reset_mock()
         _member_started.return_value = False
         harness.charm.on.start.emit()
         _configure_patroni_on_unit.assert_called_once()
+        _restart_services_after_reboot.assert_called_once()
         assert isinstance(harness.model.unit.status, WaitingStatus)
 
 
@@ -2447,70 +2464,104 @@ def test_set_primary_status_message(harness, is_leader):
                 harness.charm._set_primary_status_message()
                 tc.assertIsInstance(harness.charm.unit.status, MaintenanceStatus)
 
-    @patch("charm.Patroni.update_patroni_restart_condition")
-    @patch("charm.Patroni.get_patroni_restart_condition")
-    @patch("charm.PostgresqlOperatorCharm._unit_ip")
-    def test_override_patroni_restart_condition(
-        self, _unit_ip, get_restart_condition, update_restart_condition
+
+def test_override_patroni_restart_condition(harness):
+    with (
+        patch("charm.Patroni.update_patroni_restart_condition") as _update_restart_condition,
+        patch("charm.Patroni.get_patroni_restart_condition") as _get_restart_condition,
+        patch("charm.PostgresqlOperatorCharm._unit_ip") as _unit_ip,
     ):
-        get_restart_condition.return_value = "always"
+        _get_restart_condition.return_value = "always"
 
         # Do override without repeat_cause
-        assert self.charm.override_patroni_restart_condition("no") is True
-        get_restart_condition.assert_called_once()
-        update_restart_condition.assert_called_once_with("no")
-        get_restart_condition.reset_mock()
-        update_restart_condition.reset_mock()
+        assert harness.charm.override_patroni_restart_condition("no", None) is True
+        _get_restart_condition.assert_called_once()
+        _update_restart_condition.assert_called_once_with("no")
+        _get_restart_condition.reset_mock()
+        _update_restart_condition.reset_mock()
 
-        get_restart_condition.return_value = "no"
+        _get_restart_condition.return_value = "no"
 
         # Must not be overridden twice without repeat_cause
-        assert self.charm.override_patroni_restart_condition("on-failure") is False
-        get_restart_condition.assert_called_once()
-        update_restart_condition.assert_not_called()
-        get_restart_condition.reset_mock()
-        update_restart_condition.reset_mock()
+        assert harness.charm.override_patroni_restart_condition("on-failure", None) is False
+        _get_restart_condition.assert_called_once()
+        _update_restart_condition.assert_not_called()
+        _get_restart_condition.reset_mock()
+        _update_restart_condition.reset_mock()
 
         # Reset override
-        self.charm.restore_patroni_restart_condition()
-        update_restart_condition.assert_called_once_with("always")
-        update_restart_condition.reset_mock()
+        harness.charm.restore_patroni_restart_condition()
+        _update_restart_condition.assert_called_once_with("always")
+        _update_restart_condition.reset_mock()
 
         # Must not be reset twice
-        self.charm.restore_patroni_restart_condition()
-        update_restart_condition.assert_not_called()
-        update_restart_condition.reset_mock()
+        harness.charm.restore_patroni_restart_condition()
+        _update_restart_condition.assert_not_called()
+        _update_restart_condition.reset_mock()
 
-        get_restart_condition.return_value = "always"
+        _get_restart_condition.return_value = "always"
 
         # Do override with repeat_cause
-        assert self.charm.override_patroni_restart_condition("no", "test_charm") is True
-        get_restart_condition.assert_called_once()
-        update_restart_condition.assert_called_once_with("no")
-        get_restart_condition.reset_mock()
-        update_restart_condition.reset_mock()
+        assert harness.charm.override_patroni_restart_condition("no", "test_charm") is True
+        _get_restart_condition.assert_called_once()
+        _update_restart_condition.assert_called_once_with("no")
+        _get_restart_condition.reset_mock()
+        _update_restart_condition.reset_mock()
 
-        get_restart_condition.return_value = "no"
+        _get_restart_condition.return_value = "no"
 
         # Do re-override with repeat_cause
-        assert self.charm.override_patroni_restart_condition("on-success", "test_charm") is True
-        get_restart_condition.assert_called_once()
-        update_restart_condition.assert_called_once_with("on-success")
-        get_restart_condition.reset_mock()
-        update_restart_condition.reset_mock()
+        assert harness.charm.override_patroni_restart_condition("on-success", "test_charm") is True
+        _get_restart_condition.assert_called_once()
+        _update_restart_condition.assert_called_once_with("on-success")
+        _get_restart_condition.reset_mock()
+        _update_restart_condition.reset_mock()
 
-        get_restart_condition.return_value = "on-success"
+        _get_restart_condition.return_value = "on-success"
 
         # Must not be re-overridden with different repeat_cause
         assert (
-            self.charm.override_patroni_restart_condition("on-failure", "test_not_charm") is False
+            harness.charm.override_patroni_restart_condition("on-failure", "test_not_charm")
+            is False
         )
-        get_restart_condition.assert_called_once()
-        update_restart_condition.assert_not_called()
-        get_restart_condition.reset_mock()
-        update_restart_condition.reset_mock()
+        _get_restart_condition.assert_called_once()
+        _update_restart_condition.assert_not_called()
+        _get_restart_condition.reset_mock()
+        _update_restart_condition.reset_mock()
 
         # Reset override
-        self.charm.restore_patroni_restart_condition()
-        update_restart_condition.assert_called_once_with("always")
-        update_restart_condition.reset_mock()
+        harness.charm.restore_patroni_restart_condition()
+        _update_restart_condition.assert_called_once_with("always")
+        _update_restart_condition.reset_mock()
+
+
+def test_restart_services_after_reboot(harness):
+    with (
+        patch(
+            "backups.PostgreSQLBackups.start_stop_pgbackrest_service"
+        ) as _start_stop_pgbackrest_service,
+        patch("charm.Patroni.start_patroni") as _start_patroni,
+        patch(
+            "charm.PostgresqlOperatorCharm._unit_ip",
+            new_callable=PropertyMock(return_value="1.1.1.1"),
+        ) as _unit_ip,
+    ):
+        with harness.hooks_disabled():
+            harness.update_relation_data(
+                harness.model.get_relation(PEER).id,
+                harness.charm.app.name,
+                {"members_ips": json.dumps([])},
+            )
+        harness.charm._restart_services_after_reboot()
+        _start_patroni.assert_not_called()
+        _start_stop_pgbackrest_service.assert_not_called()
+
+        with harness.hooks_disabled():
+            harness.update_relation_data(
+                harness.model.get_relation(PEER).id,
+                harness.charm.app.name,
+                {"members_ips": json.dumps([_unit_ip])},
+            )
+        harness.charm._restart_services_after_reboot()
+        _start_patroni.assert_called_once()
+        _start_stop_pgbackrest_service.assert_called_once()