feat: forest-cli net info

CHANGELOG.md

@@ -49,6 +49,8 @@
   loading forest.car.zst files.
 - [#3284](https://github.com/ChainSafe/forest/pull/3284): Add `--diff` flag to
   `archive export`.
+- [#3292](https://github.com/ChainSafe/forest/pull/3292): Add `net info`
+  subcommand to `forest-cli`.
 
 ### Changed
 

scripts/gen_coverage_report.sh

@@ -47,6 +47,7 @@ cov forest-cli snapshot export
 cov forest-cli attach --exec 'showPeers()'
 cov forest-cli net listen
 cov forest-cli net peers
+cov forest-cli net info
 
 # Load the admin token
 TOKEN=$(cat "$TOKEN_PATH")

scripts/tests/calibnet_other_check.sh

@@ -25,4 +25,7 @@ $FOREST_CLI_PATH chain set-head --epoch -10 --force
 echo "Test subcommand: info show"
 $FOREST_CLI_PATH info show
 
+echo "Test subcommand: net info"
+$FOREST_CLI_PATH net info
+
 $FOREST_CLI_PATH sync wait # allow the node to re-sync

src/chain_sync/chain_muxer.rs

@@ -419,6 +419,10 @@ where
                 metrics::LIBP2P_MESSAGE_TOTAL
                     .with_label_values(&[metrics::values::PEER_DISCONNECTED])
                     .inc();
+                // Unset heavist tipset for unset peers
+                metrics::PEER_TIPSET_EPOCH
+                    .with_label_values(&[peer_id.to_string().as_str()])
+                    .set(-1);
                 // Spawn and immediately move on to the next event
                 tokio::task::spawn(Self::handle_peer_disconnected_event(
                     network.clone(),

src/cli/subcommands/net_cmd.rs

@@ -7,6 +7,7 @@ use crate::rpc_client::net_ops::*;
 use ahash::HashSet;
 use cid::multibase;
 use clap::Subcommand;
+use itertools::Itertools;
 
 use super::{handle_rpc_err, print_stdout, Config};
 use crate::cli::subcommands::cli_error_and_die;
@@ -15,6 +16,8 @@ use crate::cli::subcommands::cli_error_and_die;
 pub enum NetCommands {
     /// Lists `libp2p` swarm listener addresses
     Listen,
+    /// Lists `libp2p` swarm network info
+    Info,
     /// Lists `libp2p` swarm peers
     Peers,
     /// Connects to a peer by its peer ID and multi-addresses
@@ -44,6 +47,19 @@ impl NetCommands {
                 print_stdout(addresses.join("\n"));
                 Ok(())
             }
+            Self::Info => {
+                let info = net_info((), &config.client.rpc_token)
+                    .await
+                    .map_err(handle_rpc_err)?;
+                println!("forest libp2p swarm info:");
+                println!("num peers: {}", info.num_peers);
+                println!("num connections: {}", info.num_connections);
+                println!("num pending: {}", info.num_pending);
+                println!("num pending incoming: {}", info.num_pending_incoming);
+                println!("num pending outgoing: {}", info.num_pending_outgoing);
+                println!("num established: {}", info.num_established);
+                Ok(())
+            }
             Self::Peers => {
                 let addrs = net_peers((), &config.client.rpc_token)
                     .await
@@ -60,8 +76,7 @@ impl NetCommands {
                                 _ => true,
                             })
                             .map(|addr| addr.to_string())
-                            .collect::<HashSet<_>>()
-                            .into_iter()
+                            .unique()
                             .collect();
                         if addresses.is_empty() {
                             return None;

src/libp2p/service.rs

@@ -6,12 +6,12 @@ use std::{
     time::{Duration, SystemTime, UNIX_EPOCH},
 };
 
-use crate::blocks::GossipBlock;
 use crate::chain::ChainStore;
 use crate::libp2p_bitswap::{
     request_manager::BitswapRequestManager, BitswapStoreRead, BitswapStoreReadWrite,
 };
 use crate::message::SignedMessage;
+use crate::{blocks::GossipBlock, rpc_api::net_api::NetInfoResult};
 use ahash::{HashMap, HashSet};
 use anyhow::Context;
 use cid::Cid;
@@ -170,6 +170,7 @@ pub enum NetworkMessage {
 pub enum NetRPCMethods {
     AddrsListen(OneShotSender<(PeerId, HashSet<Multiaddr>)>),
     Peers(OneShotSender<HashMap<PeerId, HashSet<Multiaddr>>>),
+    Info(OneShotSender<NetInfoResult>),
     Connect(OneShotSender<bool>, PeerId, HashSet<Multiaddr>),
     Disconnect(OneShotSender<()>, PeerId),
 }
@@ -437,6 +438,11 @@ async fn handle_network_message(
                     warn!("Failed to get Libp2p peers");
                 }
             }
+            NetRPCMethods::Info(response_channel) => {
+                if response_channel.send(swarm.network_info().into()).is_err() {
+                    warn!("Failed to get Libp2p peers");
+                }
+            }
             NetRPCMethods::Connect(response_channel, peer_id, addresses) => {
                 let mut success = false;
 

src/rpc/mod.rs

@@ -121,6 +121,7 @@ where
             // Net API
             .with_method(NET_ADDRS_LISTEN, net_api::net_addrs_listen::<DB>)
             .with_method(NET_PEERS, net_api::net_peers::<DB>)
+            .with_method(NET_INFO, net_api::net_info::<DB>)
             .with_method(NET_CONNECT, net_api::net_connect::<DB>)
             .with_method(NET_DISCONNECT, net_api::net_disconnect::<DB>)
             // DB API

src/rpc/net_api.rs

@@ -53,6 +53,18 @@ pub(in crate::rpc) async fn net_peers<DB: Blockstore + Clone + Send + Sync + 'st
     Ok(connections)
 }
 
+pub(in crate::rpc) async fn net_info<DB: Blockstore>(
+    data: Data<RPCState<DB>>,
+) -> Result<NetInfoResult, JsonRpcError> {
+    let (tx, rx) = oneshot::channel();
+    let req = NetworkMessage::JSONRPCRequest {
+        method: NetRPCMethods::Info(tx),
+    };
+
+    data.network_send.send_async(req).await?;
+    Ok(rx.await?)
+}
+
 pub(in crate::rpc) async fn net_connect<DB: Blockstore + Clone + Send + Sync + 'static>(
     data: Data<RPCState<DB>>,
     Params(params): Params<NetConnectParams>,

src/rpc_api/mod.rs

@@ -94,6 +94,7 @@ pub static ACCESS_MAP: Lazy<HashMap<&str, Access>> = Lazy::new(|| {
     // Net API
     access.insert(net_api::NET_ADDRS_LISTEN, Access::Read);
     access.insert(net_api::NET_PEERS, Access::Read);
+    access.insert(net_api::NET_INFO, Access::Read);
     access.insert(net_api::NET_CONNECT, Access::Write);
     access.insert(net_api::NET_DISCONNECT, Access::Write);
 
@@ -417,6 +418,8 @@ pub mod common_api {
 
 /// Net API
 pub mod net_api {
+    use serde::{Deserialize, Serialize};
+
     use crate::rpc_api::data_types::AddrInfo;
 
     pub const NET_ADDRS_LISTEN: &str = "Filecoin.NetAddrsListen";
@@ -427,6 +430,33 @@ pub mod net_api {
     pub type NetPeersParams = ();
     pub type NetPeersResult = Vec<AddrInfo>;
 
+    pub const NET_INFO: &str = "Filecoin.NetInfo";
+    pub type NetInfoParams = ();
+
+    #[derive(Debug, Default, Serialize, Deserialize)]
+    pub struct NetInfoResult {
+        pub num_peers: usize,
+        pub num_connections: u32,
+        pub num_pending: u32,
+        pub num_pending_incoming: u32,
+        pub num_pending_outgoing: u32,
+        pub num_established: u32,
+    }
+
+    impl From<libp2p::swarm::NetworkInfo> for NetInfoResult {
+        fn from(i: libp2p::swarm::NetworkInfo) -> Self {
+            let counters = i.connection_counters();
+            Self {
+                num_peers: i.num_peers(),
+                num_connections: counters.num_connections(),
+                num_pending: counters.num_pending(),
+                num_pending_incoming: counters.num_pending_incoming(),
+                num_pending_outgoing: counters.num_pending_outgoing(),
+                num_established: counters.num_established(),
+            }
+        }
+    }
+
     pub const NET_CONNECT: &str = "Filecoin.NetConnect";
     pub type NetConnectParams = (AddrInfo,);
     pub type NetConnectResult = ();

src/rpc_client/net_ops.rs

@@ -20,6 +20,13 @@ pub async fn net_peers(
     call(NET_PEERS, params, auth_token).await
 }
 
+pub async fn net_info(
+    params: NetInfoParams,
+    auth_token: &Option<String>,
+) -> Result<NetInfoResult, Error> {
+    call(NET_INFO, params, auth_token).await
+}
+
 pub async fn net_connect(
     params: NetConnectParams,
     auth_token: &Option<String>,