ci debug

Author: almogdepaz

chia/_tests/farmer_harvester/test_third_party_harvesters.py

@@ -92,9 +92,9 @@ async def test_harvester_receive_source_signing_data(
         UnresolvedPeerInfo(str(full_node_service_1.self_hostname), full_node_service_1._server.get_port())
     )
 
-    await wait_until_node_type_connected(farmer.server, NodeType.FULL_NODE)
-    await wait_until_node_type_connected(farmer.server, NodeType.HARVESTER)  # Should already be connected
-    await wait_until_node_type_connected(full_node_1.server, NodeType.FULL_NODE)
+    await time_out_assert(60, node_type_connected, True, farmer.server, NodeType.FULL_NODE)
+    await time_out_assert(60, node_type_connected, True, farmer.server, NodeType.HARVESTER)
+    await time_out_assert(60, node_type_connected, True, full_node_1.server, NodeType.FULL_NODE)
 
     # Prepare test data
     blocks: list[FullBlock]
@@ -429,12 +429,11 @@ def log_has_new_text() -> bool:
     return False
 
 
-async def wait_until_node_type_connected(server: ChiaServer, node_type: NodeType) -> WSChiaConnection:
-    while True:
-        for peer in server.all_connections.values():
-            if peer.connection_type == node_type.value:
-                return peer
-        await asyncio.sleep(1)
+def node_type_connected(server: ChiaServer, node_type: NodeType) -> bool:
+    for peer in server.all_connections.values():
+        if peer.connection_type == node_type.value:
+            return True
+    return False
 
 
 def decode_sp(

chia/server/server.py

@@ -425,6 +425,7 @@ async def start_client(
         """
         if self.is_duplicate_or_self_connection(target_node):
             self.log.warning(f"cannot connect to {target_node.host}, duplicate/self connection")
+            print(f"cannot connect to {target_node.host}, duplicate/self connection")
             return False
 
         if target_node.host in self.banned_peers and time.time() < self.banned_peers[target_node.host]:
@@ -452,15 +453,19 @@ async def start_client(
                 )
             except ServerDisconnectedError:
                 self.log.debug(f"Server disconnected error connecting to {url}. Perhaps we are banned by the peer.")
+                print(f"Server disconnected error connecting to {url}. Perhaps we are banned by the peer.")
                 return False
             except ClientResponseError as e:
                 self.log.warning(f"Connection failed to {url}. Error: {e}")
+                print(f"Connection failed to {url}. Error: {e}")
                 return False
             except asyncio.TimeoutError:
                 self.log.debug(f"Timeout error connecting to {url}")
+                print(f"Timeout error connecting to {url}")
                 return False
             if ws is None:
                 self.log.warning(f"Connection failed to {url}. ws was None")
+                print(f"Connection failed to {url}. ws was None")
                 return False
 
             ssl_object = ws.get_extra_info("ssl_object")

chia/server/start_service.py

@@ -149,28 +149,35 @@ def __init__(
     async def _connect_peers_task_handler(self) -> None:
         resolved_peers: dict[UnresolvedPeerInfo, PeerInfo] = {}
         prefer_ipv6 = self.config.get("prefer_ipv6", False)
+        print(f"connect peers task started {self._connect_peers}")
         while True:
             for unresolved in self._connect_peers:
+                print(f"connect peers task started {self._connect_peers}")
+                print(f"try peer {unresolved}")
                 resolved = resolved_peers.get(unresolved)
                 if resolved is None:
                     try:
                         resolved = PeerInfo(await resolve(unresolved.host, prefer_ipv6=prefer_ipv6), unresolved.port)
                     except Exception as e:
+                        print(f"Failed to resolve {unresolved.host}: {e}")
                         self._log.warning(f"Failed to resolve {unresolved.host}: {e}")
                         continue
                     self._log.info(f"Add resolved {resolved}")
                     resolved_peers[unresolved] = resolved
 
                 if any(connection.peer_info == resolved for connection in self._server.all_connections.values()):
+                    print(f"step 1. {resolved} {self._server.all_connections.values()}")
                     continue
                 if any(
                     connection.peer_info.host == resolved.host and connection.peer_server_port == resolved.port
                     for connection in self._server.all_connections.values()
                 ):
+                    print("step 2")
                     continue
-
+                print(f"connect to {resolved}")
                 if not await self._server.start_client(resolved, None):
                     self._log.info(f"Failed to connect to {resolved}")
+                    print(f"Failed to connect to {resolved}")
                     # Re-resolve to make sure the IP didn't change, this helps for example to keep dyndns hostnames
                     # up to date.
                     try:
@@ -179,9 +186,11 @@ async def _connect_peers_task_handler(self) -> None:
                         )
                     except Exception as e:
                         self._log.warning(f"Failed to resolve after connection failure {unresolved.host}: {e}")
+                        print(f"Failed to resolve after connection failure {unresolved.host}: {e}")
                         continue
                     if resolved_new != resolved:
                         self._log.info(f"Host {unresolved.host} changed from {resolved} to {resolved_new}")
+                        print(f"Host {unresolved.host} changed from {resolved} to {resolved_new}")
                         resolved_peers[unresolved] = resolved_new
             await asyncio.sleep(self.reconnect_retry_seconds)