Improve statuses

Signed-off-by: Marcelo Henrique Neppel <[email protected]>

src/charm.py

@@ -1357,7 +1357,7 @@ def _set_primary_status_message(self) -> None:
             if self._patroni.get_primary(unit_name_pattern=True) == self.unit.name:
                 self.unit.status = ActiveStatus("Primary")
             elif self.is_standby_leader:
-                self.unit.status = ActiveStatus("Standby Leader")
+                self.unit.status = ActiveStatus("Standby")
             elif self._patroni.member_started:
                 self.unit.status = ActiveStatus()
         except (RetryError, ConnectionError) as e:

src/relations/async_replication.py

@@ -27,6 +27,7 @@
 
 from ops import (
     ActionEvent,
+    ActiveStatus,
     Application,
     BlockedStatus,
     MaintenanceStatus,
@@ -52,7 +53,7 @@
 logger = logging.getLogger(__name__)
 
 
-READ_ONLY_MODE_BLOCKING_MESSAGE = "Cluster in read-only mode"
+READ_ONLY_MODE_BLOCKING_MESSAGE = "Standalone read-only cluster"
 REPLICATION_CONSUMER_RELATION = "replication"
 REPLICATION_OFFER_RELATION = "replication-offer"
 SECRET_LABEL = "async-replication-secret"
@@ -124,13 +125,11 @@ def _can_promote_cluster(self, event: ActionEvent) -> bool:
             if standby_leader is not None:
                 try:
                     self.charm._patroni.promote_standby_cluster()
-                    if (
-                        self.charm.is_blocked
-                        and self.charm.unit.status.message == READ_ONLY_MODE_BLOCKING_MESSAGE
-                    ):
+                    if self.charm.app.status.message == READ_ONLY_MODE_BLOCKING_MESSAGE:
                         self.charm._peers.data[self.charm.app].update({
                             "promoted-cluster-counter": ""
                         })
+                        self._set_app_status()
                         self.charm._set_primary_status_message()
                 except (StandbyClusterAlreadyPromotedError, ClusterNotPromotedError) as e:
                     event.fail(str(e))
@@ -426,19 +425,11 @@ def _handle_forceful_promotion(self, event: ActionEvent) -> bool:
 
     def handle_read_only_mode(self) -> None:
         """Handle read-only mode (standby cluster that lost the relation with the primary cluster)."""
-        promoted_cluster_counter = self.charm._peers.data[self.charm.app].get(
-            "promoted-cluster-counter", ""
-        )
-        if not self.charm.is_blocked or (
-            promoted_cluster_counter != "0"
-            and self.charm.unit.status.message == READ_ONLY_MODE_BLOCKING_MESSAGE
-        ):
+        if not self.charm.is_blocked:
             self.charm._set_primary_status_message()
-        if (
-            promoted_cluster_counter == "0"
-            and self.charm.unit.status.message != READ_ONLY_MODE_BLOCKING_MESSAGE
-        ):
-            self.charm.unit.status = BlockedStatus(READ_ONLY_MODE_BLOCKING_MESSAGE)
+
+        if self.charm.unit.is_leader():
+            self._set_app_status()
 
     def _handle_replication_change(self, event: ActionEvent) -> bool:
         if not self._can_promote_cluster(event):
@@ -504,14 +495,17 @@ def _on_async_relation_broken(self, _) -> None:
         if self.charm._patroni.get_standby_leader() is not None:
             if self.charm.unit.is_leader():
                 self.charm._peers.data[self.charm.app].update({"promoted-cluster-counter": "0"})
-            self.charm.unit.status = BlockedStatus(READ_ONLY_MODE_BLOCKING_MESSAGE)
+            self._set_app_status()
         else:
             if self.charm.unit.is_leader():
                 self.charm._peers.data[self.charm.app].update({"promoted-cluster-counter": ""})
             self.charm.update_config()
 
     def _on_async_relation_changed(self, event: RelationChangedEvent) -> None:
         """Update the Patroni configuration if one of the clusters was already promoted."""
+        if self.charm.unit.is_leader():
+            self._set_app_status()
+
         primary_cluster = self._get_primary_cluster()
         logger.debug("Primary cluster: %s", primary_cluster)
         if primary_cluster is None:
@@ -590,7 +584,10 @@ def _on_create_replication(self, event: ActionEvent) -> None:
 
     def _on_promote_to_primary(self, event: ActionEvent) -> None:
         """Promote this cluster to the primary cluster."""
-        if self._get_primary_cluster() is None:
+        if (
+            self.charm.app.status.message != READ_ONLY_MODE_BLOCKING_MESSAGE
+            and self._get_primary_cluster() is None
+        ):
             event.fail(
                 "No primary cluster found. Run `create-replication` action in the cluster where the offer was created."
             )
@@ -674,6 +671,22 @@ def _relation(self) -> Relation:
             if relation is not None:
                 return relation
 
+    def _set_app_status(self) -> None:
+        """Set the app status."""
+        if self.charm._peers.data[self.charm.app].get("promoted-cluster-counter") == "0":
+            self.charm.app.status = BlockedStatus(READ_ONLY_MODE_BLOCKING_MESSAGE)
+            return
+        if self._relation is None:
+            self.charm.app.status = ActiveStatus()
+            return
+        primary_cluster = self._get_primary_cluster()
+        if primary_cluster is None:
+            self.charm.app.status = ActiveStatus()
+        else:
+            self.charm.app.status = ActiveStatus(
+                "Primary" if self.charm.app == primary_cluster else "Standby"
+            )
+
     def _stop_database(self, event: RelationChangedEvent) -> bool:
         """Stop the database."""
         if (

tests/integration/ha_tests/test_async_replication.py

@@ -288,10 +288,10 @@ async def test_promote_standby(
     async with ops_test.fast_forward(FAST_INTERVAL), fast_forward(second_model, FAST_INTERVAL):
         await gather(
             first_model.wait_for_idle(
-                apps=[DATABASE_APP_NAME],
-                status="blocked",
-                idle_period=IDLE_PERIOD,
-                timeout=TIMEOUT,
+                apps=[DATABASE_APP_NAME], idle_period=IDLE_PERIOD, timeout=TIMEOUT
+            ),
+            first_model.block_until(
+                lambda: first_model.applications[DATABASE_APP_NAME].status == "blocked",
             ),
             second_model.wait_for_idle(
                 apps=[DATABASE_APP_NAME], status="active", idle_period=IDLE_PERIOD, timeout=TIMEOUT
@@ -378,7 +378,7 @@ async def test_reestablish_relation(
     leader_unit = await get_leader_unit(ops_test, DATABASE_APP_NAME)
     assert leader_unit is not None, "No leader unit found"
     logger.info("promoting the first cluster")
-    run_action = await leader_unit.run_action("promote-to-primary")
+    run_action = await leader_unit.run_action("create-replication")
     await run_action.wait()
     assert (run_action.results.get("return-code", None) == 0) or (
         run_action.results.get("Code", None) == "0"

tests/unit/test_charm.py

@@ -2295,9 +2295,7 @@ def test_set_active_status(self, _get_primary, _is_standby_leader, _member_start
                         self.charm.unit.status.message,
                         "Primary"
                         if values[0] == self.charm.unit.name
-                        else (
-                            "Standby Leader" if values[1] else ("" if values[2] else "fake status")
-                        ),
+                        else ("Standby" if values[1] else ("" if values[2] else "fake status")),
                     )
             else:
                 _get_primary.side_effect = values[0]