cargo +nightly fmt (#3540)

* cargo +nightly fmt

* add cargo-fmt check to ci

* update ci

* fmt

* fmt

* skip macro

* ignore bridges

polkadot/node/network/statement-distribution/src/error.rs

@@ -22,7 +22,7 @@ use polkadot_primitives::v1::{CandidateHash, Hash};
 use polkadot_subsystem::SubsystemError;
 use thiserror::Error;
 
-use polkadot_node_subsystem_util::{Fault, runtime, unwrap_non_fatal};
+use polkadot_node_subsystem_util::{runtime, unwrap_non_fatal, Fault};
 
 use crate::LOG_TARGET;
 
@@ -112,9 +112,7 @@ pub enum NonFatal {
 ///
 /// We basically always want to try and continue on error. This utility function is meant to
 /// consume top-level errors by simply logging them.
-pub fn log_error(result: Result<()>, ctx: &'static str)
-	-> FatalResult<()>
-{
+pub fn log_error(result: Result<()>, ctx: &'static str) -> FatalResult<()> {
 	if let Some(error) = unwrap_non_fatal(result.map_err(|e| e.0))? {
 		tracing::debug!(target: LOG_TARGET, error = ?error, ctx)
 	}

polkadot/node/network/statement-distribution/src/requester.rs

@@ -16,21 +16,23 @@
 
 use std::time::Duration;
 
-use futures::{SinkExt, channel::{mpsc, oneshot}};
+use futures::{
+	channel::{mpsc, oneshot},
+	SinkExt,
+};
 
 use polkadot_node_network_protocol::{
-	PeerId, UnifiedReputationChange,
 	request_response::{
+		v1::{StatementFetchingRequest, StatementFetchingResponse},
 		OutgoingRequest, Recipient, Requests,
-		v1::{
-			StatementFetchingRequest, StatementFetchingResponse
-		}
-	}};
+	},
+	PeerId, UnifiedReputationChange,
+};
 use polkadot_node_subsystem_util::TimeoutExt;
 use polkadot_primitives::v1::{CandidateHash, CommittedCandidateReceipt, Hash};
 use polkadot_subsystem::{Span, Stage};
 
-use crate::{LOG_TARGET, Metrics, COST_WRONG_HASH};
+use crate::{Metrics, COST_WRONG_HASH, LOG_TARGET};
 
 // In case we failed fetching from our known peers, how long we should wait before attempting a
 // retry, even though we have not yet discovered any new peers. Or in other words how long to
@@ -43,7 +45,7 @@ pub enum RequesterMessage {
 	GetMorePeers {
 		relay_parent: Hash,
 		candidate_hash: CandidateHash,
-		tx: oneshot::Sender<Vec<PeerId>>
+		tx: oneshot::Sender<Vec<PeerId>>,
 	},
 	/// Fetching finished, ask for verification. If verification fails, task will continue asking
 	/// peers for data.
@@ -65,7 +67,6 @@ pub enum RequesterMessage {
 	SendRequest(Requests),
 }
 
-
 /// A fetching task, taking care of fetching large statements via request/response.
 ///
 /// A fetch task does not know about a particular `Statement` instead it just tries fetching a
@@ -87,28 +88,21 @@ pub async fn fetch(
 	// Peers left for trying out.
 	let mut new_peers = peers;
 
-	let req = StatementFetchingRequest {
-		relay_parent,
-		candidate_hash,
-	};
+	let req = StatementFetchingRequest { relay_parent, candidate_hash };
 
 	// We retry endlessly (with sleep periods), and rely on the subsystem to kill us eventually.
 	loop {
-
 		let span = span.child("try-available-peers");
 
 		while let Some(peer) = new_peers.pop() {
+			let _span = span.child("try-peer").with_peer_id(&peer);
 
-			let _span = span.child("try-peer")
-				.with_peer_id(&peer);
-
-			let (outgoing, pending_response) = OutgoingRequest::new(
-				Recipient::Peer(peer),
-				req.clone(),
-			);
-			if let Err(err) = sender.feed(
-				RequesterMessage::SendRequest(Requests::StatementFetching(outgoing))
-			).await {
+			let (outgoing, pending_response) =
+				OutgoingRequest::new(Recipient::Peer(peer), req.clone());
+			if let Err(err) = sender
+				.feed(RequesterMessage::SendRequest(Requests::StatementFetching(outgoing)))
+				.await
+			{
 				tracing::info!(
 					target: LOG_TARGET,
 					?err,
@@ -121,13 +115,12 @@ pub async fn fetch(
 
 			match pending_response.await {
 				Ok(StatementFetchingResponse::Statement(statement)) => {
-
 					if statement.hash() != candidate_hash {
 						metrics.on_received_response(false);
 
-						if let Err(err) = sender.feed(
-							RequesterMessage::ReportPeer(peer, COST_WRONG_HASH)
-						).await {
+						if let Err(err) =
+							sender.feed(RequesterMessage::ReportPeer(peer, COST_WRONG_HASH)).await
+						{
 							tracing::warn!(
 								target: LOG_TARGET,
 								?err,
@@ -138,15 +131,16 @@ pub async fn fetch(
 						continue
 					}
 
-					if let Err(err) = sender.feed(
-						RequesterMessage::Finished {
+					if let Err(err) = sender
+						.feed(RequesterMessage::Finished {
 							relay_parent,
 							candidate_hash,
 							from_peer: peer,
 							response: statement,
 							bad_peers: tried_peers,
-						}
-						).await {
+						})
+						.await
+					{
 						tracing::warn!(
 							target: LOG_TARGET,
 							?err,
@@ -167,7 +161,7 @@ pub async fn fetch(
 					);
 
 					metrics.on_received_response(false);
-				}
+				},
 			}
 
 			tried_peers.push(peer);
@@ -178,14 +172,10 @@ pub async fn fetch(
 		// All our peers failed us - try getting new ones before trying again:
 		match try_get_new_peers(relay_parent, candidate_hash, &mut sender, &span).await {
 			Ok(Some(mut peers)) => {
-				tracing::trace!(
-					target: LOG_TARGET,
-					?peers,
-					"Received new peers."
-				);
+				tracing::trace!(target: LOG_TARGET, ?peers, "Received new peers.");
 				// New arrivals will be tried first:
 				new_peers.append(&mut peers);
-			}
+			},
 			// No new peers, try the old ones again (if we have any):
 			Ok(None) => {
 				// Note: In case we don't have any more peers, we will just keep asking for new
@@ -205,14 +195,14 @@ async fn try_get_new_peers(
 	sender: &mut mpsc::Sender<RequesterMessage>,
 	span: &Span,
 ) -> Result<Option<Vec<PeerId>>, ()> {
-
 	let _span = span.child("wait-for-peers");
 
 	let (tx, rx) = oneshot::channel();
 
-	if let Err(err) = sender.send(
-		RequesterMessage::GetMorePeers { relay_parent, candidate_hash, tx }
-	).await {
+	if let Err(err) = sender
+		.send(RequesterMessage::GetMorePeers { relay_parent, candidate_hash, tx })
+		.await
+	{
 		tracing::debug!(
 			target: LOG_TARGET,
 			?err,
@@ -223,13 +213,9 @@ async fn try_get_new_peers(
 
 	match rx.timeout(RETRY_TIMEOUT).await.transpose() {
 		Err(_) => {
-			tracing::debug!(
-				target: LOG_TARGET,
-				"Failed fetching more peers."
-			);
+			tracing::debug!(target: LOG_TARGET, "Failed fetching more peers.");
 			Err(())
-		}
-		Ok(val) => Ok(val)
+		},
+		Ok(val) => Ok(val),
 	}
 }
-

polkadot/node/network/statement-distribution/src/responder.rs

@@ -14,16 +14,19 @@
 
 //! Large statement responding background task logic.
 
-use futures::{SinkExt, StreamExt, channel::{mpsc, oneshot}, stream::FuturesUnordered};
+use futures::{
+	channel::{mpsc, oneshot},
+	stream::FuturesUnordered,
+	SinkExt, StreamExt,
+};
 
 use polkadot_node_network_protocol::{
-	PeerId, UnifiedReputationChange as Rep,
 	request_response::{
-		IncomingRequest, MAX_PARALLEL_STATEMENT_REQUESTS, request::OutgoingResponse,
-		v1::{
-			StatementFetchingRequest, StatementFetchingResponse
-		},
+		request::OutgoingResponse,
+		v1::{StatementFetchingRequest, StatementFetchingResponse},
+		IncomingRequest, MAX_PARALLEL_STATEMENT_REQUESTS,
 	},
+	PeerId, UnifiedReputationChange as Rep,
 };
 use polkadot_primitives::v1::{CandidateHash, CommittedCandidateReceipt, Hash};
 
@@ -38,11 +41,10 @@ pub enum ResponderMessage {
 		requesting_peer: PeerId,
 		relay_parent: Hash,
 		candidate_hash: CandidateHash,
-		tx: oneshot::Sender<CommittedCandidateReceipt>
+		tx: oneshot::Sender<CommittedCandidateReceipt>,
 	},
 }
 
-
 /// A fetching task, taking care of fetching large statements via request/response.
 ///
 /// A fetch task does not know about a particular `Statement` instead it just tries fetching a
@@ -74,56 +76,41 @@ pub async fn respond(
 
 		let raw = match receiver.next().await {
 			None => {
-				tracing::debug!(
-					target: LOG_TARGET,
-					"Shutting down request responder"
-				);
+				tracing::debug!(target: LOG_TARGET, "Shutting down request responder");
 				return
-			}
+			},
 			Some(v) => v,
 		};
 
-		let req =
-			match IncomingRequest::<StatementFetchingRequest>::try_from_raw(
-				raw,
-				vec![COST_INVALID_REQUEST],
-			) {
+		let req = match IncomingRequest::<StatementFetchingRequest>::try_from_raw(
+			raw,
+			vec![COST_INVALID_REQUEST],
+		) {
 			Err(err) => {
-				tracing::debug!(
-					target: LOG_TARGET,
-					?err,
-					"Decoding request failed"
-				);
+				tracing::debug!(target: LOG_TARGET, ?err, "Decoding request failed");
 				continue
-			}
+			},
 			Ok(payload) => payload,
 		};
 
 		let (tx, rx) = oneshot::channel();
-		if let Err(err) = sender.feed(
-			ResponderMessage::GetData {
+		if let Err(err) = sender
+			.feed(ResponderMessage::GetData {
 				requesting_peer: req.peer,
 				relay_parent: req.payload.relay_parent,
 				candidate_hash: req.payload.candidate_hash,
 				tx,
-			}
-		).await {
-			tracing::debug!(
-				target: LOG_TARGET,
-				?err,
-				"Shutting down responder"
-			);
+			})
+			.await
+		{
+			tracing::debug!(target: LOG_TARGET, ?err, "Shutting down responder");
 			return
 		}
 		let response = match rx.await {
 			Err(err) => {
-				tracing::debug!(
-					target: LOG_TARGET,
-					?err,
-					"Requested data not found."
-				);
+				tracing::debug!(target: LOG_TARGET, ?err, "Requested data not found.");
 				Err(())
-			}
+			},
 			Ok(v) => Ok(StatementFetchingResponse::Statement(v)),
 		};
 		let (pending_sent_tx, pending_sent_rx) = oneshot::channel();
@@ -134,10 +121,7 @@ pub async fn respond(
 		};
 		pending_out.push(pending_sent_rx);
 		if let Err(_) = req.send_outgoing_response(response) {
-			tracing::debug!(
-				target: LOG_TARGET,
-				"Sending response failed"
-			);
+			tracing::debug!(target: LOG_TARGET, "Sending response failed");
 		}
 	}
 }