Show a node's network usage

server/src/common_rpc_types.rs

@@ -133,6 +133,22 @@ pub struct GraphNetworkOutAllRow {
 
 pub type GraphNetworkOutAllAVGRow = GraphNetworkOutAllRow;
 
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GraphNetworkOutNodeExtensionRow {
+    pub extension: String,
+    pub time: DateTime<Utc>,
+    pub value: f32,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GraphNetworkOutNodePeerRow {
+    pub peer: String,
+    pub time: DateTime<Utc>,
+    pub value: f32,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

server/src/db/queries/network_usage_graph.rs

@@ -1,4 +1,7 @@
-use common_rpc_types::{GraphCommonArgs, GraphNetworkOutAllRow, GraphPeriod};
+use common_rpc_types::{
+    GraphCommonArgs, GraphNetworkOutAllRow, GraphNetworkOutNodeExtensionRow, GraphNetworkOutNodePeerRow, GraphPeriod,
+    NodeName,
+};
 use postgres;
 
 pub fn query_network_out_all(
@@ -69,3 +72,65 @@ pub fn query_network_out_all_avg(
         })
         .collect())
 }
+
+pub fn query_network_out_node_extension(
+    conn: &postgres::Connection,
+    node_name: NodeName,
+    graph_args: GraphCommonArgs,
+) -> postgres::Result<Vec<GraphNetworkOutNodeExtensionRow>> {
+    let query_stmt = format!(
+        "\
+         SELECT \
+         extension, \
+         {}, \
+         CAST (AVG(bytes) AS REAL) as value \
+         FROM \"network_usage\" \
+         WHERE \"network_usage\".\"time\"<$1 AND \"network_usage\".\"time\">$2 \
+           AND \"network_usage\".\"name\"=$3
+         GROUP BY \"network_usage\".\"extension\", \"rounded_time\" \
+         ORDER BY \"network_usage\".\"extension\", \"rounded_time\" ASC",
+        get_sql_round_period_expression(graph_args.period)
+    );
+
+    let rows = conn.query(&query_stmt, &[&graph_args.to, &graph_args.from, &node_name])?;
+
+    Ok(rows
+        .into_iter()
+        .map(|row| GraphNetworkOutNodeExtensionRow {
+            extension: row.get("extension"),
+            time: row.get("rounded_time"),
+            value: row.get("value"),
+        })
+        .collect())
+}
+
+pub fn query_network_out_node_peer(
+    conn: &postgres::Connection,
+    node_name: NodeName,
+    graph_args: GraphCommonArgs,
+) -> postgres::Result<Vec<GraphNetworkOutNodePeerRow>> {
+    let query_stmt = format!(
+        "\
+         SELECT \
+         \"target_ip\", \
+         {}, \
+         CAST (AVG(bytes) AS REAL) as value \
+         FROM \"network_usage\" \
+         WHERE \"network_usage\".\"time\"<$1 AND \"network_usage\".\"time\">$2 \
+           AND \"network_usage\".\"name\"=$3
+         GROUP BY \"network_usage\".\"target_ip\", \"rounded_time\" \
+         ORDER BY \"network_usage\".\"target_ip\", \"rounded_time\" ASC",
+        get_sql_round_period_expression(graph_args.period)
+    );
+
+    let rows = conn.query(&query_stmt, &[&graph_args.to, &graph_args.from, &node_name])?;
+
+    Ok(rows
+        .into_iter()
+        .map(|row| GraphNetworkOutNodePeerRow {
+            peer: row.get("target_ip"),
+            time: row.get("rounded_time"),
+            value: row.get("value"),
+        })
+        .collect())
+}

server/src/db/service.rs

@@ -13,7 +13,10 @@ use super::super::common_rpc_types::{NodeName, NodeStatus, StructuredLog};
 use super::event::{Event, EventSubscriber};
 use super::queries;
 use super::types::{AgentExtra, AgentQueryResult, Connection, Connections, Error as DBError, Log, LogQueryParams};
-use common_rpc_types::{GraphCommonArgs, GraphNetworkOutAllAVGRow, GraphNetworkOutAllRow, NetworkUsage};
+use common_rpc_types::{
+    GraphCommonArgs, GraphNetworkOutAllAVGRow, GraphNetworkOutAllRow, GraphNetworkOutNodeExtensionRow,
+    GraphNetworkOutNodePeerRow, NetworkUsage,
+};
 use util;
 
 #[derive(Debug, Clone)]
@@ -32,6 +35,12 @@ pub enum Message {
     WritePeerCount(NodeName, i32, chrono::DateTime<chrono::Utc>),
     GetGraphNetworkOutAll(GraphCommonArgs, Sender<Result<Vec<GraphNetworkOutAllRow>, DBError>>),
     GetGraphNetworkOutAllAVG(GraphCommonArgs, Sender<Result<Vec<GraphNetworkOutAllAVGRow>, DBError>>),
+    GetGraphNetworkOutNodeExtension(
+        NodeName,
+        GraphCommonArgs,
+        Sender<Result<Vec<GraphNetworkOutNodeExtensionRow>, DBError>>,
+    ),
+    GetGraphNetworkOutNodePeer(NodeName, GraphCommonArgs, Sender<Result<Vec<GraphNetworkOutNodePeerRow>, DBError>>),
 }
 
 #[derive(Clone)]
@@ -77,6 +86,7 @@ impl Service {
         }
     }
 
