refactor(multipath): rename EndpointMap/EndpointState to RemoteMap/RemoteState (#3673)

## Description

Renames:
* renamed `endpoint_map` -> `remote_map`, `EndpointMap` -> `RemoteMap`,
`endpoint_state` -> `remote_state`, `EndpointStateActor` ->
`RemoteStateActor`

Moved:
* moved `path_state` module under `remote_state` (prev
`endpoint_state`), its items are used only there and nowhere else

## Breaking Changes

<!-- Optional, if there are any breaking changes document them,
including how to migrate older code. -->

## Notes & open questions

<!-- Any notes, remarks or open questions you have to make about the PR.
-->

## Change checklist
<!-- Remove any that are not relevant. -->
- [ ] Self-review.
- [ ] Documentation updates following the [style
guide](https://rust-lang.github.io/rfcs/1574-more-api-documentation-conventions.html#appendix-a-full-conventions-text),
if relevant.
- [ ] Tests if relevant.
- [ ] All breaking changes documented.
- [ ] List all breaking changes in the above "Breaking Changes" section.
- [ ] Open an issue or PR on any number0 repos that are affected by this
breaking change. Give guidance on how the updates should be handled or
do the actual updates themselves. The major ones are:
    - [ ] [`quic-rpc`](https://github.com/n0-computer/quic-rpc)
    - [ ] [`iroh-gossip`](https://github.com/n0-computer/iroh-gossip)
    - [ ] [`iroh-blobs`](https://github.com/n0-computer/iroh-blobs)
    - [ ] [`dumbpipe`](https://github.com/n0-computer/dumbpipe)
    - [ ] [`sendme`](https://github.com/n0-computer/sendme)

---------

Co-authored-by: Floris Bruynooghe <flub@n0.computer>

Author: Frando

iroh/src/discovery.rs

@@ -124,7 +124,7 @@ use tokio::sync::oneshot;
 use tracing::{Instrument, debug, error_span, warn};
 
 pub use crate::endpoint_info::{EndpointData, EndpointInfo, ParseError, UserData};
-use crate::{Endpoint, magicsock::endpoint_map::Source};
+use crate::{Endpoint, magicsock::remote_map::Source};
 
 #[cfg(not(wasm_browser))]
 pub mod dns;

iroh/src/endpoint.rs

@@ -26,7 +26,7 @@ use url::Url;
 
 pub use super::magicsock::{
     AddEndpointAddrError, DirectAddr, DirectAddrType, PathInfo,
-    endpoint_map::{PathInfoList, Source},
+    remote_map::{PathInfoList, Source},
 };
 #[cfg(wasm_browser)]
 use crate::discovery::pkarr::PkarrResolver;

iroh/src/endpoint/connection.rs

@@ -42,8 +42,8 @@ use crate::{
     Endpoint,
     discovery::DiscoveryTask,
     magicsock::{
-        EndpointStateActorStoppedError,
-        endpoint_map::{PathInfoList, PathsWatcher},
+        RemoteStateActorStoppedError,
+        remote_map::{PathInfoList, PathsWatcher},
     },
 };
 
@@ -208,9 +208,9 @@ pub enum AuthenticationError {
     NoAlpn {},
 }
 
-impl From<EndpointStateActorStoppedError> for ConnectingError {
+impl From<RemoteStateActorStoppedError> for ConnectingError {
     #[track_caller]
-    fn from(_value: EndpointStateActorStoppedError) -> Self {
+    fn from(_value: RemoteStateActorStoppedError) -> Self {
         e!(Self::InternalConsistencyError)
     }
 }
@@ -221,15 +221,15 @@ impl From<EndpointStateActorStoppedError> for ConnectingError {
 /// or if the remote did not set an ALPN.
 ///
 /// Otherwise returns a future that completes once the connection has been registered with the
-/// magicsock. This future can return an [`EndpointStateActorStoppedError`], which will only be
+/// magicsock. This future can return an [`RemoteStateActorStoppedError`], which will only be
 /// emitted if the endpoint is closing.
 ///
 /// The returned future is `'static`, so it can be stored without being lifetime-bound on `&ep`.
 fn conn_from_quinn_conn(
     conn: quinn::Connection,
     ep: &Endpoint,
 ) -> Result<
-    impl Future<Output = Result<Connection, EndpointStateActorStoppedError>> + Send + 'static,
+    impl Future<Output = Result<Connection, RemoteStateActorStoppedError>> + Send + 'static,
     ConnectingError,
 > {
     let (remote_id, alpn) = match static_info_from_conn(&conn) {
@@ -328,7 +328,7 @@ pub struct Connecting {
     _discovery_drop_guard: Option<DiscoveryTask>,
 }
 
-type RegisterWithMagicsockFut = BoxFuture<Result<Connection, EndpointStateActorStoppedError>>;
+type RegisterWithMagicsockFut = BoxFuture<Result<Connection, RemoteStateActorStoppedError>>;
 
 /// In-progress connection attempt future
 #[derive(derive_more::Debug)]
@@ -370,7 +370,7 @@ pub enum ConnectingError {
     },
     #[error("Failure finalizing the handshake")]
     HandshakeFailure { source: AuthenticationError },
-    #[error("internal consistency error: EndpointStateActor stopped")]
+    #[error("internal consistency error: RemoteStateActor stopped")]
     InternalConsistencyError,
 }
 

iroh/src/magicsock.rs

@@ -47,8 +47,8 @@ use transports::{LocalAddrsWatch, MagicTransport, TransportConfig};
 use url::Url;
 
 use self::{
-    endpoint_map::{EndpointMap, EndpointStateMessage},
     metrics::Metrics as MagicsockMetrics,
+    remote_map::{RemoteMap, RemoteStateMessage},
     transports::{RelayActorConfig, Transports, TransportsSender},
 };
 #[cfg(not(wasm_browser))]
@@ -60,22 +60,22 @@ use crate::{
     disco::{self, SendAddr},
     discovery::{ConcurrentDiscovery, Discovery, EndpointData, UserData},
     key::{DecryptionError, SharedSecret, public_ed_box, secret_ed_box},
-    magicsock::endpoint_map::PathsWatcher,
+    magicsock::remote_map::PathsWatcher,
     metrics::EndpointMetrics,
     net_report::{self, IfStateDetails, Report},
 };
 
 mod metrics;
 
-pub(crate) mod endpoint_map;
 pub(crate) mod mapped_addrs;
+pub(crate) mod remote_map;
 pub(crate) mod transports;
 
-pub use self::{endpoint_map::PathInfo, metrics::Metrics};
 use self::{
     mapped_addrs::{EndpointIdMappedAddr, MappedAddr},
     transports::Addr,
 };
+pub use self::{metrics::Metrics, remote_map::PathInfo};
 
 // TODO: Use this
 // /// How long we consider a QAD-derived endpoint valid for. UDP NAT mappings typically
@@ -102,7 +102,7 @@ pub(crate) const MAX_MULTIPATH_PATHS: u32 = 16;
 /// Error returned when the endpoint state actor stopped while waiting for a reply.
 #[stack_error(derive)]
 #[error("endpoint state actor stopped")]
-pub(crate) struct EndpointStateActorStoppedError;
+pub(crate) struct RemoteStateActorStoppedError;
 
 /// Contains options for `MagicSock::listen`.
 #[derive(derive_more::Debug)]
@@ -183,7 +183,7 @@ pub(crate) struct MagicSock {
     /// If the last net_report report, reports IPv6 to be available.
     ipv6_reported: Arc<AtomicBool>,
     /// Tracks the networkmap endpoint entity for each endpoint discovery key.
-    pub(crate) endpoint_map: EndpointMap,
+    pub(crate) remote_map: RemoteMap,
 
     /// Local addresses
     local_addrs_watch: LocalAddrsWatch,
@@ -252,7 +252,7 @@ impl MagicSock {
         self.local_addrs_watch.clone().get()
     }
 
-    /// Registers the connection in the `EndpointStateActor`.
+    /// Registers the connection in the `RemoteStateActor`.
     ///
     /// The actor is responsible for holepunching and opening additional paths to this
     /// connection.
@@ -264,16 +264,16 @@ impl MagicSock {
         &self,
         remote: EndpointId,
         conn: WeakConnectionHandle,
-    ) -> impl Future<Output = Result<PathsWatcher, EndpointStateActorStoppedError>> + Send + 'static
+    ) -> impl Future<Output = Result<PathsWatcher, RemoteStateActorStoppedError>> + Send + 'static
     {
         let (tx, rx) = oneshot::channel();
-        let sender = self.endpoint_map.endpoint_state_actor(remote);
+        let sender = self.remote_map.remote_state_actor(remote);
         async move {
             sender
-                .send(EndpointStateMessage::AddConnection(conn, tx))
+                .send(RemoteStateMessage::AddConnection(conn, tx))
                 .await
-                .map_err(|_| EndpointStateActorStoppedError)?;
-            rx.await.map_err(|_| EndpointStateActorStoppedError)
+                .map_err(|_| RemoteStateActorStoppedError)?;
+            rx.await.map_err(|_| RemoteStateActorStoppedError)
         }
     }
 
@@ -290,9 +290,9 @@ impl MagicSock {
 
     /// Returns `true` if we have at least one candidate address where we can send packets to.
     pub(crate) async fn has_send_address(&self, eid: EndpointId) -> bool {
-        let actor = self.endpoint_map.endpoint_state_actor(eid);
+        let actor = self.remote_map.remote_state_actor(eid);
         let (tx, rx) = oneshot::channel();
-        if actor.send(EndpointStateMessage::CanSend(tx)).await.is_err() {
+        if actor.send(RemoteStateMessage::CanSend(tx)).await.is_err() {
             return false;
         }
         rx.await.unwrap_or(false)
@@ -379,21 +379,21 @@ impl MagicSock {
     // TODO: Build better info to expose to the user about remote nodes.  We probably want
     // to expose this as part of path information instead.
     pub(crate) async fn latency(&self, eid: EndpointId) -> Option<Duration> {
-        let endpoint_state = self.endpoint_map.endpoint_state_actor(eid);
+        let remote_state = self.remote_map.remote_state_actor(eid);
         let (tx, rx) = oneshot::channel();
-        endpoint_state
-            .send(EndpointStateMessage::Latency(tx))
+        remote_state
+            .send(RemoteStateMessage::Latency(tx))
             .await
             .ok();
         rx.await.unwrap_or_default()
     }
 
     /// Returns the socket address which can be used by the QUIC layer to dial this endpoint.
     pub(crate) fn get_endpoint_mapped_addr(&self, eid: EndpointId) -> EndpointIdMappedAddr {
-        self.endpoint_map.endpoint_mapped_addr(eid)
+        self.remote_map.endpoint_mapped_addr(eid)
     }
 
-    /// Add potential addresses for a endpoint to the `EndpointStateActor`.
+    /// Add potential addresses for a endpoint to the `RemoteStateActor`.
     ///
     /// This is used to add possible paths that the remote endpoint might be reachable on.  They
     /// will be used when there is no active connection to the endpoint to attempt to establish
@@ -402,7 +402,7 @@ impl MagicSock {
     pub(crate) async fn add_endpoint_addr(
         &self,
         mut addr: EndpointAddr,
-        source: endpoint_map::Source,
+        source: remote_map::Source,
     ) -> Result<(), AddEndpointAddrError> {
         let mut pruned: usize = 0;
         for my_addr in self.direct_addrs.sockaddrs() {
@@ -412,8 +412,8 @@ impl MagicSock {
             }
         }
         if !addr.is_empty() {
-            // Add addr to the internal EndpointMap
-            self.endpoint_map
+            // Add addr to the internal RemoteMap
+            self.remote_map
                 .add_endpoint_addr(addr.clone(), source)
                 .await;
             Ok(())
@@ -522,8 +522,8 @@ impl MagicSock {
         // result in the wrong address family and Windows trips up on that.
         //
         // What should be done is that this dst_ip from the RecvMeta is stored in the
-        // EndpointState/PathState.  Then on the send path it should be retrieved from the
-        // EndpointState/PathSate together with the send address and substituted at send time.
+        // RemoteState/PathState.  Then on the send path it should be retrieved from the
+        // RemoteState/PathState together with the send address and substituted at send time.
         // This is relevant for IPv6 link-local addresses where the OS otherwise does not
         // know which interface to send from.
         #[cfg(not(windows))]
@@ -605,7 +605,7 @@ impl MagicSock {
                     }
                     transports::Addr::Relay(src_url, src_endpoint) => {
                         let mapped_addr = self
-                            .endpoint_map
+                            .remote_map
                             .relay_mapped_addrs
                             .get(&(src_url.clone(), *src_endpoint));
                         quinn_meta.addr = mapped_addr.private_socket_addr();
@@ -679,15 +679,15 @@ impl MagicSock {
         match dm {
             disco::Message::Ping(ping) => {
                 self.metrics.magicsock.recv_disco_ping.inc();
-                self.endpoint_map.handle_ping(ping, sender, src.clone());
+                self.remote_map.handle_ping(ping, sender, src.clone());
             }
             disco::Message::Pong(pong) => {
                 self.metrics.magicsock.recv_disco_pong.inc();
-                self.endpoint_map.handle_pong(pong, sender, src.clone());
+                self.remote_map.handle_pong(pong, sender, src.clone());
             }
             disco::Message::CallMeMaybe(cm) => {
                 self.metrics.magicsock.recv_disco_call_me_maybe.inc();
-                self.endpoint_map
+                self.remote_map
                     .handle_call_me_maybe(cm, sender, src.clone());
             }
         }
@@ -1015,8 +1015,8 @@ impl Handle {
         let direct_addrs = DiscoveredDirectAddrs::default();
         let (disco, disco_receiver) = DiscoState::new(&secret_key);
 
-        let endpoint_map = {
-            EndpointMap::new(
+        let remote_map = {
+            RemoteMap::new(
                 secret_key.public(),
                 metrics.magicsock.clone(),
                 direct_addrs.addrs.watch(),
@@ -1032,7 +1032,7 @@ impl Handle {
             disco,
             actor_sender: actor_sender.clone(),
             ipv6_reported,
-            endpoint_map,
+            remote_map,
             discovery,
             relay_map: relay_map.clone(),
             discovery_user_data: RwLock::new(discovery_user_data),
@@ -1358,8 +1358,8 @@ impl Actor {
         // ensure we are doing an initial publish of our addresses
         self.msock.publish_my_addr();
 
-        // Interval timer to remove closed `EndpointStateActor` handles from the endpoint map.
-        let mut endpoint_map_gc = time::interval(endpoint_map::ENDPOINT_MAP_GC_INTERVAL);
+        // Interval timer to remove closed `RemoteStateActor` handles from the endpoint map.
+        let mut remote_map_gc = time::interval(remote_map::REMOTE_MAP_GC_INTERVAL);
 
         loop {
             self.msock.metrics.magicsock.actor_tick_main.inc();
@@ -1472,8 +1472,8 @@ impl Actor {
                         warn!(%dst, endpoint = %dst_key.fmt_short(), ?err, "failed to send disco message (UDP)");
                     }
                 }
-                _ = endpoint_map_gc.tick() => {
-                    self.msock.endpoint_map.remove_closed_endpoint_state_actors();
+                _ = remote_map_gc.tick() => {
+                    self.msock.remote_map.remove_closed_remote_state_actors();
                 }
             }
         }
@@ -1844,7 +1844,7 @@ mod tests {
     use tracing::{Instrument, error, info, info_span, instrument};
     use tracing_test::traced_test;
 
-    use super::{EndpointIdMappedAddr, Options, endpoint_map::Source, mapped_addrs::MappedAddr};
+    use super::{EndpointIdMappedAddr, Options, mapped_addrs::MappedAddr, remote_map::Source};
     use crate::{
         Endpoint, RelayMode, SecretKey,
         discovery::static_provider::StaticProvider,
@@ -2379,7 +2379,7 @@ mod tests {
 
         let msock_1 = magicsock_ep(secret_key_1.clone()).await.unwrap();
 
-        // Generate an address not present in the EndpointMap.
+        // Generate an address not present in the RemoteMap.
         let bad_addr = EndpointIdMappedAddr::generate();
 
         // 500ms is rather fast here.  Running this locally it should always be the correct
@@ -2505,9 +2505,9 @@ mod tests {
         });
         let _accept_task = AbortOnDropHandle::new(accept_task);
 
-        // Add an empty entry in the EndpointMap of ep_1
+        // Add an empty entry in the RemoteMap of ep_1
         msock_1
-            .endpoint_map
+            .remote_map
             .add_endpoint_addr(
                 EndpointAddr {
                     id: endpoint_id_2,
@@ -2545,7 +2545,7 @@ mod tests {
 
         // Provide correct addressing information
         msock_1
-            .endpoint_map
+            .remote_map
             .add_endpoint_addr(
                 EndpointAddr {
                     id: endpoint_id_2,
@@ -2584,6 +2584,6 @@ mod tests {
         .expect("connection timed out");
 
         // TODO: could remove the addresses again, send, add it back and see it recover.
-        // But we don't have that much private access to the EndpointMap.  This will do for now.
+        // But we don't have that much private access to the RemoteMap.  This will do for now.
     }
 }