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() {
87                                Some(Protocol::Ip4(ip_addr)) => !ip_addr.is_loopback(),
88                                Some(Protocol::Ip6(ip_addr)) => !ip_addr.is_loopback(),
89                                Some(_) => true,
90                                None => false,
91                            })
92                            .map(|addr| addr.to_string())
93                            .unique()
94                            .collect();
95                        if addresses.is_empty() {
96                            return None;
97                        }
98
99                        let result = format!("{}, [{}]", info.id, addresses.join(", "));
100
101                        if agent {
102                            Some(
103                                [
104                                    result,
105                                    peer_to_agents
106                                        .get(&info.id)
107                                        .cloned()
108                                        .unwrap_or_else(|| "<agent unknown>".to_owned()),
109                                ]
110                                .join(", "),
111                            )
112                        } else {
113                            Some(result)
114                        }
115                    })
116                    .collect();
117                println!("{}", output.join("\n"));
118                Ok(())
119            }
120            Self::Connect { address } => {
121                let addr: Multiaddr = address
122                    .parse()
123                    .map_err(|e| {
124                        cli_error_and_die(format!("Error parsing multiaddr. Error was: {e}"), 1);
125                    })
126                    .expect("Parse provided multiaddr from string");
127
128                let mut id = "".to_owned();
129
130                for protocol in addr.iter() {
131                    if let Protocol::P2p(p2p) = protocol {
132                        id = multibase::encode(multibase::Base::Base58Btc, p2p.to_bytes());
133                        id = id.split_off(1);
134                    }
135                }
136
137                if id.is_empty() {
138                    cli_error_and_die("Needs a /p2p/ protocol present in multiaddr", 1)
139                }
140
141                let addrs = HashSet::from_iter([addr]);
142                let addr_info = AddrInfo {
143                    id: id.clone(),
144                    addrs,
145                };
146
147                NetConnect::call(&client, (addr_info,)).await?;
148                println!("connect {id}: success");
149                Ok(())
150            }
151            Self::Disconnect { id } => {
152                NetDisconnect::call(&client, (id.clone(),)).await?;
153                println!("disconnect {id}: success");
154                Ok(())
155            }
156            Self::Reachability => {
157                let nat_status = NetAutoNatStatus::call(&client, ()).await?;
158                println!("AutoNAT status:  {}", nat_status.reachability_as_str());
159                if let Some(public_addrs) = nat_status.public_addrs
160                    && !public_addrs.is_empty()
161                {
162                    // Format is compatible with Go code:
163                    // `fmt.Println("Public address:", []string{"foo", "bar"})`
164                    println!("Public address: [{}]", public_addrs.join(" "));
165                }
166                Ok(())
167            }
168        }
169    }
170}
forest/cli/subcommands/net_cmd.rs

forest/cli/subcommands/
net_cmd.rs
