rename disconnect_peer to drop_peer in low-level

substrate/network-libp2p/src/network_state.rs

@@ -126,6 +126,45 @@ struct PeerConnectionInfo {
 	local_address: Option<Multiaddr>,
 }
 
+/// Simplified, POD version of PeerConnectionInfo.
+#[derive(Debug, Clone)]
+pub struct PeerInfo {
+	/// Id of the peer.
+	pub id: PeerstorePeerId,
+
+	/// True if this connection was initiated by us.
+	/// Note that it is theoretically possible that we dial the remote at the
+	/// same time they dial us, in which case the protocols may be dispatched
+	/// between both connections, and in which case the value here will be racy.
+	pub originated: bool,
+
+	/// Latest known ping duration.
+	pub ping: Option<Duration>,
+
+	/// The client version of the remote, or `None` if not known.
+	pub client_version: Option<String>,
+
+	/// The multiaddress of the remote, or `None` if not known.
+	pub remote_address: Option<Multiaddr>,
+
+	/// The local multiaddress used to communicate with the remote, or `None`
+	/// if not known.
+	pub local_address: Option<Multiaddr>,
+}
+
+impl<'a> From<&'a PeerConnectionInfo> for PeerInfo {
+	fn from(i: &'a PeerConnectionInfo) -> PeerInfo {
+		PeerInfo {
+			id: i.id.clone(),
+			originated: i.originated,
+			ping: i.ping.lock().clone(),
+			client_version: i.client_version.clone(),
+			remote_address: i.remote_address.clone(),
+			local_address: i.local_address.clone(),
+		}
+	}
+}
+
 impl NetworkState {
 	pub fn new(config: &NetworkConfiguration) -> Result<NetworkState, Error> {
 		// Private and public keys configuration.
@@ -593,16 +632,23 @@ impl NetworkState {
 		}
 	}
 
+	/// Get the info on a peer, if there's an active connection.
+	pub fn peer_info(&self, who: PeerId) -> Option<PeerInfo> {
+		self.connections.read().info_by_peer.get(&who).map(Into::into)
+	}
+
 	/// Disconnects a peer, if a connection exists (ie. drops the Kademlia
 	/// controller, and the senders that were stored in the `UniqueConnec` of
 	/// `custom_proto`).
-	pub fn disconnect_peer(&self, peer_id: PeerId, reason: &str) {
+	pub fn drop_peer(&self, peer_id: PeerId, reason: Option<&str>) {
 		let mut connections = self.connections.write();
 		if let Some(peer_info) = connections.info_by_peer.remove(&peer_id) {
-			if let (&Some(ref client_version), &Some(ref remote_address)) = (&peer_info.client_version, &peer_info.remote_address) {
-				info!(target: "network", "Disconnected peer {} (version: {}, address: {}). {}", peer_id, client_version, remote_address, reason);
-			} else {
-				info!(target: "network", "Disconnected peer {}. {}", peer_id, reason);
+			if let Some(reason) = reason {
+				if let (&Some(ref client_version), &Some(ref remote_address)) = (&peer_info.client_version, &peer_info.remote_address) {
+					debug!(target: "sub-libp2p", "Disconnected peer {} (version: {}, address: {}). {}", peer_id, client_version, remote_address, reason);
+				} else {
+					debug!(target: "sub-libp2p", "Disconnected peer {}. {}", peer_id, reason);
+				}
 			}
 
 			trace!(target: "sub-libp2p", "Destroying peer #{} {:?} ; \

substrate/network-libp2p/src/service.rs

@@ -318,7 +318,7 @@ impl NetworkContext for NetworkContextImpl {
 		message.extend_from_slice(&[packet_id]);
 		message.extend_from_slice(&data);
 		if self.inner.network_state.send(protocol, peer, message).is_err() {
-			self.inner.network_state.disconnect_peer(peer, "Sending to peer failed");
+			self.inner.network_state.drop_peer(peer, Some("Sending to peer failed"));
 		}
 	}
 
@@ -331,11 +331,17 @@ impl NetworkContext for NetworkContextImpl {
 	}
 
 	fn report_peer(&self, peer: PeerId, reason: Severity) {
-		debug!(target: "sub-libp2p", "Peer {} reported by client: {}", peer, reason);
+		if let Some(info) = self.inner.network_state.peer_info(peer) {
+			if let (Some(client_version), Some(remote_address)) = (info.client_version, info.remote_address) {
+				info!(target: "sub-libp2p", "Peer {} ({} {}) reported by client: {}", peer, remote_address, client_version, reason);
+			} else {
+				info!(target: "sub-libp2p", "Peer {} reported by client: {}", peer, reason);
+			}
+		}
 		match reason {
 			Severity::Bad(reason) => self.inner.network_state.disable_peer(peer, reason),
-			Severity::Useless(reason) => self.inner.network_state.disconnect_peer(peer, reason),
-			Severity::Timeout => self.inner.network_state.disconnect_peer(peer, "Timeout waiting for response"),
+			Severity::Useless(reason) => self.inner.network_state.drop_peer(peer, Some(reason)),
+			Severity::Timeout => self.inner.network_state.drop_peer(peer, Some("Timeout waiting for response")),
 		}
 	}
 
@@ -782,7 +788,7 @@ fn handle_custom_connection(
 
 			// When any custom protocol drops, we drop the peer entirely.
 			// TODO: is this correct?
-			self.inner.network_state.disconnect_peer(self.peer_id, "Remote end disconnected");
+			self.inner.network_state.drop_peer(self.peer_id, Some("Remote end disconnected"));
 		}
 	}
 
@@ -1285,7 +1291,7 @@ fn ping_all<T, St, C>(
 				match val {
 					Err(err) => {
 						trace!(target: "sub-libp2p", "Error while pinging #{:?} => {:?}", peer, err);
-						shared.network_state.disconnect_peer(peer, "libp2p ping timeout");
+						shared.network_state.drop_peer(peer, None);	// None so that we don't print messages on such low-level issues.
 						// Return Ok, otherwise we would close the ping service
 						Ok(())
 					},