cargo +nightly fmt (#3540)

* cargo +nightly fmt

* add cargo-fmt check to ci

* update ci

* fmt

* fmt

* skip macro

* ignore bridges

polkadot/node/network/bridge/src/lib.rs

@@ -19,48 +19,39 @@
 #![deny(unused_crate_dependencies)]
 #![warn(missing_docs)]
 
-
-use parity_scale_codec::{Encode, Decode};
+use futures::{prelude::*, stream::BoxStream};
+use parity_scale_codec::{Decode, Encode};
 use parking_lot::Mutex;
-use futures::prelude::*;
-use futures::stream::BoxStream;
 use polkadot_subsystem::messages::DisputeDistributionMessage;
 use sc_network::Event as NetworkEvent;
 use sp_consensus::SyncOracle;
 
-use polkadot_overseer::gen::{
-	Subsystem,
-	OverseerError,
-};
-use polkadot_subsystem::{
-	overseer,
-	OverseerSignal,
-	FromOverseer,
-	SpawnedSubsystem,
-	SubsystemContext,
-	SubsystemSender,
-	errors::{SubsystemError, SubsystemResult},
-	ActivatedLeaf, ActiveLeavesUpdate,
-	messages::{
-		AllMessages, StatementDistributionMessage,
-		NetworkBridgeMessage, CollatorProtocolMessage, NetworkBridgeEvent,
-	},
-};
-use polkadot_primitives::v1::{Hash, BlockNumber};
 use polkadot_node_network_protocol::{
-	PeerId, peer_set::PeerSet, View, v1 as protocol_v1, OurView, UnifiedReputationChange as Rep,
-	ObservedRole,
+	peer_set::PeerSet, v1 as protocol_v1, ObservedRole, OurView, PeerId,
+	UnifiedReputationChange as Rep, View,
 };
 use polkadot_node_subsystem_util::metrics::{self, prometheus};
+use polkadot_overseer::gen::{OverseerError, Subsystem};
+use polkadot_primitives::v1::{BlockNumber, Hash};
+use polkadot_subsystem::{
+	errors::{SubsystemError, SubsystemResult},
+	messages::{
+		AllMessages, CollatorProtocolMessage, NetworkBridgeEvent, NetworkBridgeMessage,
+		StatementDistributionMessage,
+	},
+	overseer, ActivatedLeaf, ActiveLeavesUpdate, FromOverseer, OverseerSignal, SpawnedSubsystem,
+	SubsystemContext, SubsystemSender,
+};
 
 /// Peer set info for network initialization.
 ///
 /// To be added to [`NetworkConfiguration::extra_sets`].
 pub use polkadot_node_network_protocol::peer_set::{peer_sets_info, IsAuthority};
 
-use std::collections::HashSet;
-use std::collections::{HashMap, hash_map};
-use std::sync::Arc;
+use std::{
+	collections::{hash_map, HashMap, HashSet},
+	sync::Arc,
+};
 
 mod validator_discovery;
 
@@ -68,7 +59,7 @@ mod validator_discovery;
 ///
 /// Defines the `Network` trait with an implementation for an `Arc<NetworkService>`.
 mod network;
-use network::{Network, send_message};
+use network::{send_message, Network};
 
 /// Request multiplexer for combining the multiple request sources into a single `Stream` of `AllMessages`.
 mod multiplexer;
@@ -84,7 +75,6 @@ mod tests;
 /// We use the same limit to compute the view sent to peers locally.
 const MAX_VIEW_HEADS: usize = 5;
 
-
 const MALFORMED_MESSAGE_COST: Rep = Rep::CostMajor("Malformed Network-bridge message");
 const UNCONNECTED_PEERSET_COST: Rep = Rep::CostMinor("Message sent to un-connected peer-set");
 const MALFORMED_VIEW_COST: Rep = Rep::CostMajor("Malformed view");
@@ -99,36 +89,41 @@ pub struct Metrics(Option<MetricsInner>);
 
 impl Metrics {
 	fn on_peer_connected(&self, peer_set: PeerSet) {
-		self.0.as_ref().map(|metrics| metrics
-			.connected_events
-			.with_label_values(&[peer_set.get_protocol_name_static()])
-			.inc()
-		);
+		self.0.as_ref().map(|metrics| {
+			metrics
+				.connected_events
+				.with_label_values(&[peer_set.get_protocol_name_static()])
+				.inc()
+		});
 	}
 
 	fn on_peer_disconnected(&self, peer_set: PeerSet) {
-		self.0.as_ref().map(|metrics| metrics
-			.disconnected_events
-			.with_label_values(&[peer_set.get_protocol_name_static()])
-			.inc()
-		);
+		self.0.as_ref().map(|metrics| {
+			metrics
+				.disconnected_events
+				.with_label_values(&[peer_set.get_protocol_name_static()])
+				.inc()
+		});
 	}
 
 	fn note_peer_count(&self, peer_set: PeerSet, count: usize) {
-		self.0.as_ref().map(|metrics| metrics
-			.peer_count
-			.with_label_values(&[peer_set.get_protocol_name_static()])
-			.set(count as u64)
-		);
+		self.0.as_ref().map(|metrics| {
+			metrics
+				.peer_count
+				.with_label_values(&[peer_set.get_protocol_name_static()])
+				.set(count as u64)
+		});
 	}
 
 	fn on_notification_received(&self, peer_set: PeerSet, size: usize) {
 		if let Some(metrics) = self.0.as_ref() {
-			metrics.notifications_received
+			metrics
+				.notifications_received
 				.with_label_values(&[peer_set.get_protocol_name_static()])
 				.inc();
 
-			metrics.bytes_received
+			metrics
+				.bytes_received
 				.with_label_values(&[peer_set.get_protocol_name_static()])
 				.inc_by(size as u64);
 		}
@@ -136,22 +131,25 @@ impl Metrics {
 
 	fn on_notification_sent(&self, peer_set: PeerSet, size: usize, to_peers: usize) {
 		if let Some(metrics) = self.0.as_ref() {
-			metrics.notifications_sent
+			metrics
+				.notifications_sent
 				.with_label_values(&[peer_set.get_protocol_name_static()])
 				.inc_by(to_peers as u64);
 
-			metrics.bytes_sent
+			metrics
+				.bytes_sent
 				.with_label_values(&[peer_set.get_protocol_name_static()])
 				.inc_by((size * to_peers) as u64);
 		}
 	}
 
 	fn note_desired_peer_count(&self, peer_set: PeerSet, size: usize) {
-		self.0.as_ref().map(|metrics| metrics
-			.desired_peer_count
-			.with_label_values(&[peer_set.get_protocol_name_static()])
-			.set(size as u64)
-		);
+		self.0.as_ref().map(|metrics| {
+			metrics
+				.desired_peer_count
+				.with_label_values(&[peer_set.get_protocol_name_static()])
+				.set(size as u64)
+		});
 	}
 }
 
@@ -170,9 +168,9 @@ struct MetricsInner {
 }
 
 impl metrics::Metrics for Metrics {
-	fn try_register(registry: &prometheus::Registry)
-		-> std::result::Result<Self, prometheus::PrometheusError>
-	{
+	fn try_register(
+		registry: &prometheus::Registry,
+	) -> std::result::Result<Self, prometheus::PrometheusError> {
 		let metrics = MetricsInner {
 			peer_count: prometheus::register(
 				prometheus::GaugeVec::new(
@@ -306,10 +304,11 @@ impl<N, AD> NetworkBridge<N, AD> {
 }
 
 impl<Net, AD, Context> Subsystem<Context, SubsystemError> for NetworkBridge<Net, AD>
-	where
-		Net: Network + Sync,
-		AD: validator_discovery::AuthorityDiscovery + Clone,
-		Context: SubsystemContext<Message = NetworkBridgeMessage> + overseer::SubsystemContext<Message = NetworkBridgeMessage>,
+where
+	Net: Network + Sync,
+	AD: validator_discovery::AuthorityDiscovery + Clone,
+	Context: SubsystemContext<Message = NetworkBridgeMessage>
+		+ overseer::SubsystemContext<Message = NetworkBridgeMessage>,
 {
 	fn start(mut self, ctx: Context) -> SpawnedSubsystem {
 		// The stream of networking events has to be created at initialization, otherwise the
@@ -319,14 +318,9 @@ impl<Net, AD, Context> Subsystem<Context, SubsystemError> for NetworkBridge<Net,
 		// Swallow error because failure is fatal to the node and we log with more precision
 		// within `run_network`.
 		let future = run_network(self, ctx, network_stream)
-			.map_err(|e| {
-				SubsystemError::with_origin("network-bridge", e)
-			})
+			.map_err(|e| SubsystemError::with_origin("network-bridge", e))
 			.boxed();
-		SpawnedSubsystem {
-			name: "network-bridge-subsystem",
-			future,
-		}
+		SpawnedSubsystem { name: "network-bridge-subsystem", future }
 	}
 }
 
@@ -882,7 +876,8 @@ async fn run_network<N, AD, Context>(
 where
 	N: Network,
 	AD: validator_discovery::AuthorityDiscovery + Clone,
-	Context: SubsystemContext<Message=NetworkBridgeMessage> + overseer::SubsystemContext<Message=NetworkBridgeMessage>,
+	Context: SubsystemContext<Message = NetworkBridgeMessage>
+		+ overseer::SubsystemContext<Message = NetworkBridgeMessage>,
 {
 	let shared = Shared::default();
 
@@ -902,7 +897,7 @@ where
 		.get_dispute_sending()
 		.expect("Gets initialized, must be `Some` on startup. qed.");
 
-	let (remote, network_event_handler) = handle_network_messages::<>(
+	let (remote, network_event_handler) = handle_network_messages(
 		ctx.sender().clone(),
 		network_service.clone(),
 		network_stream,
@@ -910,16 +905,15 @@ where
 		request_multiplexer,
 		metrics.clone(),
 		shared.clone(),
-	).remote_handle();
+	)
+	.remote_handle();
 
 	ctx.spawn("network-bridge-network-worker", Box::pin(remote))?;
 
-	ctx.send_message(
-		DisputeDistributionMessage::DisputeSendingReceiver(dispute_receiver)
-	).await;
-	ctx.send_message(
-		StatementDistributionMessage::StatementFetchingReceiver(statement_receiver)
-	).await;
+	ctx.send_message(DisputeDistributionMessage::DisputeSendingReceiver(dispute_receiver))
+		.await;
+	ctx.send_message(StatementDistributionMessage::StatementFetchingReceiver(statement_receiver))
+		.await;
 
 	let subsystem_event_handler = handle_subsystem_messages(
 		ctx,
@@ -949,38 +943,34 @@ where
 				"Received SubsystemError from overseer: {:?}",
 				err
 			)))
-		}
+		},
 		Err(UnexpectedAbort::EventStreamConcluded) => {
 			tracing::info!(
 				target: LOG_TARGET,
 				"Shutting down Network Bridge: underlying request stream concluded"
 			);
-			Err(SubsystemError::Context(
-				"Incoming network event stream concluded.".to_string(),
-			))
-		}
+			Err(SubsystemError::Context("Incoming network event stream concluded.".to_string()))
+		},
 		Err(UnexpectedAbort::RequestStreamConcluded) => {
 			tracing::info!(
 				target: LOG_TARGET,
 				"Shutting down Network Bridge: underlying request stream concluded"
 			);
-			Err(SubsystemError::Context(
-				"Incoming network request stream concluded".to_string(),
-			))
-		}
+			Err(SubsystemError::Context("Incoming network request stream concluded".to_string()))
+		},
 	}
 }
 
-fn construct_view(live_heads: impl DoubleEndedIterator<Item = Hash>, finalized_number: BlockNumber) -> View {
-	View::new(
-		live_heads.take(MAX_VIEW_HEADS),
-		finalized_number,
-	)
+fn construct_view(
+	live_heads: impl DoubleEndedIterator<Item = Hash>,
+	finalized_number: BlockNumber,
+) -> View {
+	View::new(live_heads.take(MAX_VIEW_HEADS), finalized_number)
 }
 
 fn update_our_view(
 	net: &mut impl Network,
-	ctx: &mut impl SubsystemContext<Message=NetworkBridgeMessage, AllMessages=AllMessages>,
+	ctx: &mut impl SubsystemContext<Message = NetworkBridgeMessage, AllMessages = AllMessages>,
 	live_heads: &[ActivatedLeaf],
 	shared: &Shared,
 	finalized_number: BlockNumber,
@@ -997,17 +987,14 @@ fn update_our_view(
 		// If this is the first view update since becoming active, but our view is empty,
 		// there is no need to send anything.
 		match shared.local_view {
-			Some(ref v) if v.check_heads_eq(&new_view) => {
-				return;
-			}
+			Some(ref v) if v.check_heads_eq(&new_view) => return,
 			None if live_heads.is_empty() => {
 				shared.local_view = Some(new_view);
-				return;
-			}
+				return
+			},
 			_ => {
 				shared.local_view = Some(new_view.clone());
-			}
-
+			},
 		}
 
 		(
@@ -1023,12 +1010,7 @@ fn update_our_view(
 		metrics,
 	);
 
-	send_collation_message(
-		net,
-		collation_peers,
-		WireMessage::ViewUpdate(new_view),
-		metrics,
-	);
+	send_collation_message(net, collation_peers, WireMessage::ViewUpdate(new_view), metrics);
 
 	let our_view = OurView::new(
 		live_heads.iter().take(MAX_VIEW_HEADS).cloned().map(|a| (a.hash, a.span)),
@@ -1056,9 +1038,7 @@ fn handle_peer_messages<M>(
 	metrics: &Metrics,
 ) -> (Vec<NetworkBridgeEvent<M>>, Vec<Rep>) {
 	let peer_data = match peers.get_mut(&peer) {
-		None => {
-			return (Vec::new(), vec![UNCONNECTED_PEERSET_COST]);
-		},
+		None => return (Vec::new(), vec![UNCONNECTED_PEERSET_COST]),
 		Some(d) => d,
 	};
 
@@ -1083,15 +1063,11 @@ fn handle_peer_messages<M>(
 				} else {
 					peer_data.view = new_view;
 
-					NetworkBridgeEvent::PeerViewChange(
-						peer.clone(),
-						peer_data.view.clone(),
-					)
+					NetworkBridgeEvent::PeerViewChange(peer.clone(), peer_data.view.clone())
 				}
-			}
-			WireMessage::ProtocolMessage(message) => {
-				NetworkBridgeEvent::PeerMessage(peer.clone(), message)
-			}
+			},
+			WireMessage::ProtocolMessage(message) =>
+				NetworkBridgeEvent::PeerMessage(peer.clone(), message),
 		})
 	}
 
@@ -1116,24 +1092,23 @@ fn send_collation_message(
 	send_message(net, peers, PeerSet::Collation, message, metrics)
 }
 
-
 async fn dispatch_validation_event_to_all(
 	event: NetworkBridgeEvent<protocol_v1::ValidationProtocol>,
-	ctx: &mut impl SubsystemSender
+	ctx: &mut impl SubsystemSender,
 ) {
 	dispatch_validation_events_to_all(std::iter::once(event), ctx).await
 }
 
 async fn dispatch_collation_event_to_all(
 	event: NetworkBridgeEvent<protocol_v1::CollationProtocol>,
-	ctx: &mut impl SubsystemSender
+	ctx: &mut impl SubsystemSender,
 ) {
 	dispatch_collation_events_to_all(std::iter::once(event), ctx).await
 }
 
 fn dispatch_validation_event_to_all_unbounded(
 	event: NetworkBridgeEvent<protocol_v1::ValidationProtocol>,
-	ctx: &mut impl SubsystemSender
+	ctx: &mut impl SubsystemSender,
 ) {
 	for msg in AllMessages::dispatch_iter(event) {
 		ctx.send_unbounded_message(msg);
@@ -1142,36 +1117,30 @@ fn dispatch_validation_event_to_all_unbounded(
 
 fn dispatch_collation_event_to_all_unbounded(
 	event: NetworkBridgeEvent<protocol_v1::CollationProtocol>,
-	ctx: &mut impl SubsystemSender
+	ctx: &mut impl SubsystemSender,
 ) {
 	if let Some(msg) = event.focus().ok().map(CollatorProtocolMessage::NetworkBridgeUpdateV1) {
 		ctx.send_unbounded_message(msg.into());
 	}
 }
 
-async fn dispatch_validation_events_to_all<I>(
-	events: I,
-	ctx: &mut impl SubsystemSender
-)
-	where
-		I: IntoIterator<Item = NetworkBridgeEvent<protocol_v1::ValidationProtocol>>,
-		I::IntoIter: Send,
+async fn dispatch_validation_events_to_all<I>(events: I, ctx: &mut impl SubsystemSender)
+where
+	I: IntoIterator<Item = NetworkBridgeEvent<protocol_v1::ValidationProtocol>>,
+	I::IntoIter: Send,
 {
 	ctx.send_messages(events.into_iter().flat_map(AllMessages::dispatch_iter)).await
 }
 
-async fn dispatch_collation_events_to_all<I>(
-	events: I,
-	ctx: &mut impl SubsystemSender
-)
-	where
-		I: IntoIterator<Item = NetworkBridgeEvent<protocol_v1::CollationProtocol>>,
-		I::IntoIter: Send,
+async fn dispatch_collation_events_to_all<I>(events: I, ctx: &mut impl SubsystemSender)
+where
+	I: IntoIterator<Item = NetworkBridgeEvent<protocol_v1::CollationProtocol>>,
+	I::IntoIter: Send,
 {
 	let messages_for = |event: NetworkBridgeEvent<protocol_v1::CollationProtocol>| {
-		event.focus().ok().map(|m| AllMessages::CollatorProtocol(
-			CollatorProtocolMessage::NetworkBridgeUpdateV1(m)
-		))
+		event.focus().ok().map(|m| {
+			AllMessages::CollatorProtocol(CollatorProtocolMessage::NetworkBridgeUpdateV1(m))
+		})
 	};
 
 	ctx.send_messages(events.into_iter().flat_map(messages_for)).await

polkadot/node/network/bridge/src/multiplexer.rs

@@ -14,18 +14,18 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::pin::Pin;
-use std::unreachable;
+use std::{pin::Pin, unreachable};
 
-use futures::channel::mpsc;
-use futures::stream::{FusedStream, Stream};
-use futures::task::{Context, Poll};
+use futures::{
+	channel::mpsc,
+	stream::{FusedStream, Stream},
+	task::{Context, Poll},
+};
 use strum::IntoEnumIterator;
 
 use parity_scale_codec::{Decode, Error as DecodingError};
 
-use sc_network::config as network;
-use sc_network::PeerId;
+use sc_network::{config as network, PeerId};
 
 use polkadot_node_network_protocol::request_response::{
 	request::IncomingRequest, v1, Protocol, RequestResponseConfig,
@@ -72,33 +72,23 @@ impl RequestMultiplexer {
 
 		// Ok this code is ugly as hell, it is also a hack, see https://github.com/paritytech/polkadot/issues/2842.
 		// But it works and is executed on startup so, if anything is wrong here it will be noticed immediately.
-		let index = receivers.iter().enumerate().find_map(|(i, (p, _))|
-			if let Protocol::StatementFetching = p {
-				Some(i)
-			} else {
-				None
-			}
-		).expect("Statement fetching must be registered. qed.");
+		let index = receivers
+			.iter()
+			.enumerate()
+			.find_map(
+				|(i, (p, _))| if let Protocol::StatementFetching = p { Some(i) } else { None },
+			)
+			.expect("Statement fetching must be registered. qed.");
 		let statement_fetching = Some(receivers.remove(index).1);
 
-		let index = receivers.iter().enumerate().find_map(|(i, (p, _))|
-			if let Protocol::DisputeSending = p {
-				Some(i)
-			} else {
-				None
-			}
-		).expect("Dispute sending must be registered. qed.");
+		let index = receivers
+			.iter()
+			.enumerate()
+			.find_map(|(i, (p, _))| if let Protocol::DisputeSending = p { Some(i) } else { None })
+			.expect("Dispute sending must be registered. qed.");
 		let dispute_sending = Some(receivers.remove(index).1);
 
-		(
-			Self {
-				receivers,
-				statement_fetching,
-                dispute_sending,
-				next_poll: 0,
-			},
-			cfgs,
-		)
+		(Self { receivers, statement_fetching, dispute_sending, next_poll: 0 }, cfgs)
 	}
 
 	/// Get the receiver for handling statement fetching requests.
@@ -132,7 +122,7 @@ impl Stream for RequestMultiplexer {
 			// Avoid panic:
 			if rx.is_terminated() {
 				// Early return, we don't want to update next_poll.
-				return Poll::Ready(None);
+				return Poll::Ready(None)
 			}
 			i += 1;
 			count -= 1;
@@ -142,8 +132,8 @@ impl Stream for RequestMultiplexer {
 				Poll::Ready(None) => return Poll::Ready(None),
 				Poll::Ready(Some(v)) => {
 					result = Poll::Ready(Some(multiplex_single(*p, v)));
-					break;
-				}
+					break
+				},
 			}
 		}
 		self.next_poll = i;
@@ -155,7 +145,7 @@ impl FusedStream for RequestMultiplexer {
 	fn is_terminated(&self) -> bool {
 		let len = self.receivers.len();
 		if len == 0 {
-			return true;
+			return true
 		}
 		let (_, rx) = &self.receivers[self.next_poll % len];
 		rx.is_terminated()
@@ -165,11 +155,7 @@ impl FusedStream for RequestMultiplexer {
 /// Convert a single raw incoming request into a `MultiplexMessage`.
 fn multiplex_single(
 	p: Protocol,
-	network::IncomingRequest {
-		payload,
-		peer,
-		pending_response,
-	}: network::IncomingRequest,
+	network::IncomingRequest { payload, peer, pending_response }: network::IncomingRequest,
 ) -> Result<AllMessages, RequestMultiplexError> {
 	let r = match p {
 		Protocol::ChunkFetching => AllMessages::from(IncomingRequest::new(
@@ -194,10 +180,10 @@ fn multiplex_single(
 		)),
 		Protocol::StatementFetching => {
 			unreachable!("Statement fetching requests are handled directly. qed.");
-		}
+		},
 		Protocol::DisputeSending => {
 			unreachable!("Dispute sending request are handled directly. qed.");
-		}
+		},
 	};
 	Ok(r)
 }
@@ -211,8 +197,7 @@ fn decode_with_peer<Req: Decode>(
 
 #[cfg(test)]
 mod tests {
-	use futures::prelude::*;
-	use futures::stream::FusedStream;
+	use futures::{prelude::*, stream::FusedStream};
 
 	use super::RequestMultiplexer;
 	#[test]

polkadot/node/network/bridge/src/network.rs

@@ -14,23 +14,21 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::borrow::Cow;
-use std::collections::HashSet;
-use std::sync::Arc;
+use std::{borrow::Cow, collections::HashSet, sync::Arc};
 
 use async_trait::async_trait;
-use futures::prelude::*;
-use futures::stream::BoxStream;
+use futures::{prelude::*, stream::BoxStream};
 
 use parity_scale_codec::Encode;
 
-use sc_network::Event as NetworkEvent;
-use sc_network::{IfDisconnected, NetworkService, OutboundFailure, RequestFailure};
-use sc_network::{config::parse_addr, multiaddr::Multiaddr};
+use sc_network::{
+	config::parse_addr, multiaddr::Multiaddr, Event as NetworkEvent, IfDisconnected,
+	NetworkService, OutboundFailure, RequestFailure,
+};
 
 use polkadot_node_network_protocol::{
 	peer_set::PeerSet,
-	request_response::{OutgoingRequest, Requests, Recipient},
+	request_response::{OutgoingRequest, Recipient, Requests},
 	PeerId, UnifiedReputationChange as Rep,
 };
 use polkadot_primitives::v1::{AuthorityDiscoveryId, Block, Hash};
@@ -50,8 +48,7 @@ pub(crate) fn send_message<M>(
 	peer_set: PeerSet,
 	message: M,
 	metrics: &super::Metrics,
-)
-where
+) where
 	M: Encode + Clone,
 {
 	let message = {
@@ -112,12 +109,7 @@ pub trait Network: Clone + Send + 'static {
 	fn disconnect_peer(&self, who: PeerId, peer_set: PeerSet);
 
 	/// Write a notification to a peer on the given peer-set's protocol.
-	fn write_notification(
-		&self,
-		who: PeerId,
-		peer_set: PeerSet,
-		message: Vec<u8>,
-	);
+	fn write_notification(&self, who: PeerId, peer_set: PeerSet, message: Vec<u8>);
 }
 
 #[async_trait]
@@ -170,38 +162,29 @@ impl Network for Arc<NetworkService<Block, Hash>> {
 		req: Requests,
 		if_disconnected: IfDisconnected,
 	) {
-		let (
-			protocol,
-			OutgoingRequest {
-				peer,
-				payload,
-				pending_response,
-			},
-		) = req.encode_request();
+		let (protocol, OutgoingRequest { peer, payload, pending_response }) = req.encode_request();
 
 		let peer_id = match peer {
-			Recipient::Peer(peer_id) =>  Some(peer_id),
+			Recipient::Peer(peer_id) => Some(peer_id),
 			Recipient::Authority(authority) => {
 				let mut found_peer_id = None;
 				// Note: `get_addresses_by_authority_id` searched in a cache, and it thus expected
 				// to be very quick.
 				for addr in authority_discovery
-					.get_addresses_by_authority_id(authority).await
-					.into_iter().flat_map(|list| list.into_iter())
+					.get_addresses_by_authority_id(authority)
+					.await
+					.into_iter()
+					.flat_map(|list| list.into_iter())
 				{
 					let (peer_id, addr) = match parse_addr(addr) {
 						Ok(v) => v,
 						Err(_) => continue,
 					};
-					NetworkService::add_known_address(
-						&*self,
-						peer_id.clone(),
-						addr,
-					);
+					NetworkService::add_known_address(&*self, peer_id.clone(), addr);
 					found_peer_id = Some(peer_id);
 				}
 				found_peer_id
-			}
+			},
 		};
 
 		let peer_id = match peer_id {
@@ -214,10 +197,10 @@ impl Network for Arc<NetworkService<Block, Hash>> {
 						target: LOG_TARGET,
 						"Sending failed request response failed."
 					),
-					Ok(_) => {}
+					Ok(_) => {},
 				}
-				return;
-			}
+				return
+			},
 			Some(peer_id) => peer_id,
 		};
 
@@ -240,7 +223,8 @@ pub async fn get_peer_id_by_authority_id<AD: AuthorityDiscovery>(
 	// Note: `get_addresses_by_authority_id` searched in a cache, and it thus expected
 	// to be very quick.
 	authority_discovery
-		.get_addresses_by_authority_id(authority).await
+		.get_addresses_by_authority_id(authority)
+		.await
 		.into_iter()
 		.flat_map(|list| list.into_iter())
 		.find_map(|addr| parse_addr(addr).ok().map(|(p, _)| p))

polkadot/node/network/bridge/src/validator_discovery.rs

@@ -25,9 +25,9 @@ use futures::channel::oneshot;
 
 use sc_network::multiaddr::Multiaddr;
 
-use polkadot_primitives::v1::AuthorityDiscoveryId;
-use polkadot_node_network_protocol::peer_set::{PeerSet, PerPeerSet};
 pub use polkadot_node_network_protocol::authority_discovery::AuthorityDiscovery;
+use polkadot_node_network_protocol::peer_set::{PeerSet, PerPeerSet};
+use polkadot_primitives::v1::AuthorityDiscoveryId;
 
 const LOG_TARGET: &str = "parachain::validator-discovery";
 
@@ -44,10 +44,7 @@ struct StatePerPeerSet {
 
 impl<N: Network, AD: AuthorityDiscovery> Service<N, AD> {
 	pub fn new() -> Self {
-		Self {
-			state: Default::default(),
-			_phantom: PhantomData,
-		}
+		Self { state: Default::default(), _phantom: PhantomData }
 	}
 
 	/// On a new connection request, a peer set update will be issued.
@@ -70,24 +67,27 @@ impl<N: Network, AD: AuthorityDiscovery> Service<N, AD> {
 		let mut newly_requested = HashSet::new();
 		let requested = validator_ids.len();
 		for authority in validator_ids.into_iter() {
-			let result = authority_discovery_service.get_addresses_by_authority_id(authority.clone()).await;
+			let result = authority_discovery_service
+				.get_addresses_by_authority_id(authority.clone())
+				.await;
 			if let Some(addresses) = result {
 				newly_requested.extend(addresses);
 			} else {
 				failed_to_resolve += 1;
-				tracing::debug!(target: LOG_TARGET, "Authority Discovery couldn't resolve {:?}", authority);
+				tracing::debug!(
+					target: LOG_TARGET,
+					"Authority Discovery couldn't resolve {:?}",
+					authority
+				);
 			}
 		}
 
 		let state = &mut self.state[peer_set];
 		// clean up revoked requests
-		let multiaddr_to_remove: HashSet<_> = state.previously_requested
-			.difference(&newly_requested)
-			.cloned()
-			.collect();
-		let multiaddr_to_add: HashSet<_> = newly_requested.difference(&state.previously_requested)
-			.cloned()
-			.collect();
+		let multiaddr_to_remove: HashSet<_> =
+			state.previously_requested.difference(&newly_requested).cloned().collect();
+		let multiaddr_to_add: HashSet<_> =
+			newly_requested.difference(&state.previously_requested).cloned().collect();
 		state.previously_requested = newly_requested;
 
 		tracing::debug!(
@@ -101,17 +101,16 @@ impl<N: Network, AD: AuthorityDiscovery> Service<N, AD> {
 		);
 		// ask the network to connect to these nodes and not disconnect
 		// from them until removed from the set
-		if let Err(e) = network_service.add_to_peers_set(
-			peer_set.into_protocol_name(),
-			multiaddr_to_add,
-		).await {
+		if let Err(e) = network_service
+			.add_to_peers_set(peer_set.into_protocol_name(), multiaddr_to_add)
+			.await
+		{
 			tracing::warn!(target: LOG_TARGET, err = ?e, "AuthorityDiscoveryService returned an invalid multiaddress");
 		}
 		// the addresses are known to be valid
-		let _ = network_service.remove_from_peers_set(
-			peer_set.into_protocol_name(),
-			multiaddr_to_remove
-		).await;
+		let _ = network_service
+			.remove_from_peers_set(peer_set.into_protocol_name(), multiaddr_to_remove)
+			.await;
 
 		let _ = failed.send(failed_to_resolve);
 
@@ -124,12 +123,12 @@ mod tests {
 	use super::*;
 	use crate::network::Network;
 
-	use std::{borrow::Cow, collections::HashMap};
-	use futures::stream::BoxStream;
 	use async_trait::async_trait;
+	use futures::stream::BoxStream;
+	use polkadot_node_network_protocol::{request_response::request::Requests, PeerId};
 	use sc_network::{Event as NetworkEvent, IfDisconnected};
 	use sp_keyring::Sr25519Keyring;
-	use polkadot_node_network_protocol::{PeerId, request_response::request::Requests};
+	use std::{borrow::Cow, collections::HashMap};
 
 	fn new_service() -> Service<TestNetwork, TestAuthorityDiscovery> {
 		Service::new()
@@ -156,13 +155,8 @@ mod tests {
 			let authorities = known_authorities();
 			let multiaddr = known_multiaddr();
 			Self {
-				by_authority_id: authorities.iter()
-					.cloned()
-					.zip(multiaddr.into_iter())
-					.collect(),
-				by_peer_id: peer_ids.into_iter()
-					.zip(authorities.into_iter())
-					.collect(),
+				by_authority_id: authorities.iter().cloned().zip(multiaddr.into_iter()).collect(),
+				by_peer_id: peer_ids.into_iter().zip(authorities.into_iter()).collect(),
 			}
 		}
 	}
@@ -173,17 +167,30 @@ mod tests {
 			panic!()
 		}
 
-		async fn add_to_peers_set(&mut self, _protocol: Cow<'static, str>, multiaddresses: HashSet<Multiaddr>) -> Result<(), String> {
+		async fn add_to_peers_set(
+			&mut self,
+			_protocol: Cow<'static, str>,
+			multiaddresses: HashSet<Multiaddr>,
+		) -> Result<(), String> {
 			self.peers_set.extend(multiaddresses.into_iter());
 			Ok(())
 		}
 
-		async fn remove_from_peers_set(&mut self, _protocol: Cow<'static, str>, multiaddresses: HashSet<Multiaddr>) -> Result<(), String> {
+		async fn remove_from_peers_set(
+			&mut self,
+			_protocol: Cow<'static, str>,
+			multiaddresses: HashSet<Multiaddr>,
+		) -> Result<(), String> {
 			self.peers_set.retain(|elem| !multiaddresses.contains(elem));
 			Ok(())
 		}
 
-		async fn start_request<AD: AuthorityDiscovery>(&self, _: &mut AD, _: Requests, _: IfDisconnected) {
+		async fn start_request<AD: AuthorityDiscovery>(
+			&self,
+			_: &mut AD,
+			_: Requests,
+			_: IfDisconnected,
+		) {
 		}
 
 		fn report_peer(&self, _: PeerId, _: crate::Rep) {
@@ -194,33 +201,33 @@ mod tests {
 			panic!()
 		}
 
-		fn write_notification(
-				&self,
-				_: PeerId,
-				_: PeerSet,
-				_: Vec<u8>,
-		) {
+		fn write_notification(&self, _: PeerId, _: PeerSet, _: Vec<u8>) {
 			panic!()
 		}
 	}
 
 	#[async_trait]
 	impl AuthorityDiscovery for TestAuthorityDiscovery {
-		async fn get_addresses_by_authority_id(&mut self, authority: AuthorityDiscoveryId) -> Option<Vec<Multiaddr>> {
+		async fn get_addresses_by_authority_id(
+			&mut self,
+			authority: AuthorityDiscoveryId,
+		) -> Option<Vec<Multiaddr>> {
 			self.by_authority_id.get(&authority).cloned().map(|addr| vec![addr])
 		}
 
-		async fn get_authority_id_by_peer_id(&mut self, peer_id: PeerId) -> Option<AuthorityDiscoveryId> {
+		async fn get_authority_id_by_peer_id(
+			&mut self,
+			peer_id: PeerId,
+		) -> Option<AuthorityDiscoveryId> {
 			self.by_peer_id.get(&peer_id).cloned()
 		}
 	}
 
 	fn known_authorities() -> Vec<AuthorityDiscoveryId> {
-		[
-			Sr25519Keyring::Alice,
-			Sr25519Keyring::Bob,
-			Sr25519Keyring::Charlie,
-		].iter().map(|k| k.public().into()).collect()
+		[Sr25519Keyring::Alice, Sr25519Keyring::Bob, Sr25519Keyring::Charlie]
+			.iter()
+			.map(|k| k.public().into())
+			.collect()
 	}
 
 	fn known_peer_ids() -> Vec<PeerId> {
@@ -245,26 +252,20 @@ mod tests {
 
 		futures::executor::block_on(async move {
 			let (failed, _) = oneshot::channel();
-			let (ns, ads) = service.on_request(
-				vec![authority_ids[0].clone()],
-				PeerSet::Validation,
-				failed,
-				ns,
-				ads,
-			).await;
+			let (ns, ads) = service
+				.on_request(vec![authority_ids[0].clone()], PeerSet::Validation, failed, ns, ads)
+				.await;
 
 			let (failed, _) = oneshot::channel();
-			let (_, ads) = service.on_request(
-				vec![authority_ids[1].clone()],
-				PeerSet::Validation,
-				failed,
-				ns,
-				ads,
-			).await;
+			let (_, ads) = service
+				.on_request(vec![authority_ids[1].clone()], PeerSet::Validation, failed, ns, ads)
+				.await;
 
 			let state = &service.state[PeerSet::Validation];
 			assert_eq!(state.previously_requested.len(), 1);
-			assert!(state.previously_requested.contains(ads.by_authority_id.get(&authority_ids[1]).unwrap()));
+			assert!(state
+				.previously_requested
+				.contains(ads.by_authority_id.get(&authority_ids[1]).unwrap()));
 		});
 	}
 
@@ -279,17 +280,21 @@ mod tests {
 		futures::executor::block_on(async move {
 			let (failed, failed_rx) = oneshot::channel();
 			let unknown = Sr25519Keyring::Ferdie.public().into();
-			let (_, ads) = service.on_request(
-				vec![authority_ids[0].clone(), unknown],
-				PeerSet::Validation,
-				failed,
-				ns,
-				ads,
-			).await;
+			let (_, ads) = service
+				.on_request(
+					vec![authority_ids[0].clone(), unknown],
+					PeerSet::Validation,
+					failed,
+					ns,
+					ads,
+				)
+				.await;
 
 			let state = &service.state[PeerSet::Validation];
 			assert_eq!(state.previously_requested.len(), 1);
-			assert!(state.previously_requested.contains(ads.by_authority_id.get(&authority_ids[0]).unwrap()));
+			assert!(state
+				.previously_requested
+				.contains(ads.by_authority_id.get(&authority_ids[0]).unwrap()));
 
 			let failed = failed_rx.await.unwrap();
 			assert_eq!(failed, 1);