minimize diff and required changes

Author: rklaehn

README.md

@@ -34,7 +34,7 @@ Here is a basic example of how to set up `iroh-blobs` with `iroh`:
 
 ```rust,no_run
 use iroh::{protocol::Router, Endpoint};
-use iroh_blobs::{store::mem::MemStore, BlobsProtocol, provider::events::EventSender};
+use iroh_blobs::{store::mem::MemStore, BlobsProtocol};
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
@@ -44,7 +44,7 @@ async fn main() -> anyhow::Result<()> {
 
     // create a protocol handler using an in-memory blob store.
     let store = MemStore::new();
-    let blobs = BlobsProtocol::new(&store, endpoint.clone(), EventSender::NONE);
+    let blobs = BlobsProtocol::new(&store, endpoint.clone(), None);
 
     // build the router
     let router = Router::builder(endpoint)

examples/custom-protocol.rs

@@ -48,9 +48,7 @@ use iroh::{
     protocol::{AcceptError, ProtocolHandler, Router},
     Endpoint, NodeId,
 };
-use iroh_blobs::{
-    api::Store, provider::events::EventSender, store::mem::MemStore, BlobsProtocol, Hash,
-};
+use iroh_blobs::{api::Store, store::mem::MemStore, BlobsProtocol, Hash};
 mod common;
 use common::{get_or_generate_secret_key, setup_logging};
 
@@ -102,7 +100,7 @@ async fn listen(text: Vec<String>) -> Result<()> {
         proto.insert_and_index(text).await?;
     }
     // Build the iroh-blobs protocol handler, which is used to download blobs.
-    let blobs = BlobsProtocol::new(&store, endpoint.clone(), EventSender::NONE);
+    let blobs = BlobsProtocol::new(&store, endpoint.clone(), None);
 
     // create a router that handles both our custom protocol and the iroh-blobs protocol.
     let node = Router::builder(endpoint)

examples/mdns-discovery.rs

@@ -18,7 +18,7 @@ use clap::{Parser, Subcommand};
 use iroh::{
     discovery::mdns::MdnsDiscovery, protocol::Router, Endpoint, PublicKey, RelayMode, SecretKey,
 };
-use iroh_blobs::{provider::events::EventSender, store::mem::MemStore, BlobsProtocol, Hash};
+use iroh_blobs::{store::mem::MemStore, BlobsProtocol, Hash};
 
 mod common;
 use common::{get_or_generate_secret_key, setup_logging};
@@ -68,7 +68,7 @@ async fn accept(path: &Path) -> Result<()> {
         .await?;
     let builder = Router::builder(endpoint.clone());
     let store = MemStore::new();
-    let blobs = BlobsProtocol::new(&store, endpoint.clone(), EventSender::NONE);
+    let blobs = BlobsProtocol::new(&store, endpoint.clone(), None);
     let builder = builder.accept(iroh_blobs::ALPN, blobs.clone());
     let node = builder.spawn();
 

examples/random_store.rs

@@ -238,7 +238,7 @@ async fn provide(args: ProvideArgs) -> anyhow::Result<()> {
         .bind()
         .await?;
     let (dump_task, events_tx) = dump_provider_events(args.allow_push);
-    let blobs = iroh_blobs::BlobsProtocol::new(&store, endpoint.clone(), events_tx);
+    let blobs = iroh_blobs::BlobsProtocol::new(&store, endpoint.clone(), Some(events_tx));
     let router = iroh::protocol::Router::builder(endpoint.clone())
         .accept(iroh_blobs::ALPN, blobs)
         .spawn();

examples/transfer.rs

@@ -1,9 +1,7 @@
 use std::path::PathBuf;
 
 use iroh::{protocol::Router, Endpoint};
-use iroh_blobs::{
-    provider::events::EventSender, store::mem::MemStore, ticket::BlobTicket, BlobsProtocol,
-};
+use iroh_blobs::{store::mem::MemStore, ticket::BlobTicket, BlobsProtocol};
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
@@ -14,7 +12,7 @@ async fn main() -> anyhow::Result<()> {
     // We initialize an in-memory backing store for iroh-blobs
     let store = MemStore::new();
     // Then we initialize a struct that can accept blobs requests over iroh connections
-    let blobs = BlobsProtocol::new(&store, endpoint.clone(), EventSender::NONE);
+    let blobs = BlobsProtocol::new(&store, endpoint.clone(), None);
 
     // Grab all passed in arguments, the first one is the binary itself, so we skip it.
     let args: Vec<String> = std::env::args().skip(1).collect();

src/net_protocol.rs

@@ -7,7 +7,7 @@
 //! ```rust
 //! # async fn example() -> anyhow::Result<()> {
 //! use iroh::{protocol::Router, Endpoint};
