cargo +nightly fmt (#3540)

* cargo +nightly fmt

* add cargo-fmt check to ci

* update ci

* fmt

* fmt

* skip macro

* ignore bridges

polkadot/node/network/availability-distribution/src/pov_requester/mod.rs

@@ -16,23 +16,26 @@
 
 //! PoV requester takes care of requesting PoVs from validators of a backing group.
 
-use futures::{FutureExt, channel::oneshot, future::BoxFuture};
+use futures::{channel::oneshot, future::BoxFuture, FutureExt};
 
-use polkadot_subsystem::jaeger;
-use polkadot_node_network_protocol::request_response::{OutgoingRequest, Recipient, request::{RequestError, Requests},
-	v1::{PoVFetchingRequest, PoVFetchingResponse}};
-use polkadot_primitives::v1::{
-	CandidateHash, Hash, ValidatorIndex,
+use polkadot_node_network_protocol::request_response::{
+	request::{RequestError, Requests},
+	v1::{PoVFetchingRequest, PoVFetchingResponse},
+	OutgoingRequest, Recipient,
 };
 use polkadot_node_primitives::PoV;
-use polkadot_subsystem::{
-	SubsystemContext,
-	messages::{NetworkBridgeMessage, IfDisconnected}
-};
 use polkadot_node_subsystem_util::runtime::RuntimeInfo;
+use polkadot_primitives::v1::{CandidateHash, Hash, ValidatorIndex};
+use polkadot_subsystem::{
+	jaeger,
+	messages::{IfDisconnected, NetworkBridgeMessage},
+	SubsystemContext,
+};
 
-use crate::error::{Fatal, NonFatal};
-use crate::LOG_TARGET;
+use crate::{
+	error::{Fatal, NonFatal},
+	LOG_TARGET,
+};
 
 /// Start background worker for taking care of fetching the requested `PoV` from the network.
 pub async fn fetch_pov<Context>(
@@ -42,32 +45,31 @@ pub async fn fetch_pov<Context>(
 	from_validator: ValidatorIndex,
 	candidate_hash: CandidateHash,
 	pov_hash: Hash,
-	tx: oneshot::Sender<PoV>
+	tx: oneshot::Sender<PoV>,
 ) -> super::Result<()>
 where
 	Context: SubsystemContext,
 {
 	let info = &runtime.get_session_info(ctx.sender(), parent).await?.session_info;
-	let authority_id = info.discovery_keys.get(from_validator.0 as usize)
+	let authority_id = info
+		.discovery_keys
+		.get(from_validator.0 as usize)
 		.ok_or(NonFatal::InvalidValidatorIndex)?
 		.clone();
 	let (req, pending_response) = OutgoingRequest::new(
 		Recipient::Authority(authority_id),
-		PoVFetchingRequest {
-			candidate_hash,
-		},
+		PoVFetchingRequest { candidate_hash },
 	);
 	let full_req = Requests::PoVFetching(req);
 
-	ctx.send_message(
-			NetworkBridgeMessage::SendRequests(
-				vec![full_req],
-				// We are supposed to be connected to validators of our group via `PeerSet`,
-				// but at session boundaries that is kind of racy, in case a connection takes
-				// longer to get established, so we try to connect in any case.
-				IfDisconnected::TryConnect
-			)
-	).await;
+	ctx.send_message(NetworkBridgeMessage::SendRequests(
+		vec![full_req],
+		// We are supposed to be connected to validators of our group via `PeerSet`,
+		// but at session boundaries that is kind of racy, in case a connection takes
+		// longer to get established, so we try to connect in any case.
+		IfDisconnected::TryConnect,
+	))
+	.await;
 
 	let span = jaeger::Span::new(candidate_hash, "fetch-pov")
 		.with_validator_index(from_validator)
@@ -85,11 +87,7 @@ async fn fetch_pov_job(
 	tx: oneshot::Sender<PoV>,
 ) {
 	if let Err(err) = do_fetch_pov(pov_hash, pending_response, span, tx).await {
-		tracing::warn!(
-			target: LOG_TARGET,
-			?err,
-			"fetch_pov_job"
-		);
+		tracing::warn!(target: LOG_TARGET, ?err, "fetch_pov_job");
 	}
 }
 
@@ -99,15 +97,11 @@ async fn do_fetch_pov(
 	pending_response: BoxFuture<'static, Result<PoVFetchingResponse, RequestError>>,
 	_span: jaeger::Span,
 	tx: oneshot::Sender<PoV>,
-)
-	-> std::result::Result<(), NonFatal>
-{
+) -> std::result::Result<(), NonFatal> {
 	let response = pending_response.await.map_err(NonFatal::FetchPoV)?;
 	let pov = match response {
 		PoVFetchingResponse::PoV(pov) => pov,
-		PoVFetchingResponse::NoSuchPoV => {
-			return Err(NonFatal::NoSuchPoV)
-		}
+		PoVFetchingResponse::NoSuchPoV => return Err(NonFatal::NoSuchPoV),
 	};
 	if pov.hash() == pov_hash {
 		tx.send(pov).map_err(|_| NonFatal::SendResponse)
@@ -124,38 +118,37 @@ mod tests {
 	use parity_scale_codec::Encode;
 	use sp_core::testing::TaskExecutor;
 
-	use polkadot_primitives::v1::{CandidateHash, Hash, ValidatorIndex};
 	use polkadot_node_primitives::BlockData;
+	use polkadot_primitives::v1::{CandidateHash, Hash, ValidatorIndex};
+	use polkadot_subsystem::messages::{
+		AllMessages, AvailabilityDistributionMessage, RuntimeApiMessage, RuntimeApiRequest,
+	};
 	use polkadot_subsystem_testhelpers as test_helpers;
-	use polkadot_subsystem::messages::{AvailabilityDistributionMessage, RuntimeApiMessage, RuntimeApiRequest, AllMessages};
 	use test_helpers::mock::make_ferdie_keystore;
 
 	use super::*;
-	use crate::LOG_TARGET;
-	use crate::tests::mock::{make_session_info};
+	use crate::{tests::mock::make_session_info, LOG_TARGET};
 
 	#[test]
 	fn rejects_invalid_pov() {
 		sp_tracing::try_init_simple();
-		let pov = PoV {
-			block_data: BlockData(vec![1,2,3,4,5,6]),
-		};
+		let pov = PoV { block_data: BlockData(vec![1, 2, 3, 4, 5, 6]) };
 		test_run(Hash::default(), pov);
 	}
 
 	#[test]
 	fn accepts_valid_pov() {
 		sp_tracing::try_init_simple();
-		let pov = PoV {
-			block_data: BlockData(vec![1,2,3,4,5,6]),
-		};
+		let pov = PoV { block_data: BlockData(vec![1, 2, 3, 4, 5, 6]) };
 		test_run(pov.hash(), pov);
 	}
 
 	fn test_run(pov_hash: Hash, pov: PoV) {
 		let pool = TaskExecutor::new();
-		let (mut context, mut virtual_overseer) =
-			test_helpers::make_subsystem_context::<AvailabilityDistributionMessage, TaskExecutor>(pool.clone());
+		let (mut context, mut virtual_overseer) = test_helpers::make_subsystem_context::<
+			AvailabilityDistributionMessage,
+			TaskExecutor,
+		>(pool.clone());
 		let keystore = make_ferdie_keystore();
 		let mut runtime = polkadot_node_subsystem_util::runtime::RuntimeInfo::new(Some(keystore));
 
@@ -169,34 +162,33 @@ mod tests {
 				CandidateHash::default(),
 				pov_hash,
 				tx,
-			).await.expect("Should succeed");
+			)
+			.await
+			.expect("Should succeed");
 		};
 
 		let tester = async move {
 			loop {
 				match virtual_overseer.recv().await {
-					AllMessages::RuntimeApi(
-						RuntimeApiMessage::Request(
-							_,
-							RuntimeApiRequest::SessionIndexForChild(tx)
-							)
-						) => {
+					AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+						_,
+						RuntimeApiRequest::SessionIndexForChild(tx),
+					)) => {
 						tx.send(Ok(0)).unwrap();
-					}
-					AllMessages::RuntimeApi(
-						RuntimeApiMessage::Request(
-							_,
-							RuntimeApiRequest::SessionInfo(_, tx)
-							)
-						) => {
+					},
+					AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+						_,
+						RuntimeApiRequest::SessionInfo(_, tx),
+					)) => {
 						tx.send(Ok(Some(make_session_info()))).unwrap();
-					}
+					},
 					AllMessages::NetworkBridge(NetworkBridgeMessage::SendRequests(mut reqs, _)) => {
 						let req = assert_matches!(
 							reqs.pop(),
 							Some(Requests::PoVFetching(outgoing)) => {outgoing}
 						);
-						req.pending_response.send(Ok(PoVFetchingResponse::PoV(pov.clone()).encode()))
+						req.pending_response
+							.send(Ok(PoVFetchingResponse::PoV(pov.clone()).encode()))
 							.unwrap();
 						break
 					},