forest/cli/subcommands/
net_cmd.rs

1// Copyright 2019-2026 ChainSafe Systems
2// SPDX-License-Identifier: Apache-2.0, MIT
3
4use crate::libp2p::{Multiaddr, Protocol};
5use crate::rpc::{self, net::AddrInfo, prelude::*};
6use ahash::{HashMap, HashSet};
7use cid::multibase;
8use clap::Subcommand;
9use itertools::Itertools;
10
11use crate::cli::subcommands::cli_error_and_die;
12
13#[derive(Debug, Subcommand)]
14pub enum NetCommands {
15    /// Lists `libp2p` swarm listener addresses
16    Listen,
17    /// Lists `libp2p` swarm network info
18    Info,
19    /// Lists `libp2p` swarm peers
20    Peers {
21        /// Print agent name
22        #[arg(short, long)]
23        agent: bool,
24    },
25    /// Connects to a peer by its peer ID and multi-addresses
26    Connect {
27        /// Multi-address (with `/p2p/` protocol)
28        address: String,
29    },
30    /// Disconnects from a peer by it's peer ID
31    Disconnect {
32        /// Peer ID to disconnect from
33        id: String,
34    },
35    /// Print information about reachability from the internet
36    Reachability,
37}
38
39impl NetCommands {
40    pub async fn run(self, client: rpc::Client) -> anyhow::Result<()> {
41        match self {
42            Self::Listen => {
43                let info = NetAddrsListen::call(&client, ()).await?;
44                let addresses: Vec<String> = info
45                    .addrs
46                    .iter()
47                    .map(|addr| format!("{}/p2p/{}", addr, info.id))
48                    .collect();
49                println!("{}", addresses.join("\n"));
50                Ok(())
51            }
52            Self::Info => {
53                let info = NetInfo::call(&client, ()).await?;
54                println!("forest libp2p swarm info:");
55                println!("num peers: {}", info.num_peers);
56                println!("num connections: {}", info.num_connections);
57                println!("num pending: {}", info.num_pending);
58                println!("num pending incoming: {}", info.num_pending_incoming);
59                println!("num pending outgoing: {}", info.num_pending_outgoing);
60                println!("num established: {}", info.num_established);
61                Ok(())
62            }
63            Self::Peers { agent } => {
64                let addrs = NetPeers::call(&client, ()).await?;
65                let peer_to_agents: HashMap<String, String> = if agent {
66                    let agents = futures::future::join_all(
67                        addrs
68                            .iter()
69                            .map(|info| NetAgentVersion::call(&client, (info.id.clone(),))),
70                    )
71                    .await
72                    .into_iter()
73                    .map(|res| res.unwrap_or_else(|_| "<agent unknown>".to_owned()));
74
75                    HashMap::from_iter(addrs.iter().map(|info| info.id.to_owned()).zip(agents))
76                } else {
77                    HashMap::default()
78                };
79
80                let output: Vec<String> = addrs
81                    .into_iter()
82                    .filter_map(|info| {
83                        let addresses: Vec<String> = info
84                            .addrs
85                            .into_iter()
86                            .filter(|addr| match addr.iter().next().unwrap() {
87                                Protocol::Ip4(ip_addr) => !ip_addr.is_loopback(),
88                                Protocol::Ip6(ip_addr) => !ip_addr.is_loopback(),
89                                _ => true,
90                            })
91                            .map(|addr| addr.to_string())
92                            .unique()
93                            .collect();
94                        if addresses.is_empty() {
95                            return None;
96                        }
97
98                        let result = format!("{}, [{}]", info.id, addresses.join(", "));
99
100                        if agent {
101                            Some(
102                                [
103                                    result,
104                                    peer_to_agents
105                                        .get(&info.id)
106                                        .cloned()
107                                        .unwrap_or_else(|| "<agent unknown>".to_owned()),
108                                ]
109                                .join(", "),
110                            )
111                        } else {
112                            Some(result)
113                        }
114                    })
115                    .collect();
116                println!("{}", output.join("\n"));
117                Ok(())
118            }
119            Self::Connect { address } => {
120                let addr: Multiaddr = address
121                    .parse()
122                    .map_err(|e| {
123                        cli_error_and_die(format!("Error parsing multiaddr. Error was: {e}"), 1);
124                    })
125                    .expect("Parse provided multiaddr from string");
126
127                let mut id = "".to_owned();
128
129                for protocol in addr.iter() {
130                    if let Protocol::P2p(p2p) = protocol {
131                        id = multibase::encode(multibase::Base::Base58Btc, p2p.to_bytes());
132                        id = id.split_off(1);
133                    }
134                }
135
136                if id.is_empty() {
137                    cli_error_and_die("Needs a /p2p/ protocol present in multiaddr", 1)
138                }
139
140                let addrs = HashSet::from_iter([addr]);
141                let addr_info = AddrInfo {
142                    id: id.clone(),
143                    addrs,
144                };
145
146                NetConnect::call(&client, (addr_info,)).await?;
147                println!("connect {id}: success");
148                Ok(())
149            }
150            Self::Disconnect { id } => {
151                NetDisconnect::call(&client, (id.clone(),)).await?;
152                println!("disconnect {id}: success");
153                Ok(())
154            }
155            Self::Reachability => {
156                let nat_status = NetAutoNatStatus::call(&client, ()).await?;
157                println!("AutoNAT status:  {}", nat_status.reachability_as_str());
158                if let Some(public_addrs) = nat_status.public_addrs
159                    && !public_addrs.is_empty()
160                {
161                    // Format is compatible with Go code:
162                    // `fmt.Println("Public address:", []string{"foo", "bar"})`
163                    println!("Public address: [{}]", public_addrs.join(" "));
164                }
165                Ok(())
166            }
167        }
168    }
169}
forest/cli/subcommands/net_cmd.rs

forest/cli/subcommands/
net_cmd.rs
