refactor(iroh)!: Extract net and node rpc (#2927)

## Description

Introduce a new crate iroh-node-util.

This contains generic utilities that are needed to build an iroh node,
as well as the rpc protocol and rpc client to remote control an
arbitrary iroh-net endpoint (add/remove addresses etc.) as well as to
control the node as a whole (shutdown/stats/status).

## Breaking Changes

- module iroh::client::net is now a reexport of
iroh_node_util::rpc::client::net
- module iroh::client::node is now a reexport of
iroh_node_util::rpc::client::node
- fn iroh::client::Iroh::net returns a net::Client instead of a
&net::Client
- fn iroh::client::Iroh::node returns a node::Client instead of a
&node::Client

## Notes & open questions

Note: I think the rpc protocol and the client needs some refactoring. It
isn't always clear to me what is node and what is net. But I think it
might be best to do this in a subsequent PR and keep this one as a pure
move things around PR for better separation.

## Change checklist

- [ ] Self-review.
- [ ] Documentation updates following the [style
guide](https://rust-lang.github.io/rfcs/1574-more-api-documentation-conventions.html#appendix-a-full-conventions-text),
if relevant.
- [ ] Tests if relevant.
- [ ] All breaking changes documented.

---------

Co-authored-by: dignifiedquire <me@dignifiedquire.com>
Co-authored-by: Diva M <divma@protonmail.com>

Author: 3 people

Cargo.lock

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

Cargo.toml

@@ -101,7 +101,7 @@ impl RpcCommands {
             Self::Tags { command } => command.run(&iroh.tags()).await,
             Self::Gossip { command } => command.run(&iroh.gossip()).await,
             Self::Stats => {
-                let stats = iroh.stats().await?;
+                let stats = iroh.node().stats().await?;
                 for (name, details) in stats.iter() {
                     println!(
                         "{:23} : {:>6}    ({})",
@@ -111,11 +111,11 @@ impl RpcCommands {
                 Ok(())
             }
             Self::Shutdown { force } => {
-                iroh.shutdown(force).await?;
+                iroh.node().shutdown(force).await?;
                 Ok(())
             }
             Self::Status => {
-                let response = iroh.status().await?;
+                let response = iroh.node().status().await?;
                 println!("Listening addresses: {:#?}", response.listen_addrs);
                 println!("Node ID: {}", response.addr.node_id);
                 println!("Version: {}", response.version);

iroh-cli/src/commands/rpc.rs

@@ -0,0 +1,30 @@
+[package]
+name = "iroh-node-util"
+description = "Utilities to build binaries containing an iroh-net endpoint"
+readme = "README.md"
+license = "MIT OR Apache-2.0"
+version = "0.28.0"
+edition = "2021"
+authors = ["n0 team"]
+repository = "https://github.com/n0-computer/iroh"
+keywords = ["quic", "networking", "holepunching", "p2p"]
+
+# Sadly this also needs to be updated in .github/workflows/ci.yml
+rust-version = "1.76"
+
+[lints]
+workspace = true
+
+[dependencies]
+anyhow = "1"
+tokio = "1"
+iroh-net = { path = "../iroh-net" }
+tempfile = "3"
+strum = "0.26"
+nested_enum_utils = "0.1.0"
+quic-rpc = "0.15.0"
+quic-rpc-derive = "0.15.0"
+serde = "1"
+serde-error = "0.1.3"
+futures-lite = "2.5.0"
+tracing = "0.1.40"

iroh-node-util/Cargo.toml

@@ -0,0 +1,21 @@
+# iroh-node-util
+
+This crate provides utilities to build binaries containing an iroh-net endpoint.
+
+# License
+
+This project is licensed under either of
+
+ * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
+   http://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license ([LICENSE-MIT](LICENSE-MIT) or
+   http://opensource.org/licenses/MIT)
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in this project by you, as defined in the Apache-2.0 license,
+shall be dual licensed as above, without any additional terms or conditions.
+

iroh-node-util/README.md

@@ -0,0 +1,47 @@
+#![deny(missing_docs, rustdoc::broken_intra_doc_links)]
+//! 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/lib.rs

@@ -0,0 +1,4 @@
+//! RPC client, server and protocol to control iroh-net endpoints and iroh nodes
+pub mod client;
+pub mod proto;
+pub mod server;

iroh-node-util/src/rpc.rs

@@ -0,0 +1,20 @@
+//! Client to interact with iroh nodes and endpoints.
+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()),
+    })
+}