+    #[allow(clippy::cognitive_complexity)]
     pub fn run_thread(arg: ServiceNewArg) -> ServiceSender {
         let (tx, rx) = channel();
         let service_sender = ServiceSender::new(tx);
@@ -149,6 +159,22 @@ impl Service {
                                 cerror!("Error at {}", callback_err);
                             }
                         }
+                        Message::GetGraphNetworkOutNodeExtension(node_name, args, callback) => {
+                            let result = service
+                                .get_network_out_node_extension_graph(node_name, args)
+                                .map_err(|err| DBError::Internal(err.to_string()));
+                            if let Err(callback_err) = callback.send(result) {
+                                cerror!("Error at {}", callback_err);
+                            }
+                        }
+                        Message::GetGraphNetworkOutNodePeer(node_name, args, callback) => {
+                            let result = service
+                                .get_network_out_node_peer_graph(node_name, args)
+                                .map_err(|err| DBError::Internal(err.to_string()));
+                            if let Err(callback_err) = callback.send(result) {
+                                cerror!("Error at {}", callback_err);
+                            }
+                        }
                     }
                 }
             })
@@ -339,6 +365,24 @@ impl Service {
         let rows = queries::network_usage_graph::query_network_out_all_avg(&self.db_conn, args)?;
         Ok(rows)
     }
+
+    fn get_network_out_node_extension_graph(
+        &self,
+        node_name: NodeName,
+        args: GraphCommonArgs,
+    ) -> Result<Vec<GraphNetworkOutNodeExtensionRow>, Box<error::Error>> {
+        let rows = queries::network_usage_graph::query_network_out_node_extension(&self.db_conn, node_name, args)?;
+        Ok(rows)
+    }
+
+    fn get_network_out_node_peer_graph(
+        &self,
+        node_name: NodeName,
+        args: GraphCommonArgs,
+    ) -> Result<Vec<GraphNetworkOutNodePeerRow>, Box<error::Error>> {
+        let rows = queries::network_usage_graph::query_network_out_node_peer(&self.db_conn, node_name, args)?;
+        Ok(rows)
+    }
 }
 
 impl ServiceSender {
@@ -440,4 +484,28 @@ impl ServiceSender {
         self.sender.send(Message::GetGraphNetworkOutAllAVG(args, tx)).expect("Should success send request");
         rx.recv()?
     }
+
+    pub fn get_network_out_node_extension_graph(
+        &self,
+        node_name: NodeName,
+        args: GraphCommonArgs,
+    ) -> Result<Vec<GraphNetworkOutNodeExtensionRow>, DBError> {
+        let (tx, rx) = channel();
+        self.sender
+            .send(Message::GetGraphNetworkOutNodeExtension(node_name, args, tx))
+            .expect("should success send request");
+        rx.recv()?
+    }
+
+    pub fn get_network_out_node_peer_graph(
+        &self,
+        node_name: NodeName,
+        args: GraphCommonArgs,
+    ) -> Result<Vec<GraphNetworkOutNodePeerRow>, DBError> {
+        let (tx, rx) = channel();
+        self.sender
+            .send(Message::GetGraphNetworkOutNodePeer(node_name, args, tx))
+            .expect("Should success send request");
+        rx.recv()?
+    }
 }

