remove unnecessary From impls

Author: “ramfox”

iroh-relay/src/relay_map.rs

@@ -53,18 +53,6 @@ impl RelayMap {
     }
 }
 
-impl FromIterator<Arc<RelayNode>> for RelayMap {
-    fn from_iter<T: IntoIterator<Item = Arc<RelayNode>>>(iter: T) -> Self {
-        Self {
-            nodes: Arc::new(
-                iter.into_iter()
-                    .map(|node| (node.url.clone(), node))
-                    .collect(),
-            ),
-        }
-    }
-}
-
 impl FromIterator<RelayNode> for RelayMap {
     fn from_iter<T: IntoIterator<Item = RelayNode>>(iter: T) -> Self {
         Self {
@@ -77,6 +65,10 @@ impl FromIterator<RelayNode> for RelayMap {
     }
 }
 
+/// Create a `RelayMap` from a `RelayUrl`.
+///
+/// The `RelayNode`s in the `RelayMap` will have the default stun and quic address
+/// discovery ports.
 impl From<RelayUrl> for RelayMap {
     fn from(value: RelayUrl) -> Self {
         Self {
@@ -85,6 +77,10 @@ impl From<RelayUrl> for RelayMap {
     }
 }
 
+/// Create a `RelayMap` from a `RelayUrl` and a stun port.
+///
+/// The resulting `RelayMap` contains `RelayNode`s with the default quic address
+/// discovery port.
 impl From<(RelayUrl, u16)> for RelayMap {
     fn from(value: (RelayUrl, u16)) -> Self {
         Self {
@@ -101,6 +97,10 @@ impl From<RelayNode> for RelayMap {
     }
 }
 
+/// Create a `RelayMap` from an interator of `RelayUrl`.
+///
+/// The `RelayNode`s in the `RelayMap` will have the default stun and quic address
+/// discovery ports.
 impl FromIterator<RelayUrl> for RelayMap {
     fn from_iter<T: IntoIterator<Item = RelayUrl>>(iter: T) -> Self {
         Self {
@@ -113,6 +113,10 @@ impl FromIterator<RelayUrl> for RelayMap {
     }
 }
 
+/// Create a `RelayMap` from an iterator of `RelayUrl`s and a stun ports.
+///
+/// The resulting `RelayMap` contains `RelayNode`s with the default quic address
+/// discovery port.
 impl FromIterator<(RelayUrl, u16)> for RelayMap {
     fn from_iter<T: IntoIterator<Item = (RelayUrl, u16)>>(iter: T) -> Self {
         Self {

iroh/examples/transfer.rs

@@ -10,7 +10,7 @@ use indicatif::HumanBytes;
 use iroh::{
     discovery::{dns::DnsDiscovery, pkarr::PkarrPublisher},
     endpoint::{ConnectionError, PathSelection},
-    Endpoint, NodeAddr, RelayMap, RelayMode, RelayUrl, SecretKey,
+    Endpoint, NodeAddr, RelayMode, RelayUrl, SecretKey,
 };
 use iroh_base::ticket::NodeTicket;
 use tracing::info;

iroh/src/net_report.rs

@@ -877,11 +877,9 @@ pub(crate) mod stun_utils {
 mod test_utils {
     //! Creates a relay server against which to perform tests
 
-    use std::sync::Arc;
-
     use iroh_relay::{server, RelayNode, RelayQuicConfig};
 
-    pub(crate) async fn relay() -> (server::Server, Arc<RelayNode>) {
+    pub(crate) async fn relay() -> (server::Server, RelayNode) {
         let server = server::Server::spawn(server::testing::server_config())
             .await
             .expect("should serve relay");
@@ -895,7 +893,7 @@ mod test_utils {
             quic,
         };
 
-        (server, Arc::new(node_desc))
+        (server, node_desc)
     }
 
     /// Create a [`crate::RelayMap`] of the given size.

iroh/src/net_report/reportgen.rs

@@ -1455,6 +1455,8 @@ mod tests {
         let (_server_b, relay_b) = test_utils::relay().await;
 
         let mut report = Report::default();
+        let relay_a = Arc::new(relay_a);
+        let relay_b = Arc::new(relay_b);
 
         // A STUN IPv4 probe from the the first relay server.
         let probe_report_a = ProbeReport {
@@ -1539,6 +1541,8 @@ mod tests {
     async fn test_update_report_icmp() {
         let (_server_a, relay_a) = test_utils::relay().await;
         let (_server_b, relay_b) = test_utils::relay().await;
+        let relay_a = Arc::new(relay_a);
+        let relay_b = Arc::new(relay_b);
 
         let mut report = Report::default();
 
@@ -1652,7 +1656,7 @@ mod tests {
         let addr = server.stun_addr().expect("test relay serves stun");
         let probe = Probe::IcmpV4 {
             delay: Duration::from_secs(0),
-            node,
+            node: Arc::new(node),
         };
 
         // A single ICMP packet might get lost.  Try several and take the first.
@@ -1717,6 +1721,7 @@ mod tests {
     #[traced_test]
     async fn test_quic_probe() -> TestResult {
         let (server, relay) = test_utils::relay().await;
+        let relay = Arc::new(relay);
         let client_config = iroh_relay::client::make_dangerous_client_config();
         let ep = quinn::Endpoint::client(SocketAddr::new(Ipv4Addr::LOCALHOST.into(), 0))?;
         let client_addr = ep.local_addr()?;
@@ -1730,7 +1735,7 @@ mod tests {
         let port = server.quic_addr().unwrap().port();
         let probe = Probe::QuicIpv4 {
             delay: Duration::from_secs(0),
-            node: relay.clone(),
+            node: relay,
         };
         let probe = match run_quic_probe(
             quic_addr_disc,