Support querying peer reputation (paritytech#2392)

# Description

Trivial change that resolves
paritytech#2185.

Since there was a mix of `who` and `peer_id` argument names nearby I
changed them all to `peer_id`.

# Checklist

- [x] My PR includes a detailed description as outlined in the
"Description" section above
- [x] My PR follows the [labeling requirements](CONTRIBUTING.md#Process)
of this project (at minimum one label for `T`
  required)
- [x] I have made corresponding changes to the documentation (if
applicable)
- [ ] I have added tests that prove my fix is effective or that my
feature works (if applicable)

---------

Co-authored-by: Bastian Köcher <[email protected]>

substrate/client/consensus/grandpa/src/communication/tests.rs

@@ -76,11 +76,15 @@ impl NetworkPeers for TestNetwork {
 		unimplemented!();
 	}
 
-	fn report_peer(&self, who: PeerId, cost_benefit: ReputationChange) {
-		let _ = self.sender.unbounded_send(Event::Report(who, cost_benefit));
+	fn report_peer(&self, peer_id: PeerId, cost_benefit: ReputationChange) {
+		let _ = self.sender.unbounded_send(Event::Report(peer_id, cost_benefit));
 	}
 
-	fn disconnect_peer(&self, _who: PeerId, _protocol: ProtocolName) {}
+	fn peer_reputation(&self, _peer_id: &PeerId) -> i32 {
+		unimplemented!()
+	}
+
+	fn disconnect_peer(&self, _peer_id: PeerId, _protocol: ProtocolName) {}
 
 	fn accept_unreserved_peers(&self) {
 		unimplemented!();

substrate/client/network-gossip/src/bridge.rs

@@ -372,9 +372,13 @@ mod tests {
 			unimplemented!();
 		}
 
-		fn report_peer(&self, _who: PeerId, _cost_benefit: ReputationChange) {}
+		fn report_peer(&self, _peer_id: PeerId, _cost_benefit: ReputationChange) {}
 
-		fn disconnect_peer(&self, _who: PeerId, _protocol: ProtocolName) {
+		fn peer_reputation(&self, _peer_id: &PeerId) -> i32 {
+			unimplemented!()
+		}
+
+		fn disconnect_peer(&self, _peer_id: PeerId, _protocol: ProtocolName) {
 			unimplemented!();
 		}
 

substrate/client/network-gossip/src/state_machine.rs

@@ -600,11 +600,15 @@ mod tests {
 			unimplemented!();
 		}
 
-		fn report_peer(&self, who: PeerId, cost_benefit: ReputationChange) {
-			self.inner.lock().unwrap().peer_reports.push((who, cost_benefit));
+		fn report_peer(&self, peer_id: PeerId, cost_benefit: ReputationChange) {
+			self.inner.lock().unwrap().peer_reports.push((peer_id, cost_benefit));
 		}
 
-		fn disconnect_peer(&self, _who: PeerId, _protocol: ProtocolName) {
+		fn peer_reputation(&self, _peer_id: &PeerId) -> i32 {
+			unimplemented!()
+		}
+
+		fn disconnect_peer(&self, _peer_id: PeerId, _protocol: ProtocolName) {
 			unimplemented!();
 		}
 

substrate/client/network/src/service.rs

@@ -116,6 +116,8 @@ pub struct NetworkService<B: BlockT + 'static, H: ExHashT> {
 	local_identity: Keypair,
 	/// Bandwidth logging system. Can be queried to know the average bandwidth consumed.
 	bandwidth: Arc<transport::BandwidthSinks>,
+	/// Used to query and report reputation changes.
+	peer_store_handle: PeerStoreHandle,
 	/// Channel that sends messages to the actual worker.
 	to_worker: TracingUnboundedSender<ServiceToWorkerMsg>,
 	/// For each peer and protocol combination, an object that allows sending notifications to
@@ -871,12 +873,18 @@ where
 			.unbounded_send(ServiceToWorkerMsg::AddKnownAddress(peer_id, addr));
 	}
 
-	fn report_peer(&self, who: PeerId, cost_benefit: ReputationChange) {
-		let _ = self.to_worker.unbounded_send(ServiceToWorkerMsg::ReportPeer(who, cost_benefit));
+	fn report_peer(&self, peer_id: PeerId, cost_benefit: ReputationChange) {
+		self.peer_store_handle.clone().report_peer(peer_id, cost_benefit);
+	}
+
+	fn peer_reputation(&self, peer_id: &PeerId) -> i32 {
+		self.peer_store_handle.peer_reputation(peer_id)
 	}
 
-	fn disconnect_peer(&self, who: PeerId, protocol: ProtocolName) {
-		let _ = self.to_worker.unbounded_send(ServiceToWorkerMsg::DisconnectPeer(who, protocol));
+	fn disconnect_peer(&self, peer_id: PeerId, protocol: ProtocolName) {
+		let _ = self
+			.to_worker
+			.unbounded_send(ServiceToWorkerMsg::DisconnectPeer(peer_id, protocol));
 	}
 
 	fn accept_unreserved_peers(&self) {
@@ -1193,7 +1201,6 @@ enum ServiceToWorkerMsg {
 	GetValue(KademliaKey),
 	PutValue(KademliaKey, Vec<u8>),
 	AddKnownAddress(PeerId, Multiaddr),
-	ReportPeer(PeerId, ReputationChange),
 	EventStream(out_events::Sender),
 	Request {
 		target: PeerId,
@@ -1324,8 +1331,6 @@ where
 				self.network_service.behaviour_mut().put_value(key, value),
 			ServiceToWorkerMsg::AddKnownAddress(peer_id, addr) =>
 				self.network_service.behaviour_mut().add_known_address(peer_id, addr),
-			ServiceToWorkerMsg::ReportPeer(peer_id, reputation_change) =>
-				self.peer_store_handle.report_peer(peer_id, reputation_change),
 			ServiceToWorkerMsg::EventStream(sender) => self.event_streams.push(sender),
 			ServiceToWorkerMsg::Request {
 				target,

substrate/client/network/src/service/traits.rs

@@ -150,12 +150,15 @@ pub trait NetworkPeers {
 
 	/// Report a given peer as either beneficial (+) or costly (-) according to the
 	/// given scalar.
-	fn report_peer(&self, who: PeerId, cost_benefit: ReputationChange);
+	fn report_peer(&self, peer_id: PeerId, cost_benefit: ReputationChange);
+
+	/// Get peer reputation.
+	fn peer_reputation(&self, peer_id: &PeerId) -> i32;
 
 	/// Disconnect from a node as soon as possible.
 	///
 	/// This triggers the same effects as if the connection had closed itself spontaneously.
-	fn disconnect_peer(&self, who: PeerId, protocol: ProtocolName);
+	fn disconnect_peer(&self, peer_id: PeerId, protocol: ProtocolName);
 
 	/// Connect to unreserved peers and allow unreserved peers to connect for syncing purposes.
 	fn accept_unreserved_peers(&self);
@@ -241,16 +244,16 @@ where
 		T::add_known_address(self, peer_id, addr)
 	}
 
-	fn report_peer(&self, who: PeerId, cost_benefit: ReputationChange) {
-		// TODO: when we get rid of `Peerset`, we'll likely need to add some kind of async
-		// interface to `PeerStore`, otherwise we'll have trouble calling functions accepting
-		// `&mut self` via `Arc`.
-		// See https://github.com/paritytech/substrate/issues/14170.
-		T::report_peer(self, who, cost_benefit)
+	fn report_peer(&self, peer_id: PeerId, cost_benefit: ReputationChange) {
+		T::report_peer(self, peer_id, cost_benefit)
+	}
+
+	fn peer_reputation(&self, peer_id: &PeerId) -> i32 {
+		T::peer_reputation(self, peer_id)
 	}
 
-	fn disconnect_peer(&self, who: PeerId, protocol: ProtocolName) {
-		T::disconnect_peer(self, who, protocol)
+	fn disconnect_peer(&self, peer_id: PeerId, protocol: ProtocolName) {
+		T::disconnect_peer(self, peer_id, protocol)
 	}
 
 	fn accept_unreserved_peers(&self) {

substrate/client/network/sync/src/service/mock.rs

@@ -83,8 +83,9 @@ mockall::mock! {
 		fn set_authorized_peers(&self, peers: HashSet<PeerId>);
 		fn set_authorized_only(&self, reserved_only: bool);
 		fn add_known_address(&self, peer_id: PeerId, addr: Multiaddr);
-		fn report_peer(&self, who: PeerId, cost_benefit: ReputationChange);
-		fn disconnect_peer(&self, who: PeerId, protocol: ProtocolName);
+		fn report_peer(&self, peer_id: PeerId, cost_benefit: ReputationChange);
+		fn peer_reputation(&self, peer_id: &PeerId) -> i32;
+		fn disconnect_peer(&self, peer_id: PeerId, protocol: ProtocolName);
 		fn accept_unreserved_peers(&self);
 		fn deny_unreserved_peers(&self);
 		fn add_reserved_peer(&self, peer: MultiaddrWithPeerId) -> Result<(), String>;

substrate/client/offchain/src/api.rs

@@ -243,11 +243,15 @@ mod tests {
 			unimplemented!();
 		}
 
-		fn report_peer(&self, _who: PeerId, _cost_benefit: ReputationChange) {
+		fn report_peer(&self, _peer_id: PeerId, _cost_benefit: ReputationChange) {
 			unimplemented!();
 		}
 
-		fn disconnect_peer(&self, _who: PeerId, _protocol: ProtocolName) {
+		fn peer_reputation(&self, _peer_id: &PeerId) -> i32 {
+			unimplemented!()
+		}
+
+		fn disconnect_peer(&self, _peer_id: PeerId, _protocol: ProtocolName) {
 			unimplemented!();
 		}
 

substrate/client/offchain/src/lib.rs

@@ -371,11 +371,15 @@ mod tests {
 			unimplemented!();
 		}
 
-		fn report_peer(&self, _who: PeerId, _cost_benefit: ReputationChange) {
+		fn report_peer(&self, _peer_id: PeerId, _cost_benefit: ReputationChange) {
 			unimplemented!();
 		}
 
-		fn disconnect_peer(&self, _who: PeerId, _protocol: ProtocolName) {
+		fn peer_reputation(&self, _peer_id: &PeerId) -> i32 {
+			unimplemented!()
+		}
+
+		fn disconnect_peer(&self, _peer_id: PeerId, _protocol: ProtocolName) {
 			unimplemented!();
 		}