split QuorumStatus to a pure dataclass and a facade

Author: tomjelinek

pcs/cluster.py

@@ -60,8 +60,11 @@
 from pcs.lib.communication.tools import RunRemotelyBase
 from pcs.lib.communication.tools import run as run_com_cmd
 from pcs.lib.communication.tools import run_and_raise
-from pcs.lib.corosync import live as corosync_live
 from pcs.lib.corosync import qdevice_net
+from pcs.lib.corosync.live import (
+    QuorumStatusException,
+    QuorumStatusFacade,
+)
 from pcs.lib.errors import LibraryError
 from pcs.lib.node import get_existing_nodes_names
 from pcs.utils import parallel_for_nodes
@@ -495,14 +498,14 @@ def stop_cluster_nodes(nodes):
                 error_list.append(node + ": " + data)
                 continue
             try:
-                quorum_status = corosync_live.parse_quorum_status(data)
-                if not quorum_status.is_quorate:
+                quorum_status_facade = QuorumStatusFacade.from_string(data)
+                if not quorum_status_facade.is_quorate:
                     # Get quorum status from a quorate node, non-quorate nodes
                     # may provide inaccurate info. If no node is quorate, there
                     # is no quorum to be lost and therefore no error to be
                     # reported.
                     continue
-                if quorum_status.stopping_nodes_cause_quorum_loss(nodes):
+                if quorum_status_facade.stopping_nodes_cause_quorum_loss(nodes):
                     utils.err(
                         "Stopping the node(s) will cause a loss of the quorum"
                         + ", use --force to override"
@@ -511,7 +514,7 @@ def stop_cluster_nodes(nodes):
                     # We have the info, no need to print errors
                     error_list = []
                     break
-            except corosync_live.QuorumStatusException:
+            except QuorumStatusException:
                 if not utils.is_node_offline_by_quorumtool_output(data):
                     error_list.append(node + ": Unable to get quorum status")
                 # else the node seems to be stopped already
@@ -688,14 +691,14 @@ def stop_cluster(argv):
         # - retval is 2 on success if a node is not in a partition with quorum
         output, dummy_retval = utils.run(["corosync-quorumtool", "-p", "-s"])
         try:
-            if corosync_live.parse_quorum_status(
+            if QuorumStatusFacade.from_string(
                 output
             ).stopping_local_node_cause_quorum_loss():
                 utils.err(
                     "Stopping the node will cause a loss of the quorum"
                     + ", use --force to override"
                 )
-        except corosync_live.QuorumStatusException:
+        except QuorumStatusException:
             if not utils.is_node_offline_by_quorumtool_output(output):
                 utils.err(
                     "Unable to determine whether stopping the node will cause "

pcs/lib/commands/cluster.py

@@ -1851,9 +1851,11 @@ def remove_nodes(
         # required, cluster has to be turned off and therefore it loses quorum.
         com_cmd = cluster.GetQuorumStatus(report_processor)
         com_cmd.set_targets(targets_to_remove)
-        failures, quorum_status = run_com(env.get_node_communicator(), com_cmd)
-        if quorum_status:
-            if quorum_status.stopping_nodes_cause_quorum_loss(node_list):
+        failures, quorum_status_facade = run_com(
+            env.get_node_communicator(), com_cmd
+        )
+        if quorum_status_facade:
+            if quorum_status_facade.stopping_nodes_cause_quorum_loss(node_list):
                 report_processor.report(
                     ReportItem(
                         severity=reports.item.get_severity(

pcs/lib/communication/cluster.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from pcs.common import reports
 from pcs.common.node_communicator import RequestData
 from pcs.common.reports.item import ReportItem
@@ -9,7 +11,10 @@
     SimpleResponseProcessingMixin,
     SkipOfflineMixin,
 )
-from pcs.lib.corosync import live as corosync_live
+from pcs.lib.corosync.live import (
+    QuorumStatusException,
+    QuorumStatusFacade,
+)
 from pcs.lib.node_communication import response_to_report_item
 
 
@@ -84,8 +89,8 @@ def on_complete(self):
 
 
 class GetQuorumStatus(AllSameDataMixin, OneByOneStrategyMixin, RunRemotelyBase):
-    _quorum_status = None
-    _has_failure = False
+    _quorum_status_facade: Optional[QuorumStatusFacade] = None
+    _has_failure: Optional[bool] = False
 
     def _get_request_data(self):
         return RequestData("remote/get_quorum_info")
@@ -103,11 +108,11 @@ def _process_response(self, response):
             # corosync is not running on the node, this is OK
             return self._get_next_list()
         try:
-            quorum_status = corosync_live.parse_quorum_status(response.data)
-            if not quorum_status.is_quorate:
+            quorum_status_facade = QuorumStatusFacade.from_string(response.data)
+            if not quorum_status_facade.is_quorate:
                 return self._get_next_list()
-            self._quorum_status = quorum_status
-        except corosync_live.QuorumStatusParsingException as e:
+            self._quorum_status_facade = quorum_status_facade
+        except QuorumStatusException as e:
             self._has_failure = True
             self._report(
                 ReportItem.warning(
@@ -120,5 +125,7 @@ def _process_response(self, response):
             return self._get_next_list()
         return []
 
-    def on_complete(self):
-        return self._has_failure, self._quorum_status
+    def on_complete(
+        self,
+    ) -> tuple[Optional[bool], Optional[QuorumStatusFacade]]:
+        return self._has_failure, self._quorum_status_facade

pcs/lib/corosync/live.py

@@ -100,6 +100,35 @@ def qdevice_votes(self) -> int:
         """
         return sum(qdevice.votes for qdevice in self.qdevice_list)
 
+
+class QuorumStatusFacade:
+    @classmethod
+    def from_string(cls, quorum_status_string: str) -> "QuorumStatusFacade":
+        return cls(_parse_quorum_status(quorum_status_string))
+
+    def __init__(self, quorum_status: QuorumStatus):
+        self._quorum_status = quorum_status
+
+    @property
+    def node_list(self) -> Sequence[QuorumStatusNode]:
+        return self._quorum_status.node_list
+
+    @property
+    def qdevice_list(self) -> Sequence[QuorumStatusNode]:
+        return self._quorum_status.qdevice_list
+
+    @property
+    def is_quorate(self) -> bool:
+        return self._quorum_status.is_quorate
+
+    @property
+    def votes_needed_for_quorum(self) -> int:
+        return self._quorum_status.votes_needed_for_quorum
+
+    @property
+    def qdevice_votes(self) -> int:
+        return self._quorum_status.qdevice_votes
+
     def _get_votes_excluding_nodes(self, node_names: Container[str]) -> int:
         """
         How many votes do remain if specified nodes are not counted in?
@@ -151,7 +180,7 @@ def stopping_local_node_cause_quorum_loss(self) -> bool:
         )
 
 
-def parse_quorum_status(quorum_status: str) -> QuorumStatus:
+def _parse_quorum_status(quorum_status: str) -> QuorumStatus:
     # pylint: disable=too-many-branches
     node_list: list[QuorumStatusNode] = []
     qdevice_list: list[QuorumStatusNode] = []