cometbft_rpc/endpoint/
net_info.rs

1//! `/net_info` endpoint JSON-RPC wrapper
2
3use core::{
4    fmt::{self, Display},
5    time::Duration,
6};
7use std::net::IpAddr;
8
9use cometbft::{channel::Channel, node, serializers, Time};
10use serde::{Deserialize, Serialize};
11
12use crate::prelude::*;
13use crate::{dialect::Dialect, request::RequestMessage};
14
15/// Request network information from a node
16#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
17pub struct Request;
18
19impl RequestMessage for Request {
20    fn method(&self) -> crate::Method {
21        crate::Method::NetInfo
22    }
23}
24
25impl<S: Dialect> crate::Request<S> for Request {
26    type Response = Response;
27}
28
29impl<S: Dialect> crate::SimpleRequest<S> for Request {
30    type Output = Response;
31}
32
33/// Net info responses
34#[derive(Clone, Debug, Deserialize, Serialize)]
35pub struct Response {
36    /// Are we presently listening?
37    pub listening: bool,
38
39    /// Active listeners
40    pub listeners: Vec<Listener>,
41
42    /// Number of connected peers
43    #[serde(with = "serializers::from_str")]
44    pub n_peers: u64,
45
46    /// Peer information
47    pub peers: Vec<PeerInfo>,
48}
49
50impl crate::Response for Response {}
51
52/// Listener information
53#[derive(Clone, Debug, Deserialize, Serialize)]
54pub struct Listener(String);
55
56impl Display for Listener {
57    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
58        write!(f, "{}", self.0)
59    }
60}
61
62/// Peer information
63#[derive(Clone, Debug, Deserialize, Serialize)]
64pub struct PeerInfo {
65    /// Node information
66    pub node_info: node::Info,
67
68    /// Is this an outbound connection?
69    pub is_outbound: bool,
70
71    /// Connection status
72    pub connection_status: ConnectionStatus,
73
74    /// Remote IP address
75    pub remote_ip: IpAddr,
76}
77
78/// Connection status information
79#[derive(Clone, Debug, Deserialize, Serialize)]
80pub struct ConnectionStatus {
81    /// Duration of this connection
82    #[serde(rename = "Duration", with = "serializers::time_duration")]
83    pub duration: Duration,
84
85    /// Send monitor
86    #[serde(rename = "SendMonitor")]
87    pub send_monitor: Monitor,
88
89    /// Receive monitor
90    #[serde(rename = "RecvMonitor")]
91    pub recv_monitor: Monitor,
92
93    /// Channels
94    #[serde(rename = "Channels")]
95    pub channels: Vec<Channel>,
96}
97
98/// Monitor
99#[derive(Clone, Debug, Deserialize, Serialize)]
100pub struct Monitor {
101    /// Is this monitor active?
102    #[serde(rename = "Active")]
103    pub active: bool,
104
105    /// When the monitor started
106    #[serde(rename = "Start")]
107    pub start: Time,
108
109    /// Duration of this monitor
110    #[serde(rename = "Duration", with = "serializers::time_duration")]
111    pub duration: Duration,
112
113    /// Idle duration for this monitor
114    #[serde(rename = "Idle", with = "serializers::time_duration")]
115    pub idle: Duration,
116
117    /// Bytes
118    #[serde(rename = "Bytes", with = "serializers::from_str")]
119    pub bytes: u64,
120
121    /// Samples
122    #[serde(rename = "Samples", with = "serializers::from_str")]
123    pub samples: u64,
124
125    /// Instant rate
126    #[serde(rename = "InstRate", with = "serializers::from_str")]
127    pub inst_rate: u64,
128
129    /// Current rate
130    #[serde(rename = "CurRate", with = "serializers::from_str")]
131    pub cur_rate: u64,
132
133    /// Average rate
134    #[serde(rename = "AvgRate", with = "serializers::from_str")]
135    pub avg_rate: u64,
136
137    /// Peak rate
138    #[serde(rename = "PeakRate", with = "serializers::from_str")]
139    pub peak_rate: u64,
140
141    /// Bytes remaining
142    #[serde(rename = "BytesRem", with = "serializers::from_str")]
143    pub bytes_rem: u64,
144
145    /// Time remaining
146    #[serde(rename = "TimeRem", with = "serializers::from_str")]
147    pub time_rem: u64,
148
149    /// Progress
150    #[serde(rename = "Progress")]
151    pub progress: u64,
152}