-//! use iroh_blobs::{provider::events::EventSender, store, BlobsProtocol};
+//! use iroh_blobs::{store, BlobsProtocol};
 //!
 //! // create a store
 //! let store = store::fs::FsStore::load("blobs").await?;
@@ -19,7 +19,7 @@
 //! let endpoint = Endpoint::builder().discovery_n0().bind().await?;
 //!
 //! // create a blobs protocol handler
-//! let blobs = BlobsProtocol::new(&store, endpoint.clone(), EventSender::NONE);
+//! let blobs = BlobsProtocol::new(&store, endpoint.clone(), None);
 //!
 //! // create a router and add the blobs protocol handler
 //! let router = Router::builder(endpoint)
@@ -69,12 +69,12 @@ impl Deref for BlobsProtocol {
 }
 
 impl BlobsProtocol {
-    pub fn new(store: &Store, endpoint: Endpoint, events: EventSender) -> Self {
+    pub fn new(store: &Store, endpoint: Endpoint, events: Option<EventSender>) -> Self {
         Self {
             inner: Arc::new(BlobsInner {
                 store: store.clone(),
                 endpoint,
-                events,
+                events: events.unwrap_or(EventSender::NONE),
             }),
         }
     }

src/tests.rs

@@ -494,7 +494,7 @@ pub async fn node_test_setup_with_events_fs(
 ) -> TestResult<(Router, FsStore, PathBuf)> {
     let store = crate::store::fs::FsStore::load(&db_path).await?;
     let ep = Endpoint::builder().bind().await?;
-    let blobs = BlobsProtocol::new(&store, ep.clone(), events);
+    let blobs = BlobsProtocol::new(&store, ep.clone(), Some(events));
     let router = Router::builder(ep).accept(crate::ALPN, blobs).spawn();
     Ok((router, store, db_path))
 }
@@ -508,7 +508,7 @@ pub async fn node_test_setup_with_events_mem(
 ) -> TestResult<(Router, MemStore)> {
     let store = MemStore::new();
     let ep = Endpoint::builder().bind().await?;
-    let blobs = BlobsProtocol::new(&store, ep.clone(), events);
+    let blobs = BlobsProtocol::new(&store, ep.clone(), Some(events));
     let router = Router::builder(ep).accept(crate::ALPN, blobs).spawn();
     Ok((router, store))
 }
@@ -605,8 +605,7 @@ async fn node_serve_hash_seq() -> TestResult<()> {
     let root_tt = store.add_bytes(hash_seq).await?;
     let root = root_tt.hash;
     let endpoint = Endpoint::builder().discovery_n0().bind().await?;
-    let blobs =
-        crate::net_protocol::BlobsProtocol::new(&store, endpoint.clone(), EventSender::NONE);
+    let blobs = crate::net_protocol::BlobsProtocol::new(&store, endpoint.clone(), None);
     let r1 = Router::builder(endpoint)
         .accept(crate::protocol::ALPN, blobs)
         .spawn();
@@ -637,8 +636,7 @@ async fn node_serve_blobs() -> TestResult<()> {
         tts.push(store.add_bytes(test_data(size)).await?);
     }
     let endpoint = Endpoint::builder().discovery_n0().bind().await?;
-    let blobs =
-        crate::net_protocol::BlobsProtocol::new(&store, endpoint.clone(), EventSender::NONE);
+    let blobs = crate::net_protocol::BlobsProtocol::new(&store, endpoint.clone(), None);
     let r1 = Router::builder(endpoint)
         .accept(crate::protocol::ALPN, blobs)
         .spawn();
@@ -680,7 +678,7 @@ 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().discovery_n0().bind().await?;
-    let blobs = crate::net_protocol::BlobsProtocol::new(store, endpoint.clone(), EventSender::NONE);
+    let blobs = crate::net_protocol::BlobsProtocol::new(store, endpoint.clone(), None);
     let r1 = Router::builder(endpoint)
         .accept(crate::protocol::ALPN, blobs)
         .spawn();