Make net_recentNetworkUsage show the destination address

And this patch changes the way to show the extension name.
Currently, the key is one of the extension name, "::handshake" and
"::negotiation".
But this patch changes the key to be one of "handshake@{socket address}",
"negotiation@{socket address}" and "::{extension name}@{socket address}.

Author: Seulgi Kim

codechain/dummy_network_service.rs

@@ -107,7 +107,7 @@ impl NetworkControl for DummyNetworkService {
         Err(NetworkControlError::Disabled)
     }
 
-    fn recent_network_usage(&self) -> Result<HashMap<&'static str, usize>, NetworkControlError> {
+    fn recent_network_usage(&self) -> Result<HashMap<String, usize>, NetworkControlError> {
         Err(NetworkControlError::Disabled)
     }
 }

network/src/control.rs

@@ -49,7 +49,7 @@ pub trait Control: Send + Sync {
     fn get_whitelist(&self) -> Result<(Vec<FilterEntry>, bool), Error>;
     fn get_blacklist(&self) -> Result<(Vec<FilterEntry>, bool), Error>;
 
-    fn recent_network_usage(&self) -> Result<HashMap<&'static str, usize>, Error>;
+    fn recent_network_usage(&self) -> Result<HashMap<String, usize>, Error>;
 }
 
 #[derive(Clone, Debug)]

network/src/p2p/handler.rs