server/src/frontend/api.rs

@@ -4,7 +4,8 @@ use super::super::router::Router;
 use super::super::rpc::{response, RPCError, RPCResponse};
 use super::types::{
     Context, DashboardGetNetworkResponse, DashboardNode, GraphNetworkOutAllAVGResponse, GraphNetworkOutAllResponse,
-    LogGetRequest, LogGetResponse, LogGetTargetsResponse, NodeConnection, NodeGetInfoResponse,
+    GraphNetworkOutNodeExtensionResponse, GraphNetworkOutNodePeerResponse, LogGetRequest, LogGetResponse,
+    LogGetTargetsResponse, NodeConnection, NodeGetInfoResponse,
 };
 use common_rpc_types::{GraphCommonArgs, UpdateCodeChainRequest};
 
@@ -42,6 +43,20 @@ pub fn add_routing(router: &mut Router<Context>) {
                 as fn(Context, (GraphCommonArgs,)) -> RPCResponse<GraphNetworkOutAllAVGResponse>,
         ),
     );
+    router.add_route(
+        "graph_network_out_node_extension",
+        Box::new(
+            graph_network_out_node_extension
+                as fn(Context, (NodeName, GraphCommonArgs)) -> RPCResponse<GraphNetworkOutNodeExtensionResponse>,
+        ),
+    );
+    router.add_route(
+        "graph_network_out_node_peer",
+        Box::new(
+            graph_network_out_node_peer
+                as fn(Context, (NodeName, GraphCommonArgs)) -> RPCResponse<GraphNetworkOutNodePeerResponse>,
+        ),
+    );
 }
 
 fn ping(_: Context) -> RPCResponse<String> {
@@ -146,3 +161,27 @@ fn graph_network_out_all_node_avg(
         rows,
     })
 }
+
+fn graph_network_out_node_extension(
+    context: Context,
+    args: (NodeName, GraphCommonArgs),
+) -> RPCResponse<GraphNetworkOutNodeExtensionResponse> {
+    let (node_name, graph_args) = args;
+
+    let rows = context.db_service.get_network_out_node_extension_graph(node_name, graph_args)?;
+    response(GraphNetworkOutNodeExtensionResponse {
+        rows,
+    })
+}
+
+fn graph_network_out_node_peer(
+    context: Context,
+    args: (NodeName, GraphCommonArgs),
+) -> RPCResponse<GraphNetworkOutNodePeerResponse> {
+    let (node_name, graph_args) = args;
+
+    let rows = context.db_service.get_network_out_node_peer_graph(node_name, graph_args)?;
+    response(GraphNetworkOutNodePeerResponse {
+        rows,
+    })
+}

server/src/frontend/types.rs

@@ -3,8 +3,9 @@ use std::net::SocketAddr;
 use super::super::agent;
 use super::super::common_rpc_types;
 use super::super::common_rpc_types::{
-    BlackList, BlockId, GraphNetworkOutAllAVGRow, GraphNetworkOutAllRow, HardwareInfo, HardwareUsage, NodeName,
-    NodeStatus, NodeVersion, PendingTransaction, WhiteList,
+    BlackList, BlockId, GraphNetworkOutAllAVGRow, GraphNetworkOutAllRow, GraphNetworkOutNodeExtensionRow,
+    GraphNetworkOutNodePeerRow, HardwareInfo, HardwareUsage, NodeName, NodeStatus, NodeVersion, PendingTransaction,
+    WhiteList,
 };
 use super::super::db;
 
@@ -186,3 +187,15 @@ pub struct GraphNetworkOutAllResponse {
 pub struct GraphNetworkOutAllAVGResponse {
     pub rows: Vec<GraphNetworkOutAllAVGRow>,
 }
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GraphNetworkOutNodeExtensionResponse {
+    pub rows: Vec<GraphNetworkOutNodeExtensionRow>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GraphNetworkOutNodePeerResponse {
+    pub rows: Vec<GraphNetworkOutNodePeerRow>,
+}