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/tests/state.rs

@@ -14,38 +14,44 @@
 // 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::{collections::{HashMap, HashSet}, sync::Arc, time::Duration};
+use std::{
+	collections::{HashMap, HashSet},
+	sync::Arc,
+	time::Duration,
+};
 
 use polkadot_node_subsystem_util::TimeoutExt;
 use polkadot_subsystem_testhelpers::TestSubsystemContextHandle;
 
-use futures::{FutureExt, channel::oneshot, SinkExt, channel::mpsc, StreamExt};
+use futures::{
+	channel::{mpsc, oneshot},
+	FutureExt, SinkExt, StreamExt,
+};
 use futures_timer::Delay;
 
-use sp_keystore::SyncCryptoStorePtr;
-use sp_core::{traits::SpawnNamed, testing::TaskExecutor};
 use sc_network as network;
-use sc_network::IfDisconnected;
-use sc_network::config as netconfig;
+use sc_network::{config as netconfig, IfDisconnected};
+use sp_core::{testing::TaskExecutor, traits::SpawnNamed};
+use sp_keystore::SyncCryptoStorePtr;
 
-use polkadot_subsystem::{
-	ActiveLeavesUpdate, FromOverseer, OverseerSignal, ActivatedLeaf, LeafStatus,
-	messages::{
-		AllMessages, AvailabilityDistributionMessage, AvailabilityStoreMessage, NetworkBridgeMessage,
-		RuntimeApiMessage, RuntimeApiRequest,
-	}
-};
-use polkadot_primitives::v1::{CandidateHash, CoreState, GroupIndex, Hash, Id
-	as ParaId, ScheduledCore, SessionInfo,
-	ValidatorIndex
-};
-use polkadot_node_primitives::ErasureChunk;
 use polkadot_node_network_protocol::{
 	jaeger,
-	request_response::{IncomingRequest, OutgoingRequest, Requests, v1}
+	request_response::{v1, IncomingRequest, OutgoingRequest, Requests},
+};
+use polkadot_node_primitives::ErasureChunk;
+use polkadot_primitives::v1::{
+	CandidateHash, CoreState, GroupIndex, Hash, Id as ParaId, ScheduledCore, SessionInfo,
+	ValidatorIndex,
+};
+use polkadot_subsystem::{
+	messages::{
+		AllMessages, AvailabilityDistributionMessage, AvailabilityStoreMessage,
+		NetworkBridgeMessage, RuntimeApiMessage, RuntimeApiRequest,
+	},
+	ActivatedLeaf, ActiveLeavesUpdate, FromOverseer, LeafStatus, OverseerSignal,
 };
 use polkadot_subsystem_testhelpers as test_helpers;
-use test_helpers::{SingleItemSink, mock::make_ferdie_keystore};
+use test_helpers::{mock::make_ferdie_keystore, SingleItemSink};
 
 use super::mock::{make_session_info, OccupiedCoreBuilder};
 use crate::LOG_TARGET;
@@ -94,35 +100,32 @@ impl Default for TestState {
 			let mut cores = HashMap::new();
 			let mut chunks = HashMap::new();
 
-			cores.insert(relay_chain[0],
+			cores.insert(
+				relay_chain[0],
 				vec![
-					CoreState::Scheduled(ScheduledCore {
-						para_id: chain_ids[0],
-						collator: None,
-					}),
-					CoreState::Scheduled(ScheduledCore {
-						para_id: chain_ids[1],
-						collator: None,
-					}),
-				]
+					CoreState::Scheduled(ScheduledCore { para_id: chain_ids[0], collator: None }),
+					CoreState::Scheduled(ScheduledCore { para_id: chain_ids[1], collator: None }),
+				],
 			);
 
-			let heads =  {
+			let heads = {
 				let mut advanced = relay_chain.iter();
 				advanced.next();
 				relay_chain.iter().zip(advanced)
 			};
 			for (relay_parent, relay_child) in heads {
-				let (p_cores, p_chunks): (Vec<_>, Vec<_>) = chain_ids.iter().enumerate()
+				let (p_cores, p_chunks): (Vec<_>, Vec<_>) = chain_ids
+					.iter()
+					.enumerate()
 					.map(|(i, para_id)| {
 						let (core, chunk) = OccupiedCoreBuilder {
 							group_responsible: GroupIndex(i as _),
 							para_id: *para_id,
 							relay_parent: relay_parent.clone(),
-						}.build();
+						}
+						.build();
 						(CoreState::Occupied(core), chunk)
-					}
-					)
+					})
 					.unzip();
 				cores.insert(relay_child.clone(), p_cores);
 				// Skip chunks for our own group (won't get fetched):
