feat: prepare for wasm support

Author: Frando

Cargo.lock

@@ -31,20 +31,20 @@ futures-buffered = "0.2.4"
 futures-lite = "2.3.0"
 futures-util = { version = "0.3.25" }
 hex = "0.4"
-iroh = { version = "0.94" }
+iroh = { version = "0.94", default-features = false }
 iroh-tickets = { version = "0.1"}
-iroh-blobs = { version = "0.96" }
-iroh-gossip = { version = "0.94", features = ["net"] }
+iroh-blobs = { git = "https://github.com/n0-computer/iroh-blobs", branch = "Frando/wasm-nopatch", default-features = false }
+iroh-gossip = { version = "0.94", features = ["net"], default-features = false }
 iroh-metrics = { version = "0.36", default-features = false }
-irpc = { version = "0.10.0" }
+irpc = { git = "https://github.com/n0-computer/irpc", branch = "main", default-features = false }
 n0-future = "0.3"
 num_enum = "0.7"
 postcard = { version = "1", default-features = false, features = [
     "alloc",
     "use-std",
     "experimental-derive",
 ] }
-quinn = { package = "iroh-quinn", version = "0.14.0" }
+quinn = { package = "iroh-quinn", version = "0.14.0", optional = true }
 rand = "0.9.2"
 redb = { version = "2.6.3" }
 self_cell = "1.0.3"
@@ -74,8 +74,10 @@ tracing-subscriber = { version = "0.3.20", features = ["env-filter"] }
 tracing-test = "0.2.5"
 
 [features]
-default = ["metrics"]
+default = ["metrics", "rpc", "fs-store"]
 metrics = ["iroh-metrics/metrics", "iroh/metrics"]
+rpc = ["dep:quinn", "irpc/rpc", "iroh-blobs/rpc"]
+fs-store = ["iroh-blobs/fs-store"]
 
 [package.metadata.docs.rs]
 all-features = true

Cargo.toml

