Remove last .discovery_n0() calls.

Author: rklaehn

README.md

@@ -40,7 +40,7 @@ use iroh_blobs::{store::mem::MemStore, BlobsProtocol, ticket::BlobTicket};
 async fn main() -> anyhow::Result<()> {
     // create an iroh endpoint that includes the standard discovery mechanisms
     // we've built at number0
-    let endpoint = Endpoint::builder().discovery_n0().bind().await?;
+    let endpoint = Endpoint::bind().await?;
 
     // create a protocol handler using an in-memory blob store.
     let store = MemStore::new();

examples/get-blob.rs

@@ -29,7 +29,7 @@ async fn main() -> anyhow::Result<()> {
     setup_logging();
     let cli = Cli::parse();
     let ticket = cli.ticket;
-    let endpoint = iroh::Endpoint::builder()
+    let endpoint = iroh::Endpoint::empty_builder(iroh::RelayMode::Default)
         .discovery(PkarrResolver::n0_dns())
         .bind()
         .await?;

examples/mdns-discovery.rs

@@ -60,7 +60,7 @@ async fn accept(path: &Path) -> Result<()> {
 
     println!("Starting iroh node with mdns discovery...");
     // create a new node
-    let endpoint = Endpoint::builder()
+    let endpoint = Endpoint::empty_builder(RelayMode::Default)
         .secret_key(key)
         .discovery(MdnsDiscovery::builder())
         .relay_mode(RelayMode::Disabled)
@@ -93,10 +93,9 @@ async fn connect(node_id: PublicKey, hash: Hash, out: Option<PathBuf>) -> Result
 
     println!("Starting iroh node with mdns discovery...");
     // create a new node
-    let endpoint = Endpoint::builder()
+    let endpoint = Endpoint::empty_builder(RelayMode::Disabled)
         .secret_key(key)
         .discovery(discovery)
-        .relay_mode(RelayMode::Disabled)
         .bind()
         .await?;
     let store = MemStore::new();

examples/transfer-collection.rs

@@ -8,7 +8,9 @@
 use std::collections::HashMap;
 
 use anyhow::{Context, Result};
-use iroh::{discovery::static_provider::StaticProvider, protocol::Router, Endpoint, EndpointAddr};
+use iroh::{
+    discovery::static_provider::StaticProvider, protocol::Router, Endpoint, EndpointAddr, RelayMode,
+};
 use iroh_blobs::{
     api::{downloader::Shuffled, Store, TempTag},
     format::collection::Collection,
@@ -27,7 +29,10 @@ struct Node {
 
 impl Node {
     async fn new(disc: &StaticProvider) -> Result<Self> {
-        let endpoint = Endpoint::builder().discovery(disc.clone()).bind().await?;
+        let endpoint = Endpoint::empty_builder(RelayMode::Default)
+            .discovery(disc.clone())
+            .bind()
+            .await?;
 
         let store = MemStore::new();
 
@@ -102,7 +107,7 @@ impl Node {
 async fn main() -> anyhow::Result<()> {
     // create a local provider for nodes to discover each other.
     // outside of a development environment, production apps would
-    // use `Endpoint::builder().discovery_n0()` or a similar method
+    // use `Endpoint::bind()` or a similar method
     let disc = StaticProvider::new();
 
     // create a sending node

examples/transfer.rs

@@ -7,7 +7,7 @@ use iroh_blobs::{store::mem::MemStore, ticket::BlobTicket, BlobsProtocol};
 async fn main() -> anyhow::Result<()> {
     // Create an endpoint, it allows creating and accepting
     // connections in the iroh p2p world
-    let endpoint = Endpoint::builder().bind().await?;
+    let endpoint = Endpoint::bind().await?;
 
     // We initialize an in-memory backing store for iroh-blobs
     let store = MemStore::new();

src/net_protocol.rs

@@ -16,7 +16,7 @@
 //! let t = store.add_slice(b"hello world").await?;
 //!
 //! // create an iroh endpoint
-//! let endpoint = Endpoint::builder().discovery_n0().bind().await?;
+//! let endpoint = Endpoint::bind().await?;
 //! endpoint.online().await;
 //! let addr = endpoint.node_addr();
 //!

src/tests.rs

@@ -2,7 +2,9 @@ use std::{collections::HashSet, io, ops::Range, path::PathBuf};
 
 use bao_tree::ChunkRanges;
 use bytes::Bytes;
-use iroh::{discovery::static_provider::StaticProvider, protocol::Router, Endpoint, EndpointId};
+use iroh::{
+    discovery::static_provider::StaticProvider, protocol::Router, Endpoint, EndpointId, RelayMode,
+};
 use irpc::RpcMessage;
 use n0_future::{task::AbortOnDropHandle, StreamExt};
 use tempfile::TempDir;
@@ -500,7 +502,10 @@ pub async fn node_test_setup_with_events_fs(
 ) -> TestResult<(Router, FsStore, PathBuf, StaticProvider)> {
     let store = crate::store::fs::FsStore::load(&db_path).await?;
     let sp = StaticProvider::new();
-    let ep = Endpoint::builder().discovery(sp.clone()).bind().await?;
+    let ep = Endpoint::empty_builder(RelayMode::Default)
+        .discovery(sp.clone())
+        .bind()
+        .await?;
     let blobs = BlobsProtocol::new(&store, Some(events));
     let router = Router::builder(ep).accept(crate::ALPN, blobs).spawn();
     Ok((router, store, db_path, sp))
@@ -515,7 +520,10 @@ pub async fn node_test_setup_with_events_mem(
 ) -> TestResult<(Router, MemStore, StaticProvider)> {
     let store = MemStore::new();
     let sp = StaticProvider::new();
-    let ep = Endpoint::builder().discovery(sp.clone()).bind().await?;
+    let ep = Endpoint::empty_builder(RelayMode::Default)
+        .discovery(sp.clone())
+        .bind()
+        .await?;
     let blobs = BlobsProtocol::new(&store, Some(events));
     let router = Router::builder(ep).accept(crate::ALPN, blobs).spawn();
     Ok((router, store, sp))
@@ -612,14 +620,14 @@ async fn node_serve_hash_seq() -> TestResult<()> {
     let hash_seq = tts.iter().map(|x| x.hash).collect::<HashSeq>();
     let root_tt = store.add_bytes(hash_seq).await?;
     let root = root_tt.hash;
-    let endpoint = Endpoint::builder().bind().await?;
+    let endpoint = Endpoint::bind().await?;
     let blobs = crate::net_protocol::BlobsProtocol::new(&store, None);
     let r1 = Router::builder(endpoint)
         .accept(crate::protocol::ALPN, blobs)
         .spawn();
     let addr1 = r1.endpoint().addr();
     info!("node addr: {addr1:?}");
-    let endpoint2 = Endpoint::builder().bind().await?;
+    let endpoint2 = Endpoint::bind().await?;
     let conn = endpoint2.connect(addr1, crate::protocol::ALPN).await?;
     let (hs, sizes) = get::request::get_hash_seq_and_sizes(&conn, &root, 1024, None).await?;
     println!("hash seq: {hs:?}");
@@ -643,14 +651,14 @@ async fn node_serve_blobs() -> TestResult<()> {
     for size in sizes {
         tts.push(store.add_bytes(test_data(size)).await?);
     }
-    let endpoint = Endpoint::builder().bind().await?;
+    let endpoint = Endpoint::bind().await?;
     let blobs = crate::net_protocol::BlobsProtocol::new(&store, None);
     let r1 = Router::builder(endpoint)
         .accept(crate::protocol::ALPN, blobs)
         .spawn();
     let addr1 = r1.endpoint().addr();
     info!("node addr: {addr1:?}");
-    let endpoint2 = Endpoint::builder().bind().await?;
+    let endpoint2 = Endpoint::bind().await?;
     let conn = endpoint2.connect(addr1, crate::protocol::ALPN).await?;
     for size in sizes {
         let expected = test_data(size);
@@ -683,14 +691,14 @@ async fn node_smoke_mem() -> TestResult<()> {
 async fn node_smoke(store: &Store) -> TestResult<()> {
     let tt = store.add_bytes(b"hello world".to_vec()).temp_tag().await?;
     let hash = tt.hash();
-    let endpoint = Endpoint::builder().bind().await?;
+    let endpoint = Endpoint::bind().await?;
     let blobs = crate::net_protocol::BlobsProtocol::new(store, None);
     let r1 = Router::builder(endpoint)
         .accept(crate::protocol::ALPN, blobs)
         .spawn();
     let addr1 = r1.endpoint().addr();
     info!("node addr: {addr1:?}");
-    let endpoint2 = Endpoint::builder().bind().await?;
+    let endpoint2 = Endpoint::bind().await?;
     let conn = endpoint2.connect(addr1, crate::protocol::ALPN).await?;
     let (size, stats) = get::request::get_unverified_size(&conn, &hash).await?;
     info!("size: {} stats: {:?}", size, stats);

src/util/connection_pool.rs

@@ -545,7 +545,7 @@ mod tests {
         discovery::static_provider::StaticProvider,
         endpoint::{Connection, ConnectionType},
         protocol::{AcceptError, ProtocolHandler, Router},
-        Endpoint, EndpointAddr, EndpointId, SecretKey, Watcher,
+        Endpoint, EndpointAddr, EndpointId, RelayMode, SecretKey, Watcher,
     };
     use n0_future::{io, stream, BufferedStreamExt, StreamExt};
     use n0_snafu::ResultExt;
@@ -662,7 +662,7 @@ mod tests {
     async fn connection_pool_errors() -> TestResult<()> {
         // set up static discovery for all addrs
         let discovery = StaticProvider::new();
-        let endpoint = iroh::Endpoint::builder()
+        let endpoint = iroh::Endpoint::empty_builder(RelayMode::Default)
             .discovery(discovery.clone())
             .bind()
             .await?;
@@ -699,7 +699,7 @@ mod tests {
         let n = 32;
         let (ids, routers, discovery) = echo_servers(n).await?;
         // build a client endpoint that can resolve all the endpoint ids
-        let endpoint = iroh::Endpoint::builder()
+        let endpoint = iroh::Endpoint::empty_builder(RelayMode::Default)
             .discovery(discovery.clone())
             .bind()
             .await?;
@@ -734,7 +734,7 @@ mod tests {
         let n = 32;
         let (ids, routers, discovery) = echo_servers(n).await?;
         // build a client endpoint that can resolve all the endpoint ids
-        let endpoint = iroh::Endpoint::builder()
+        let endpoint = iroh::Endpoint::empty_builder(RelayMode::Default)
             .discovery(discovery.clone())
             .bind()
             .await?;
@@ -765,7 +765,7 @@ mod tests {
     async fn on_connected_error() -> TestResult<()> {
         let n = 1;
         let (ids, routers, discovery) = echo_servers(n).await?;
-        let endpoint = iroh::Endpoint::builder()
+        let endpoint = iroh::Endpoint::empty_builder(RelayMode::Default)
             .discovery(discovery)
             .bind()
             .await?;
@@ -795,7 +795,7 @@ mod tests {
     async fn on_connected_direct() -> TestResult<()> {
         let n = 1;
         let (ids, routers, discovery) = echo_servers(n).await?;
-        let endpoint = iroh::Endpoint::builder()
+        let endpoint = iroh::Endpoint::empty_builder(RelayMode::Default)
             .discovery(discovery)
             .bind()
             .await?;
@@ -838,7 +838,7 @@ mod tests {
     async fn watch_close() -> TestResult<()> {
         let n = 1;
         let (ids, routers, discovery) = echo_servers(n).await?;
-        let endpoint = iroh::Endpoint::builder()
+        let endpoint = iroh::Endpoint::empty_builder(RelayMode::Default)
             .discovery(discovery)
             .bind()
             .await?;