add type hints to pcs.lib.corosync

Author: tomjelinek

mypy.ini

@@ -178,6 +178,14 @@ disallow_untyped_defs = True
 [mypy-pcs.lib.commands.tag]
 disallow_untyped_defs = True
 
+[mypy-pcs.lib.corosync.*]
+disallow_untyped_defs = True
+disallow_untyped_calls = True
+
+[mypy-pcs.lib.corosync.qdevice_net]
+disallow_untyped_defs = True
+disallow_untyped_calls = False
+
 [mypy-pcs.lib.dr.*]
 disallow_untyped_defs = True
 disallow_untyped_calls = True
@@ -197,6 +205,10 @@ disallow_untyped_calls = True
 [mypy-pcs.lib.services]
 disallow_untyped_defs = True
 
+[mypy-pcs.lib.tools]
+disallow_untyped_defs = True
+disallow_untyped_calls = True
+
 [mypy-pcs.lib.validate]
 disallow_untyped_defs = True
 disallow_untyped_calls = True

pcs/cli/reports/messages.py

@@ -189,8 +189,7 @@ class NodeUsedAsTieBreaker(CliReportMessageCustom):
     @property
     def message(self) -> str:
         return (
-            f"Node '{self._obj.node}' with id '{self._obj.node_id}' is used as "
-            "a tie breaker for a qdevice, run 'pcs quorum device update model "
+            self._obj.message + ", run 'pcs quorum device update model "
             "tie_breaker=<node id>' to change it"
         )
 

pcs/cluster.py

@@ -495,7 +495,7 @@ def stop_cluster_nodes(nodes):
                 error_list.append(node + ": " + data)
                 continue
             try:
-                quorum_status = corosync_live.QuorumStatus.from_string(data)
+                quorum_status = corosync_live.parse_quorum_status(data)
                 if not quorum_status.is_quorate:
                     # Get quorum status from a quorate node, non-quorate nodes
                     # may provide inaccurate info. If no node is quorate, there
@@ -688,7 +688,7 @@ 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.QuorumStatus.from_string(
+            if corosync_live.parse_quorum_status(
                 output
             ).stopping_local_node_cause_quorum_loss():
                 utils.err(

pcs/common/corosync_conf.py

@@ -1,26 +1,29 @@
 from dataclasses import dataclass
 from typing import (
-    List,
     Mapping,
     Optional,
+    Sequence,
 )
 
 from pcs.common.interface.dto import DataTransferObject
-from pcs.common.types import CorosyncTransportType
+from pcs.common.types import (
+    CorosyncNodeAddressType,
+    CorosyncTransportType,
+)
 
 
 @dataclass(frozen=True)
 class CorosyncNodeAddressDto(DataTransferObject):
     addr: str
     link: str
-    type: str  # TODO: create enum of addr types in pcs.lib.corosync.node
+    type: CorosyncNodeAddressType
 
 
 @dataclass(frozen=True)
 class CorosyncNodeDto(DataTransferObject):
     name: str
     nodeid: str
-    addrs: List[CorosyncNodeAddressDto]
+    addrs: Sequence[CorosyncNodeAddressDto]
 
 
 @dataclass(frozen=True)
@@ -41,7 +44,7 @@ class CorosyncConfDto(DataTransferObject):
     transport_options: Mapping[str, str]
     compression_options: Mapping[str, str]
     crypto_options: Mapping[str, str]
-    nodes: List[CorosyncNodeDto]
+    nodes: Sequence[CorosyncNodeDto]
     links_options: Mapping[str, Mapping[str, str]]
     quorum_options: Mapping[str, str]
     quorum_device: Optional[CorosyncQuorumDeviceSettingsDto]

pcs/common/reports/__init__.py

@@ -11,6 +11,7 @@
     ReportItem,
     ReportItemContext,
     ReportItemList,
+    ReportItemMessage,
     ReportItemSeverity,
     get_severity,
 )

pcs/common/reports/codes.py

@@ -170,6 +170,7 @@
     "COROSYNC_CONFIG_DISTRIBUTION_NODE_ERROR"
 )
 COROSYNC_CONFIG_DISTRIBUTION_STARTED = M("COROSYNC_CONFIG_DISTRIBUTION_STARTED")
+COROSYNC_CONFIG_MISSING_IDS_OF_NODES = M("COROSYNC_CONFIG_MISSING_IDS_OF_NODES")
 COROSYNC_CONFIG_MISSING_NAMES_OF_NODES = M(
     "COROSYNC_CONFIG_MISSING_NAMES_OF_NODES"
 )