@@ -146,11 +149,12 @@ impl Default for TestState {
 }
 
 impl TestState {
-
 	/// Run, but fail after some timeout.
 	pub async fn run(self, harness: TestHarness) {
 		// Make sure test won't run forever.
-		let f = self.run_inner(harness.pool, harness.virtual_overseer).timeout(Duration::from_secs(10));
+		let f = self
+			.run_inner(harness.pool, harness.virtual_overseer)
+			.timeout(Duration::from_secs(10));
 		assert!(f.await.is_some(), "Test ran into timeout");
 	}
 
@@ -167,17 +171,19 @@ impl TestState {
 		let updates = {
 			let mut advanced = self.relay_chain.iter();
 			advanced.next();
-			self
-			.relay_chain.iter().zip(advanced)
-			.map(|(old, new)| ActiveLeavesUpdate {
-				activated: Some(ActivatedLeaf {
-					hash: new.clone(),
-					number: 1,
-					status: LeafStatus::Fresh,
-					span: Arc::new(jaeger::Span::Disabled),
-				}),
-				deactivated: vec![old.clone()].into(),
-			}).collect::<Vec<_>>()
+			self.relay_chain
+				.iter()
+				.zip(advanced)
+				.map(|(old, new)| ActiveLeavesUpdate {
+					activated: Some(ActivatedLeaf {
+						hash: new.clone(),
+						number: 1,
+						status: LeafStatus::Fresh,
+						span: Arc::new(jaeger::Span::Disabled),
+					}),
+					deactivated: vec![old.clone()].into(),
+				})
+				.collect::<Vec<_>>()
 		};
 
 		// We should be storing all valid chunks during execution:
@@ -190,24 +196,27 @@ impl TestState {
 		// Spawning necessary as incoming queue can only hold a single item, we don't want to dead
 		// lock ;-)
 		let update_tx = tx.clone();
-		executor.spawn("Sending active leaves updates", async move {
-			for update in updates {
-				overseer_signal(
-					update_tx.clone(),
-					OverseerSignal::ActiveLeaves(update)
-				).await;
-				// We need to give the subsystem a little time to do its job, otherwise it will
-				// cancel jobs as obsolete:
-				Delay::new(Duration::from_millis(20)).await;
+		executor.spawn(
+			"Sending active leaves updates",
+			async move {
+				for update in updates {
+					overseer_signal(update_tx.clone(), OverseerSignal::ActiveLeaves(update)).await;
+					// We need to give the subsystem a little time to do its job, otherwise it will
+					// cancel jobs as obsolete:
+					Delay::new(Duration::from_millis(20)).await;
+				}
 			}
-		}.boxed());
+			.boxed(),
+		);
 
-		while remaining_stores > 0
-		{
+		while remaining_stores > 0 {
 			tracing::trace!(target: LOG_TARGET, remaining_stores, "Stores left to go");
 			let msg = overseer_recv(&mut rx).await;
 			match msg {
-				AllMessages::NetworkBridge(NetworkBridgeMessage::SendRequests(reqs, IfDisconnected::TryConnect)) => {
+				AllMessages::NetworkBridge(NetworkBridgeMessage::SendRequests(
+					reqs,
+					IfDisconnected::TryConnect,
+				)) => {
 					for req in reqs {
 						// Forward requests:
 						let in_req = to_incoming_req(&executor, req);
@@ -215,50 +224,61 @@ impl TestState {
 						executor.spawn(
 							"Request forwarding",
 							overseer_send(
-									tx.clone(),
-									AvailabilityDistributionMessage::ChunkFetchingRequest(in_req)
-							).boxed()
+								tx.clone(),
+								AvailabilityDistributionMessage::ChunkFetchingRequest(in_req),
+							)
+							.boxed(),
 						);
 					}
-				}
-				AllMessages::AvailabilityStore(AvailabilityStoreMessage::QueryChunk(candidate_hash,	validator_index, tx)) => {
-					let chunk = self.chunks.get_mut(&(candidate_hash, validator_index)).map(Vec::pop).flatten().flatten();
-					tx.send(chunk)
-						.expect("Receiver is expected to be alive");
-				}
-				AllMessages::AvailabilityStore(AvailabilityStoreMessage::StoreChunk{candidate_hash,	chunk, tx, ..}) => {
+				},
+				AllMessages::AvailabilityStore(AvailabilityStoreMessage::QueryChunk(
+					candidate_hash,
+					validator_index,
+					tx,
+				)) => {
+					let chunk = self
+						.chunks
+						.get_mut(&(candidate_hash, validator_index))
+						.map(Vec::pop)
+						.flatten()
+						.flatten();
+					tx.send(chunk).expect("Receiver is expected to be alive");
+				},
+				AllMessages::AvailabilityStore(AvailabilityStoreMessage::StoreChunk {
+					candidate_hash,
+					chunk,
+					tx,
+					..
+				}) => {
 					assert!(
 						self.valid_chunks.contains(&(candidate_hash, chunk.index)),
 						"Only valid chunks should ever get stored."
 					);
-					tx.send(Ok(()))
-						.expect("Receiver is expected to be alive");
+					tx.send(Ok(())).expect("Receiver is expected to be alive");
 					tracing::trace!(target: LOG_TARGET, "'Stored' fetched chunk.");
 					remaining_stores -= 1;
-				}
+				},
 				AllMessages::RuntimeApi(RuntimeApiMessage::Request(hash, req)) => {
 					match req {
 						RuntimeApiRequest::SessionIndexForChild(tx) => {
 							// Always session index 1 for now:
-							tx.send(Ok(1))
-							.expect("Receiver should still be alive");
-						}
+							tx.send(Ok(1)).expect("Receiver should still be alive");
+						},
 						RuntimeApiRequest::SessionInfo(_, tx) => {
 							tx.send(Ok(Some(self.session_info.clone())))
-							.expect("Receiver should be alive.");
-						}
+								.expect("Receiver should be alive.");
+						},
 						RuntimeApiRequest::AvailabilityCores(tx) => {
 							tracing::trace!(target: LOG_TARGET, cores= ?self.cores[&hash], hash = ?hash, "Sending out cores for hash");
 							tx.send(Ok(self.cores[&hash].clone()))
-							.expect("Receiver should still be alive");
-						}
+								.expect("Receiver should still be alive");
+						},
 						_ => {
 							panic!("Unexpected runtime request: {:?}", req);
-						}
+						},
 					}
-				}
-				_ => {
-				}
+				},
+				_ => {},
 			}
 		}
 
