feat(iroh-net): persist known peer info

iroh-gossip/src/net.rs

@@ -1,18 +1,14 @@
 //! Networking for the `iroh-gossip` protocol
 
-use std::{
-    collections::HashMap, fmt, future::Future, net::SocketAddr, sync::Arc, task::Poll,
-    time::Instant,
-};
-
 use anyhow::{anyhow, Context};
 use bytes::{Bytes, BytesMut};
 use futures::{stream::Stream, FutureExt};
 use genawaiter::sync::{Co, Gen};
+use iroh_net::magic_endpoint::AddrInfo as IrohInfo;
 use iroh_net::{key::PublicKey, magic_endpoint::get_peer_id, MagicEndpoint};
 use rand::rngs::StdRng;
 use rand_core::SeedableRng;
-use serde::{Deserialize, Serialize};
+use std::{collections::HashMap, fmt, future::Future, sync::Arc, task::Poll, time::Instant};
 use tokio::{
     sync::{broadcast, mpsc, oneshot, watch},
     task::JoinHandle,
@@ -253,32 +249,6 @@ impl Future for JoinTopicFut {
     }
 }
 
-/// Addressing information for peers.
-///
-/// This struct is serialized and transmitted to peers in `Join` and `ForwardJoin` messages.
-/// It contains the information needed by `iroh-net` to connect to peers.
-///
-/// TODO: Replace with type from iroh-net
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-struct IrohInfo {
-    addrs: Vec<SocketAddr>,
-    derp_region: Option<u16>,
-}
-
-impl IrohInfo {
-    async fn from_endpoint(endpoint: &MagicEndpoint) -> anyhow::Result<Self> {
-        Ok(Self {
-            addrs: endpoint
-                .local_endpoints()
-                .await?
-                .iter()
-                .map(|ep| ep.addr)
-                .collect(),
-            derp_region: endpoint.my_derp().await,
-        })
-    }
-}
-
 /// Whether a connection is initiated by us (Dial) or by the remote peer (Accept)
 #[derive(Debug)]
 enum ConnOrigin {
@@ -370,7 +340,7 @@ impl Actor {
                     }
                 },
                 _ = self.on_endpoints_rx.changed() => {
-                    let info = IrohInfo::from_endpoint(&self.endpoint).await?;
+                    let info = self.endpoint.my_addr_info().await?;
                     let peer_data = postcard::to_stdvec(&info)?;
                     self.handle_in_event(InEvent::UpdatePeerData(peer_data.into()), Instant::now()).await?;
                 }