pcs/common/reports/messages.py

@@ -1723,7 +1723,26 @@ def message(self) -> str:
         note = (
             "unable to continue" if self.fatal else "those nodes were omitted"
         )
-        return f"Some nodes are missing names in corosync.conf, {note}"
+        return (
+            f"Some nodes are missing names in corosync.conf, {note}. "
+            "Edit corosync.conf and make sure all nodes have their name set."
+        )
+
+
+@dataclass(frozen=True)
+class CorosyncConfigMissingIdsOfNodes(ReportItemMessage):
+    """
+    Some nodes in corosync.conf do not have their id set
+    """
+
+    _code = codes.COROSYNC_CONFIG_MISSING_IDS_OF_NODES
+
+    @property
+    def message(self) -> str:
+        return (
+            "Some nodes are missing IDs in corosync.conf. "
+            "Edit corosync.conf and make sure all nodes have their nodeid set."
+        )
 
 
 @dataclass(frozen=True)
@@ -1799,7 +1818,7 @@ class CorosyncBadNodeAddressesCount(ReportItemMessage):
     actual_count: int
     min_count: int
     max_count: int
-    node_name: str = ""
+    node_name: Optional[str] = None
     node_index: Optional[int] = None
     _code = codes.COROSYNC_BAD_NODE_ADDRESSES_COUNT
 
@@ -1865,7 +1884,7 @@ class CorosyncAddressIpVersionWrongForLink(ReportItemMessage):
 
     address: str
     expected_address_type: str
-    link_number: Optional[int] = None
+    link_number: Optional[Union[int, str]] = None
     _code = codes.COROSYNC_ADDRESS_IP_VERSION_WRONG_FOR_LINK
 
     @property
@@ -2193,7 +2212,7 @@ class CorosyncLinkDoesNotExistCannotUpdate(ReportItemMessage):
     existing_link_list -- linknumbers of existing links
     """
 
-    link_number: int
+    link_number: Union[int, str]
     existing_link_list: List[str]
     _code = codes.COROSYNC_LINK_DOES_NOT_EXIST_CANNOT_UPDATE
 
@@ -5463,15 +5482,15 @@ class NodeUsedAsTieBreaker(ReportItemMessage):
     node_id -- node id
     """
 
-    node: str
-    node_id: int
+    node: Optional[str]
+    node_id: Union[None, str, int]
     _code = codes.NODE_USED_AS_TIE_BREAKER
 
     @property
     def message(self) -> str:
         return (
             f"Node '{self.node}' with id '{self.node_id}' is used as a tie "
-            "breaker for a qdevice"
+            "breaker for a qdevice and therefore cannot be removed"
         )
 
 

pcs/common/types.py

@@ -67,3 +67,10 @@ def from_str(cls, transport: str) -> "CorosyncTransportType":
             return cls(transport.upper())
         except ValueError:
             raise UnknownCorosyncTransportTypeException(transport) from None
+
+
+class CorosyncNodeAddressType(AutoNameEnum):
+    IPV4 = "IPv4"
+    IPV6 = "IPv6"
+    FQDN = "FQDN"
+    UNRESOLVABLE = "unresolvable"

pcs/lib/commands/cluster.py