@@ -272,9 +292,7 @@ async fn overseer_signal(
 ) {
 	let msg = msg.into();
 	tracing::trace!(target: LOG_TARGET, msg = ?msg, "sending message");
-	tx.send(FromOverseer::Signal(msg))
-		.await
-		.expect("Test subsystem no longer live");
+	tx.send(FromOverseer::Signal(msg)).await.expect("Test subsystem no longer live");
 }
 
 async fn overseer_send(
@@ -283,42 +301,44 @@ async fn overseer_send(
 ) {
 	let msg = msg.into();
 	tracing::trace!(target: LOG_TARGET, msg = ?msg, "sending message");
-	tx.send(FromOverseer::Communication { msg }).await
+	tx.send(FromOverseer::Communication { msg })
+		.await
 		.expect("Test subsystem no longer live");
 	tracing::trace!(target: LOG_TARGET, "sent message");
 }
 
-
-async fn overseer_recv(
-	rx: &mut mpsc::UnboundedReceiver<AllMessages>,
-) -> AllMessages {
+async fn overseer_recv(rx: &mut mpsc::UnboundedReceiver<AllMessages>) -> AllMessages {
 	tracing::trace!(target: LOG_TARGET, "waiting for message ...");
 	rx.next().await.expect("Test subsystem no longer live")
 }
 
 fn to_incoming_req(
 	executor: &TaskExecutor,
-	outgoing: Requests
+	outgoing: Requests,
 ) -> IncomingRequest<v1::ChunkFetchingRequest> {
 	match outgoing {
 		Requests::ChunkFetching(OutgoingRequest { payload, pending_response, .. }) => {
-			let (tx, rx): (oneshot::Sender<netconfig::OutgoingResponse>, oneshot::Receiver<_>)
-			   = oneshot::channel();
-			executor.spawn("Message forwarding", async {
-				let response = rx.await;
-				let payload = response.expect("Unexpected canceled request").result;
-				pending_response.send(payload.map_err(|_| network::RequestFailure::Refused))
-					.expect("Sending response is expected to work");
-			}.boxed()
+			let (tx, rx): (oneshot::Sender<netconfig::OutgoingResponse>, oneshot::Receiver<_>) =
+				oneshot::channel();
+			executor.spawn(
+				"Message forwarding",
+				async {
+					let response = rx.await;
+					let payload = response.expect("Unexpected canceled request").result;
+					pending_response
+						.send(payload.map_err(|_| network::RequestFailure::Refused))
+						.expect("Sending response is expected to work");
+				}
+				.boxed(),
 			);
 
 			IncomingRequest::new(
 				// We don't really care:
 				network::PeerId::random(),
 				payload,
-				tx
+				tx,
 			)
-		}
+		},
 		_ => panic!("Unexpected request!"),
 	}
 }