@@ -111,7 +111,7 @@ pub struct Handler {
 
     bootstrap_addresses: Vec<SocketAddr>,
 
-    network_usage_in_10_seconds: Mutex<HashMap<&'static str, VecDeque<(Instant, usize)>>>,
+    network_usage_in_10_seconds: Mutex<HashMap<String, VecDeque<(Instant, usize)>>>,
 
     min_peers: usize,
     max_peers: usize,
@@ -233,15 +233,15 @@ impl Handler {
         Ok(())
     }
 
-    pub fn recent_network_usage(&self) -> HashMap<&'static str, usize> {
+    pub fn recent_network_usage(&self) -> HashMap<String, usize> {
         let mut network_usage_in_10_seconds = self.network_usage_in_10_seconds.lock();
         let mut result = HashMap::with_capacity(network_usage_in_10_seconds.len());
         let now = Instant::now();
         for (name, times) in &mut *network_usage_in_10_seconds {
             remove_outdated_network_usage(times, &now);
             let total = times.iter().map(|(_, usage)| usage).sum();
             if total != 0 {
-                result.insert(*name, total);
+                result.insert(name.clone(), total);
             }
         }
         result
@@ -387,7 +387,7 @@ impl IoHandler<Message> for Handler {
                     {
                         let mut network_usage_in_10_seconds = self.network_usage_in_10_seconds.lock();
                         insert_network_usage(
-                            network_usage_in_10_seconds.entry("::handshake").or_default(),
+                            network_usage_in_10_seconds.entry(format!("handshake@{}", target)).or_default(),
                             network_message_size,
                         );
                     }
@@ -429,14 +429,18 @@ impl IoHandler<Message> for Handler {
             } => {
                 let stream =
                     *self.remote_node_ids_reverse.read().get(&node_id).ok_or_else(|| Error::InvalidNode(node_id))?;
-                let network_message_size = match stream {
+                let (network_message_size, peer_addr) = match stream {
                     FIRST_OUTBOUND...LAST_OUTBOUND => {
                         let mut outbound_connections = self.outbound_connections.write();
                         if let Some(con) = outbound_connections.get_mut(&stream) {
                             let _f = finally(|| {
                                 io.update_registration(stream);
                             });
-                            con.enqueue_extension_message(extension_name.to_string(), need_encryption, data)?
+
+                            (
+                                con.enqueue_extension_message(extension_name.to_string(), need_encryption, data)?,
+                                *con.peer_addr(),
+                            )
                         } else {
                             return Err(format!("{} is an invalid stream", stream).into())
                         }
@@ -447,7 +451,10 @@ impl IoHandler<Message> for Handler {
                             let _f = finally(|| {
                                 io.update_registration(stream);
                             });
-                            con.enqueue_extension_message(extension_name.to_string(), need_encryption, data)?
+                            (
+                                con.enqueue_extension_message(extension_name.to_string(), need_encryption, data)?,
+                                *con.peer_addr(),
+                            )
                         } else {
                             return Err(format!("{} is an invalid stream", stream).into())
                         }
@@ -456,7 +463,7 @@ impl IoHandler<Message> for Handler {
                 };
                 let mut network_usage_in_10_seconds = self.network_usage_in_10_seconds.lock();
                 insert_network_usage(
-                    network_usage_in_10_seconds.entry(extension_name).or_default(),
+                    network_usage_in_10_seconds.entry(format!("::{}@{}", extension_name, peer_addr)).or_default(),
                     network_message_size,
                 );
             }
@@ -540,7 +547,7 @@ impl IoHandler<Message> for Handler {
                     {
                         let mut network_usage_in_10_seconds = self.network_usage_in_10_seconds.lock();
                         insert_network_usage(
-                            network_usage_in_10_seconds.entry("::negotiation").or_default(),
+                            network_usage_in_10_seconds.entry(format!("negotiation@{}", peer_addr)).or_default(),
                             network_message_size,
                         );
                     }
@@ -684,7 +691,9 @@ impl IoHandler<Message> for Handler {
                             let network_message_size = con.enqueue_negotiation_response(extension_name, version);
                             let mut network_usage_in_10_seconds = self.network_usage_in_10_seconds.lock();
                             insert_network_usage(
-                                network_usage_in_10_seconds.entry("::negotiation").or_default(),
+                                network_usage_in_10_seconds
+                                    .entry(format!("negotiation@{}", con.peer_addr()))
+                                    .or_default(),
                                 network_message_size,
                             );
                         }
@@ -795,7 +804,7 @@ impl IoHandler<Message> for Handler {
                             };
                             let mut network_usage_in_10_seconds = self.network_usage_in_10_seconds.lock();
                             insert_network_usage(
-                                network_usage_in_10_seconds.entry("::handshake").or_default(),
+                                network_usage_in_10_seconds.entry(format!("handshake@{}", from)).or_default(),
                                 network_message_size,
                             );
                         }
@@ -834,7 +843,7 @@ impl IoHandler<Message> for Handler {
                             };
                             let mut network_usage_in_10_seconds = self.network_usage_in_10_seconds.lock();
                             insert_network_usage(
-                                network_usage_in_10_seconds.entry("::handshake").or_default(),
+                                network_usage_in_10_seconds.entry(format!("handshake@{}", from)).or_default(),
                                 network_message_size,
                             );
                         }

network/src/service.rs

@@ -198,7 +198,7 @@ impl Control for Service {
         Ok(self.filters_control.get_blacklist())
     }
 
-    fn recent_network_usage(&self) -> Result<HashMap<&'static str, usize>, ControlError> {
+    fn recent_network_usage(&self) -> Result<HashMap<String, usize>, ControlError> {
         Ok(self.p2p_handler.recent_network_usage())
     }
 }

rpc/src/v1/impls/net.rs

@@ -128,7 +128,7 @@ impl Net for NetClient {
         })
     }
 
-    fn recent_network_usage(&self) -> Result<HashMap<&'static str, usize>> {
+    fn recent_network_usage(&self) -> Result<HashMap<String, usize>> {
         Ok(self.network_control.recent_network_usage().map_err(|e| errors::network_control(&e))?)
     }
 }

rpc/src/v1/traits/net.rs

@@ -80,6 +80,6 @@ build_rpc_trait! {
         fn get_blacklist(&self) -> Result<FilterStatus>;
 
         #[rpc(name = "net_recentNetworkUsage")]
-        fn recent_network_usage(&self) -> Result<HashMap<&'static str, usize>>;
+        fn recent_network_usage(&self) -> Result<HashMap<String, usize>>;
     }
 }