@@ -800,13 +800,12 @@ def get_corosync_conf_struct(env: LibraryEnvironment) -> CorosyncConfDto:
     quorum_device_dto: Optional[CorosyncQuorumDeviceSettingsDto] = None
     if corosync_conf.has_quorum_device():
         (
-            qd_model,
             qd_model_options,
             qd_generic_options,
             qd_heuristics_options,
         ) = corosync_conf.get_quorum_device_settings()
         quorum_device_dto = CorosyncQuorumDeviceSettingsDto(
-            model=qd_model,
+            model=corosync_conf.get_quorum_device_model(),
             model_options=qd_model_options,
             generic_options=qd_generic_options,
             heuristics_options=qd_heuristics_options,
@@ -911,26 +910,28 @@ def add_nodes(
         skip_non_existing=skip_offline_nodes,
     )
     report_processor.report_list(target_report_list)
-    # get a target for qnetd if needed
-    (
-        qdevice_model,
-        qdevice_model_options,
-        _,
-        _,
-    ) = corosync_conf.get_quorum_device_settings()
-    if qdevice_model == "net":
-        try:
-            qnetd_target = target_factory.get_target(
-                qdevice_model_options["host"]
-            )
-        except HostNotFound:
-            report_processor.report(
-                ReportItem.error(
-                    reports.messages.HostNotFound(
-                        [qdevice_model_options["host"]]
+
+    if corosync_conf.has_quorum_device():
+        # get a target for qnetd if needed
+        qdevice_model = corosync_conf.get_quorum_device_model()
+        if qdevice_model == "net":
+            (
+                qdevice_model_options,
+                _,
+                _,
+            ) = corosync_conf.get_quorum_device_settings()
+            try:
+                qnetd_target = target_factory.get_target(
+                    qdevice_model_options["host"]
+                )
+            except HostNotFound:
+                report_processor.report(
+                    ReportItem.error(
+                        reports.messages.HostNotFound(
+                            [qdevice_model_options["host"]]
+                        )
                     )
                 )
-            )
 
     # Get targets for new nodes and report unknown (== not-authorized) nodes.
     # If a node doesn't contain the 'name' key, validation of inputs reports it.
@@ -1156,19 +1157,21 @@ def add_nodes(
     run_and_raise(env.get_node_communicator(), com_cmd)
 
     # qdevice setup
-    if qdevice_model == "net":
-        qdevice_net.set_up_client_certificates(
-            env.cmd_runner(),
-            env.report_processor,
-            env.communicator_factory,
-            qnetd_target,
-            corosync_conf.get_cluster_name(),
-            new_nodes_target_list,
-            # we don't want to allow skipping offline nodes which are being
-            # added, otherwise qdevice will not work properly
-            skip_offline_nodes=False,
-            allow_skip_offline=False,
-        )
+    if corosync_conf.has_quorum_device():
+        qdevice_model = corosync_conf.get_quorum_device_model()
+        if qdevice_model == "net":
+            qdevice_net.set_up_client_certificates(
+                env.cmd_runner(),
+                env.report_processor,
+                env.communicator_factory,
+                qnetd_target,
+                corosync_conf.get_cluster_name(),
+                new_nodes_target_list,
+                # we don't want to allow skipping offline nodes which are being
+                # added, otherwise qdevice will not work properly
+                skip_offline_nodes=False,
+                allow_skip_offline=False,
+            )
 
     # sbd setup
     if is_sbd_enabled:
@@ -1744,7 +1747,16 @@ def remove_nodes(
         config_validators.remove_nodes(
             node_list,
             corosync_conf.get_nodes(),
-            corosync_conf.get_quorum_device_settings(),
+            (
+                corosync_conf.get_quorum_device_model()
+                if corosync_conf.has_quorum_device()
+                else None
+            ),
+            (
+                corosync_conf.get_quorum_device_settings()
+                if corosync_conf.has_quorum_device()
+                else ({}, {}, {})
+            ),
         )
     )
     if report_processor.has_errors:

pcs/lib/commands/quorum.py

@@ -18,7 +18,7 @@
 from pcs.lib.node import get_existing_nodes_names
 
 
-def get_config(lib_env):
+def get_config(lib_env: LibraryEnvironment):
     """
     Extract and return quorum configuration from corosync.conf
     lib_env LibraryEnvironment
@@ -27,13 +27,12 @@ def get_config(lib_env):
     device = None
     if cfg.has_quorum_device():
         (
-            model,
             model_options,
             generic_options,
             heuristics_options,
         ) = cfg.get_quorum_device_settings()
         device = {
-            "model": model,
+            "model": cfg.get_quorum_device_model(),
             "model_options": model_options,
             "generic_options": generic_options,
             "heuristics_options": heuristics_options,
@@ -171,7 +170,7 @@ def add_device(
             model_options,
             generic_options,
             heuristics_options,
-            [node.nodeid for node in cfg.get_nodes()],
+            [node.nodeid for node in cfg.get_nodes() if node.nodeid],
             force_model=force_model,
             force_options=force_options,
         )
@@ -289,7 +288,7 @@ def update_device(
             model_options,
             generic_options,
             heuristics_options,
-            [node.nodeid for node in cfg.get_nodes()],
+            [node.nodeid for node in cfg.get_nodes() if node.nodeid],
             force_options=force_options,
         )
     ).has_errors:

pcs/lib/communication/cluster.py

@@ -103,9 +103,7 @@ 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.QuorumStatus.from_string(
-                response.data
-            )
+            quorum_status = corosync_live.parse_quorum_status(response.data)
             if not quorum_status.is_quorate:
                 return self._get_next_list()
             self._quorum_status = quorum_status