refactor(iroh)!: Extract net and node rpc

Cargo.toml

@@ -11,7 +11,7 @@ members = [
   "iroh-relay",
   "iroh-router",
   "net-tools/netwatch",
-  "net-tools/portmapper",
+  "net-tools/portmapper", "iroh-node-util",
 ]
 resolver = "2"
 

iroh-node-util/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "iroh-node-util"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0.93"
+tokio = "1.41.1"
+iroh-net = { path = "../iroh-net" }
+tempfile = "3.14.0"
+strum = "0.26.3"
+nested_enum_utils = "0.1.0"
+quic-rpc-derive = "0.15.0"
+serde = "1.0.215"
+serde-error = "0.1.3"
+quic-rpc = "0.15.0"
+futures-lite = "2.5.0"
+ref-cast = "1.0.23"
+tracing = "0.1.40"
+tokio-util = "0.7.12"
+
+[lints]
+workspace = true

iroh-node-util/src/lib.rs

@@ -0,0 +1,46 @@
+//! Utilities for building iroh nodes.
+pub mod rpc;
+
+use std::path::PathBuf;
+
+use anyhow::Context;
+use iroh_net::key::SecretKey;
+use tokio::io::AsyncWriteExt;
+
+/// Loads a [`SecretKey`] from the provided file, or stores a newly generated one
+/// at the given location.
+pub async fn load_secret_key(key_path: PathBuf) -> anyhow::Result<SecretKey> {
+    if key_path.exists() {
+        let keystr = tokio::fs::read(key_path).await?;
+        let secret_key = SecretKey::try_from_openssh(keystr).context("invalid keyfile")?;
+        Ok(secret_key)
+    } else {
+        let secret_key = SecretKey::generate();
+        let ser_key = secret_key.to_openssh()?;
+
+        // Try to canonicalize if possible
+        let key_path = key_path.canonicalize().unwrap_or(key_path);
+        let key_path_parent = key_path.parent().ok_or_else(|| {
+            anyhow::anyhow!("no parent directory found for '{}'", key_path.display())
+        })?;
+        tokio::fs::create_dir_all(&key_path_parent).await?;
+
+        // write to tempfile
+        let (file, temp_file_path) = tempfile::NamedTempFile::new_in(key_path_parent)
+            .context("unable to create tempfile")?
+            .into_parts();
+        let mut file = tokio::fs::File::from_std(file);
+        file.write_all(ser_key.as_bytes())
+            .await
+            .context("unable to write keyfile")?;
+        file.flush().await?;
+        drop(file);
+
+        // move file
+        tokio::fs::rename(temp_file_path, key_path)
+            .await
+            .context("failed to rename keyfile")?;
+
+        Ok(secret_key)
+    }
+}

iroh-node-util/src/rpc.rs

@@ -0,0 +1,3 @@
+pub mod client;
+pub mod proto;
+pub mod server;

iroh-node-util/src/rpc/client.rs

@@ -0,0 +1,19 @@
+use anyhow::Result;
+use futures_lite::{Stream, StreamExt};
+
+pub mod net;
+pub mod node;
+
+fn flatten<T, E1, E2>(
+    s: impl Stream<Item = Result<Result<T, E1>, E2>>,
+) -> impl Stream<Item = Result<T>>
+where
+    E1: std::error::Error + Send + Sync + 'static,
+    E2: std::error::Error + Send + Sync + 'static,
+{
+    s.map(|res| match res {
+        Ok(Ok(res)) => Ok(res),
+        Ok(Err(err)) => Err(err.into()),
+        Err(err) => Err(err.into()),
+    })
+}

iroh/src/client/net.rs → iroh-node-util/src/rpc/client/net.rs

@@ -13,18 +13,20 @@ use std::net::SocketAddr;
 
 use anyhow::Result;
 use futures_lite::{Stream, StreamExt};
-use iroh_base::node_addr::RelayUrl;
-use iroh_net::{endpoint::RemoteInfo, NodeAddr, NodeId};
-use ref_cast::RefCast;
+use iroh_net::{endpoint::RemoteInfo, relay::RelayUrl, NodeAddr, NodeId};
+use quic_rpc::RpcClient;
 use serde::{Deserialize, Serialize};
 
-use super::{flatten, RpcClient};
-use crate::rpc_protocol::net::{
-    AddAddrRequest, AddrRequest, IdRequest, RelayRequest, RemoteInfoRequest, RemoteInfoResponse,
-    RemoteInfosIterRequest,
+use super::flatten;
+use crate::rpc::proto::{
+    net::{
+        AddAddrRequest, AddrRequest, IdRequest, RelayRequest, RemoteInfoRequest,
+        RemoteInfoResponse, RemoteInfosIterRequest,
+    },
+    RpcService,
 };
 
-/// Iroh netx Client.
+/// Iroh net Client.
 ///
 /// Cheaply clonable and threadsafe. Use the iroh `net::Client` to access the
 /// iroh net methods from a different thread, process, or remote machine.
@@ -70,13 +72,17 @@ use crate::rpc_protocol::net::{
 /// # Ok(())
 /// # }
 /// ```
-#[derive(Debug, Clone, RefCast)]
+#[derive(Debug, Clone)]
 #[repr(transparent)]
 pub struct Client {
-    pub(super) rpc: RpcClient,
+    pub(super) rpc: RpcClient<RpcService>,
 }
 
 impl Client {
+    pub fn new(rpc: RpcClient<RpcService>) -> Self {
+        Self { rpc }
+    }
+
     /// Fetches information about currently known remote nodes.
     ///
     /// This streams a *current snapshot*. It does not keep the stream open after finishing