@@ -537,9 +507,13 @@ impl Actor {
                     Err(err) => warn!("Failed to decode PeerData from {peer}: {err}"),
                     Ok(info) => {
                         debug!(me = ?self.endpoint.peer_id(), peer = ?peer, "add known addrs: {info:?}");
+                        let IrohInfo {
+                            derp_region,
+                            endpoints,
+                        } = info;
                         if let Err(err) = self
                             .endpoint
-                            .add_known_addrs(peer, info.derp_region, &info.addrs)
+                            .add_known_addrs(peer, derp_region, &endpoints)
                             .await
                         {
                             debug!(me = ?self.endpoint.peer_id(), peer = ?peer, "add known failed: {err:?}");

iroh-net/src/magic_endpoint.rs

@@ -1,9 +1,10 @@
 //! An endpoint that leverages a [quinn::Endpoint] backed by a [magicsock::MagicSock].
 
-use std::{net::SocketAddr, sync::Arc, time::Duration};
+use std::{net::SocketAddr, path::PathBuf, sync::Arc, time::Duration};
 
 use anyhow::{anyhow, ensure, Context, Result};
 use quinn_proto::VarInt;
+use serde::{Deserialize, Serialize};
 use tracing::{debug, trace};
 
 use crate::{
@@ -17,18 +18,32 @@ use crate::{
 
 pub use super::magicsock::EndpointInfo as ConnectionInfo;
 
-/// Address information for a node.
-#[derive(Debug)]
-pub struct NodeAddr {
-    /// The node's public key.
-    pub node_id: PublicKey,
+/// Addressing information to connect to a peer.
+#[derive(Debug, Serialize, Deserialize, Eq)]
+pub struct AddrInfo {
     /// The node's home DERP region.
     pub derp_region: Option<u16>,
     /// Socket addresses where this node might be reached directly.
     pub endpoints: Vec<SocketAddr>,
 }
 
-/// Builder for [MagicEndpoint]
+impl PartialEq for AddrInfo {
+    fn eq(&self, other: &Self) -> bool {
+        if self.derp_region != other.derp_region {
+            return false;
+        }
+        if self.endpoints.len() != other.endpoints.len() {
+            return false;
+        }
+        let mut self_eps = self.endpoints.clone();
+        self_eps.sort();
+        let mut others_eps = self.endpoints.clone();
+        others_eps.sort();
+        self_eps == others_eps
+    }
+}
+
+/// Builder for [`MagicEndpoint`]
 #[derive(Debug)]
 pub struct MagicEndpointBuilder {
     secret_key: Option<SecretKey>,
@@ -38,6 +53,8 @@ pub struct MagicEndpointBuilder {
     concurrent_connections: Option<u32>,
     keylog: bool,
     callbacks: Callbacks,
+    /// Path for known peers. See [`MagicEndpointBuilder::peers_data_path`].
+    peers_path: Option<PathBuf>,
 }
 
 impl Default for MagicEndpointBuilder {
@@ -50,6 +67,7 @@ impl Default for MagicEndpointBuilder {
             concurrent_connections: Default::default(),
             keylog: Default::default(),
             callbacks: Default::default(),
+            peers_path: None,
         }
     }
 }
@@ -154,6 +172,14 @@ impl MagicEndpointBuilder {
         self
     }
 
+    /// Optionally set the path where peer info should be stored.
+    ///
+    /// If the file exists, it will be used to populate an initial set of peers.
+    pub fn peers_data_path(mut self, path: PathBuf) -> Self {
+        self.peers_path = Some(path);
+        self
+    }
+
     /// Bind the magic endpoint on the specified socket address.
     ///
     /// The *bind_port* is the port that should be bound locally.
@@ -178,15 +204,14 @@ impl MagicEndpointBuilder {
         if let Some(c) = self.concurrent_connections {
             server_config.concurrent_connections(c);
         }
-        MagicEndpoint::bind(
+        let msock_opts = magicsock::Options {
+            port: bind_port,
             secret_key,
-            bind_port,
-            Some(server_config),
-            self.derp_map.unwrap_or_default(),
-            Some(self.callbacks),
-            self.keylog,
-        )
-        .await
+            derp_map: self.derp_map.unwrap_or_default(),
+            callbacks: self.callbacks,
+            peers_path: self.peers_path,
+        };
+        MagicEndpoint::bind(Some(server_config), msock_opts, self.keylog).await
     }
 }
 
@@ -219,23 +244,15 @@ impl MagicEndpoint {
 
     /// Create a quinn endpoint backed by a magicsock.
     ///
-    /// This is for internal use, the public interface is the [MagicEndpointBuilder] obtained from
+    /// This is for internal use, the public interface is the [`MagicEndpointBuilder`] obtained from
     /// [Self::builder]. See the methods on the builder for documentation of the parameters.
     async fn bind(
-        secret_key: SecretKey,
-        bind_port: u16,
         server_config: Option<quinn::ServerConfig>,
-        derp_map: DerpMap,
-        callbacks: Option<Callbacks>,
+        msock_opts: magicsock::Options,
         keylog: bool,
     ) -> Result<Self> {
-        let msock = magicsock::MagicSock::new(magicsock::Options {
-            port: bind_port,
-            derp_map,
-            secret_key: secret_key.clone(),
-            callbacks: callbacks.unwrap_or_default(),
-        })
-        .await?;
+        let secret_key = msock_opts.secret_key.clone();
+        let msock = magicsock::MagicSock::new(msock_opts).await?;
         trace!("created magicsock");
 
         let endpoint = quinn::Endpoint::new_with_abstract_socket(
@@ -391,16 +408,15 @@ impl MagicEndpoint {
     /// If no UDP addresses are added, and the given `derp_region` cannot be dialed, it will error.
     pub async fn add_known_addrs(
         &self,
-        node_id: PublicKey,
+        peer: PublicKey,
         derp_region: Option<u16>,
         endpoints: &[SocketAddr],
     ) -> Result<()> {
-        let addr = NodeAddr {
-            node_id,
+        let info = AddrInfo {
             derp_region,
             endpoints: endpoints.to_vec(),
         };
-        self.msock.add_known_addr(addr).await?;
+        self.msock.add_known_addr(peer, info).await?;
         Ok(())
     }
 
@@ -422,6 +438,21 @@ impl MagicEndpoint {
         Ok(())
     }
 
+    /// Get addressing information of this [`MagicEndpoint`].
+    pub async fn my_addr_info(&self) -> Result<AddrInfo> {
+        let endpoints = self
+            .local_endpoints()
+            .await?
+            .iter()
+            .map(|ep| ep.addr)
+            .collect();
+        let derp_region = self.my_derp().await;
+        Ok(AddrInfo {
+            derp_region,
+            endpoints,
+        })
+    }
+
     #[cfg(test)]
     pub(crate) fn magic_sock(&self) -> &MagicSock {
         &self.msock