If a node is offline connect() no longers opens a channel with it

Fix raiden-network#5583

raiden/connection_manager.py

@@ -21,6 +21,7 @@
     RaidenUnrecoverableError,
     UnexpectedChannelState,
 )
+from raiden.network.transport.matrix.utils import AddressReachability
 from raiden.transfer import views
 from raiden.transfer.state import NettingChannelState
 from raiden.utils import typing
@@ -309,8 +310,15 @@ def _find_new_partners(self) -> List[Address]:
         )
 
         available_addresses = list(participants_addresses - known)
-        shuffle(available_addresses)
-        new_partners = available_addresses
+        available_and_online_addresses = available_addresses
+        available_and_online_addresses = [
+            address
+            for address in available_addresses
+            if self.raiden.transport.force_check_address_reachability(address)
+            == AddressReachability.REACHABLE
+        ]
+        shuffle(available_and_online_addresses)
+        new_partners = available_and_online_addresses
 
         log.debug(
             "Found partners",

raiden/network/transport/matrix/transport.py

@@ -67,6 +67,7 @@
     NamedTuple,
     NewType,
     Optional,
+    Set,
     Tuple,
     cast,
 )
@@ -537,24 +538,30 @@ def whitelist(self, address: Address) -> None:
         # the node that has to create the room.
         self._maybe_create_room_for_address(address)
 
+    def get_user_ids_for_address(self, address: Address) -> Tuple[Set[str], List[User]]:
+        address_hex = to_normalized_address(address)
+        candidates = self._client.search_user_directory(address_hex)
+        user_ids = {
+            user.user_id for user in candidates if validate_userid_signature(user) == address
+        }
+        return user_ids, candidates
+
+    def force_check_address_reachability(self, address: Address) -> AddressReachability:
+        """Force checks an address's reachability bypassing the whitelisting"""
+        user_ids, _ = self.get_user_ids_for_address(address)
+        self._address_mgr.track_address_presence(address, user_ids)
+        return self._address_mgr.get_address_reachability(address)
+
     def start_health_check(self, node_address: Address) -> None:
         """Start healthcheck (status monitoring) for a peer
 
         It also whitelists the address to answer invites and listen for messages
         """
         self.whitelist(node_address)
         with self._health_lock:
-            node_address_hex = to_normalized_address(node_address)
             self.log.debug("Healthcheck", peer_address=to_checksum_address(node_address))
-
-            candidates = self._client.search_user_directory(node_address_hex)
+            user_ids, candidates = self.get_user_ids_for_address(node_address)
             self._displayname_cache.warm_users(candidates)
-
-            user_ids = {
-                user.user_id
-                for user in candidates
-                if validate_userid_signature(user) == node_address
-            }
             # Ensure network state is updated in case we already know about the user presences
             # representing the target node
             self._address_mgr.track_address_presence(node_address, user_ids)