Swarm Bootstrap Nodes

homestar-runtime/src/event_handler.rs

@@ -10,7 +10,10 @@ use crate::{
 use anyhow::Result;
 use async_trait::async_trait;
 use fnv::FnvHashMap;
-use libp2p::{futures::StreamExt, kad::QueryId, request_response::RequestId, swarm::Swarm};
+use libp2p::{
+    core::ConnectedPoint, futures::StreamExt, kad::QueryId, request_response::RequestId,
+    swarm::Swarm, PeerId,
+};
 use std::{sync::Arc, time::Duration};
 use swarm_event::ResponseEvent;
 use tokio::{select, sync::mpsc};
@@ -48,6 +51,7 @@ pub(crate) struct EventHandler<DB: Database> {
     sender: Arc<mpsc::Sender<Event>>,
     receiver: mpsc::Receiver<Event>,
     query_senders: FnvHashMap<QueryId, (RequestResponseKey, P2PSender)>,
+    connected_peers: FnvHashMap<PeerId, ConnectedPoint>,
     request_response_senders: FnvHashMap<RequestId, (RequestResponseKey, P2PSender)>,
 }
 
@@ -71,6 +75,7 @@ where
             sender: Arc::new(sender),
             receiver,
             query_senders: FnvHashMap::default(),
+            connected_peers: FnvHashMap::default(),
             request_response_senders: FnvHashMap::default(),
         }
     }

homestar-runtime/src/event_handler/swarm_event.rs

@@ -376,6 +376,26 @@ async fn handle_swarm_event<THandlerErr: fmt::Debug + Send, DB: Database>(
             );
         }
         SwarmEvent::IncomingConnection { .. } => {}
+        SwarmEvent::ConnectionEstablished {
+            peer_id, endpoint, ..
+        } => {
+            let behavior = event_handler.swarm.behaviour_mut();
+            // only listener addresses should be added to the routing table.
+            // TODO: add identify here to discover more listen addresses and add those.
+            if endpoint.is_listener() {
+                // ignores if the peer failed or not to be added in the routing table.
+                behavior
+                    .kademlia
+                    .add_address(&peer_id, endpoint.get_remote_address().clone());
+            }
+
+            // add peer to connected peers list
+            event_handler.connected_peers.insert(peer_id, endpoint);
+        }
+        SwarmEvent::ConnectionClosed { peer_id, cause, .. } => {
+            info!("peer connection closed {peer_id}, cause: {cause:?}");
+            event_handler.connected_peers.remove_entry(&peer_id);
+        }
         _ => {}
     }
 }

homestar-runtime/src/network/swarm.rs

@@ -66,21 +66,20 @@ pub(crate) async fn new(settings: &settings::Node) -> Result<Swarm<ComposedBehav
 }
 
 fn startup<T: NetworkBehaviour>(swarm: &mut Swarm<T>, settings: &settings::Network) -> Result<()> {
-    // Dial bootstrap nodes specified in settings. Failure here shouldn't halt node startup.
+    // Listen-on given address
+    swarm.listen_on(settings.listen_address.to_string().parse()?)?;
+
+    // Dial trusted nodes specified in settings. Failure here shouldn't halt node startup.
     for trusted_addr in &settings.trusted_node_addresses {
         swarm
             .dial(trusted_addr.clone())
             .map(|_| {
-                info!(trusted_address=?trusted_addr, "Successfully dialed configured bootstrap node")
+                info!(trusted_address=?trusted_addr, "Successfully dialed configured trusted node")
             })
             // log dial failure and continue
-            .map_err(|e| warn!(err=?e, "Failed to dial bootstrap node"))
+            .map_err(|e| warn!(err=?e, "Failed to dial trusted node"))
             .ok();
     }
-
-    // Listen-on given address
-    swarm.listen_on(settings.listen_address.to_string().parse()?)?;
-
     Ok(())
 }