fix(p2p): redial beacon bootnodes after disconnect

Author: perfogic

crates/networking/p2p/src/network/beacon/mod.rs

@@ -104,6 +104,7 @@ pub struct Network {
     request_id: u64,
     network_state: Arc<NetworkState>,
     peers_to_ping: HashSetDelay<PeerId>,
+    bootnodes: Vec<Enr>,
 }
 
 impl Network {
@@ -221,6 +222,7 @@ impl Network {
             request_id: 0,
             network_state,
             peers_to_ping: HashSetDelay::new(PING_INTERVAL_DURATION),
+            bootnodes: config.discv5_config.bootnodes.clone(),
         };
 
         network.start_network_worker(config).await?;
@@ -304,9 +306,19 @@ impl Network {
         manager_sender: UnboundedSender<ReamNetworkEvent>,
         mut p2p_receiver: UnboundedReceiver<P2PMessage>,
     ) {
+        let mut bootnode_redial_interval = interval(Duration::from_secs(20));
         let mut status_interval = interval(Duration::from_secs(30));
         loop {
             tokio::select! {
+                _ = bootnode_redial_interval.tick() => {
+                    let bootnodes = self
+                        .bootnodes
+                        .iter()
+                        .cloned()
+                        .map(|bootnode| (bootnode, None))
+                        .collect();
+                    self.handle_discovered_peers(bootnodes);
+                }
                 Some(event) = self.swarm.next() => {
                     if let Some(event) = self.parse_swarm_event(event).await && let Err(err) = manager_sender.send(event) {
                         warn!("Failed to send event: {err:?}");
@@ -533,45 +545,69 @@ impl Network {
     fn handle_discovered_peers(&mut self, peers: HashMap<Enr, Option<Instant>>) {
         trace!("Discovered peers: {peers:?}");
         for (enr, _) in peers {
+            let Some(peer_id) = peer_id_from_enr(&enr) else {
+                trace!("Skipping peer with no peer id in ENR: {enr:?}");
+                continue;
+            };
+            if peer_id == self.peer_id {
+                trace!("Skipping self peer: {peer_id:?}");
+                continue;
+            }
+
+            let peer_state = self
+                .network_state
+                .peer_table
+                .read()
+                .get(&peer_id)
+                .map(|peer| peer.state);
+            if matches!(
+                peer_state,
+                Some(ConnectionState::Connected | ConnectionState::Connecting)
+            ) {
+                trace!("Peer {peer_id:?} is already {peer_state:?}, skipping dial");
+                continue;
+            }
+
             let mut multiaddrs: Vec<Multiaddr> = Vec::new();
             if let Some(ip) = enr.ip4()
                 && let Some(tcp) = enr.tcp4()
             {
                 let mut multiaddr: Multiaddr = ip.into();
                 multiaddr.push(Protocol::Tcp(tcp));
+                multiaddr.push(Protocol::P2p(peer_id));
                 multiaddrs.push(multiaddr);
             }
             if let Some(ip6) = enr.ip6()
                 && let Some(tcp6) = enr.tcp6()
             {
                 let mut multiaddr: Multiaddr = ip6.into();
                 multiaddr.push(Protocol::Tcp(tcp6));
+                multiaddr.push(Protocol::P2p(peer_id));
                 multiaddrs.push(multiaddr);
             }
 
-            let mut successfully_dialed = false;
+            let mut dialed_address = None;
             for multiaddr in multiaddrs {
+                let address = multiaddr.clone();
                 if let Err(err) = self.swarm.dial(multiaddr) {
                     warn!("Failed to dial peer: {err:?}");
                 } else {
-                    successfully_dialed = true;
+                    dialed_address.get_or_insert(address);
                 }
             }
 
-            if !successfully_dialed {
+            let Some(address) = dialed_address else {
                 trace!("Failed to dial any multiaddr for peer: {:?}", enr);
                 continue;
-            }
+            };
 
-            if let Some(peer_id) = peer_id_from_enr(&enr) {
-                self.network_state.upsert_peer(
-                    peer_id,
-                    None,
-                    ConnectionState::Connecting,
-                    Direction::Outbound,
-                    Some(enr.clone()),
-                );
-            }
+            self.network_state.upsert_peer(
+                peer_id,
+                Some(address),
+                ConnectionState::Connecting,
+                Direction::Outbound,
+                Some(enr.clone()),
+            );
         }
     }