@@ -4,7 +4,6 @@
 
 use std::{
     future::Future,
-    net::SocketAddr,
     path::Path,
     pin::Pin,
     sync::{
@@ -14,18 +13,14 @@ use std::{
     task::{ready, Poll},
 };
 
-use anyhow::{Context, Result};
+use anyhow::Result;
 use bytes::Bytes;
 use iroh::EndpointAddr;
 use iroh_blobs::{
     api::blobs::{AddPathOptions, AddProgressItem, ExportMode, ExportOptions, ExportProgress},
     Hash,
 };
-use irpc::rpc::Handler;
-use n0_future::{
-    task::{self, AbortOnDropHandle},
-    FutureExt, Stream, StreamExt,
-};
+use n0_future::{FutureExt, Stream, StreamExt};
 
 use self::{
     actor::RpcActor,
@@ -67,19 +62,25 @@ impl DocsApi {
     }
 
     /// Connect to a remote docs service
-    pub fn connect(endpoint: quinn::Endpoint, addr: SocketAddr) -> Result<DocsApi> {
+    #[cfg(feature = "rpc")]
+    pub fn connect(endpoint: quinn::Endpoint, addr: std::net::SocketAddr) -> Result<DocsApi> {
         Ok(DocsApi {
             inner: Client::quinn(endpoint, addr),
         })
     }
 
     /// Listen for incoming RPC connections
-    pub fn listen(&self, endpoint: quinn::Endpoint) -> Result<AbortOnDropHandle<()>> {
+    #[cfg(feature = "rpc")]
+    pub fn listen(
+        &self,
+        endpoint: quinn::Endpoint,
+    ) -> Result<n0_future::task::AbortOnDropHandle<()>> {
+        use anyhow::Context;
         let local = self
             .inner
             .as_local()
             .context("cannot listen on remote API")?;
-        let handler: Handler<DocsProtocol> = Arc::new(move |msg, _rx, tx| {
+        let handler: irpc::rpc::Handler<DocsProtocol> = Arc::new(move |msg, _rx, tx| {
             let local = local.clone();
             Box::pin(async move {
                 match msg {
@@ -114,8 +115,8 @@ impl DocsApi {
                 }
             })
         });
-        let join_handle = task::spawn(irpc::rpc::listen(endpoint, handler));
-        Ok(AbortOnDropHandle::new(join_handle))
+        let join_handle = n0_future::task::spawn(irpc::rpc::listen(endpoint, handler));
+        Ok(n0_future::task::AbortOnDropHandle::new(join_handle))
     }
 
     /// Creates a new document author.

src/api.rs

@@ -304,7 +304,7 @@ pub struct AuthorDeleteResponse;
 
 // Use the macro to generate both the DocsProtocol and DocsMessage enums
 // plus implement Channels for each type
-#[rpc_requests(message = DocsMessage)]
+#[rpc_requests(message = DocsMessage, rpc_feature = "rpc")]
 #[derive(Serialize, Deserialize, Debug)]
 pub enum DocsProtocol {
     #[rpc(tx = oneshot::Sender<RpcResult<OpenResponse>>)]

src/api/protocol.rs

@@ -13,7 +13,7 @@ use futures_lite::{Stream, StreamExt};
 use iroh::{Endpoint, EndpointAddr, PublicKey};
 use iroh_blobs::{
     api::{blobs::BlobStatus, downloader::Downloader, Store},
-    store::fs::options::{ProtectCb, ProtectOutcome},
+    store::{ProtectCb, ProtectOutcome},
     Hash,
 };
 use iroh_gossip::net::Gossip;

src/engine.rs

@@ -28,6 +28,7 @@ impl Docs {
 
     /// Create a new [`Builder`] for the docs protocol, using a persistent replica and author storage
     /// in the given directory.
+    #[cfg(feature = "fs-store")]
     pub fn persistent(path: PathBuf) -> Builder {
         Builder {
             path: Some(path),

src/protocol.rs

@@ -6,7 +6,7 @@ use std::{
 };
 
 use iroh::{discovery::IntoDiscovery, dns::DnsResolver, EndpointId, RelayMode, SecretKey};
-use iroh_blobs::store::fs::options::{GcConfig, Options};
+use iroh_blobs::store::GcConfig;
 use iroh_docs::{engine::ProtectCallbackHandler, protocol::Docs};
 use iroh_gossip::net::Gossip;
 
@@ -64,7 +64,7 @@ impl Client {
 pub struct Builder {
     endpoint: iroh::endpoint::Builder,
     use_n0_discovery: bool,
-    path: Option<PathBuf>,
+    storage: Storage,
     // node_discovery: Option<Box<dyn Discovery>>,
     gc_interval: Option<std::time::Duration>,
     #[debug(skip)]
@@ -97,9 +97,10 @@ impl Builder {
         let endpoint = builder.bind().await?;
         let mut router = iroh::protocol::Router::builder(endpoint.clone());
         let gossip = Gossip::builder().spawn(endpoint.clone());
-        let mut docs_builder = match self.path {
-            Some(ref path) => Docs::persistent(path.to_path_buf()),
-            None => Docs::memory(),
+        let mut docs_builder = match self.storage {
+            Storage::Memory => Docs::memory(),
+            #[cfg(feature = "fs-store")]
+            Storage::Persistent(ref path) => Docs::persistent(path.to_path_buf()),
         };
         if let Some(protect_cb) = protect_cb {
             docs_builder = docs_builder.protect_handler(protect_cb);
@@ -183,11 +184,11 @@ impl Builder {
         self
     }
 
-    fn new(path: Option<PathBuf>) -> Self {
+    fn new(storage: Storage) -> Self {
         Self {
             endpoint: iroh::Endpoint::empty_builder(RelayMode::Disabled),
             use_n0_discovery: true,
-            path,
+            storage,
             gc_interval: None,
             bind_random_port: false,
             // node_discovery: None,
@@ -197,30 +198,38 @@ impl Builder {
     }
 }
 
+#[derive(Debug)]
+enum Storage {
+    Memory,
+    #[cfg(feature = "fs-store")]
+    Persistent(PathBuf),
+}
+
 impl Node {
     /// Creates a new node with memory storage
     pub fn memory() -> Builder {
-        Builder::new(None)
+        Builder::new(Storage::Memory)
     }
 
     /// Creates a new node with persistent storage
+    #[cfg(feature = "fs-store")]
     pub fn persistent(path: impl AsRef<Path>) -> Builder {
-        let path = Some(path.as_ref().to_owned());
-        Builder::new(path)
+        Builder::new(Storage::Persistent(path.as_ref().to_owned()))
     }
 }
 
 impl Builder {
     /// Spawns the node
     pub async fn spawn(self) -> anyhow::Result<Node> {
-        let (store, protect_handler) = match self.path {
-            None => {
+        let (store, protect_handler) = match self.storage {
+            Storage::Memory => {
                 let store = iroh_blobs::store::mem::MemStore::new();
                 ((*store).clone(), None)
             }
-            Some(ref path) => {
+            #[cfg(feature = "fs-store")]
+            Storage::Persistent(ref path) => {
                 let db_path = path.join("blobs.db");
-                let mut opts = Options::new(path);
+                let mut opts = iroh_blobs::store::fs::options::Options::new(path);
                 let protect_handler = if let Some(interval) = self.gc_interval {
                     let (handler, cb) = ProtectCallbackHandler::new();
                     opts.gc = Some(GcConfig {