cargo +nightly fmt (#3540)

* cargo +nightly fmt * add cargo-fmt check to ci * update ci * fmt * fmt * skip macro * ignore bridges
2026-04-28 01:38:04 +00:00 · 2021-08-02 12:47:33 +02:00
parent 30e3012270
commit ff5d56fb76
350 changed files with 20617 additions and 21266 deletions
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.

-
 //! Helper functions and tools to generate mock data useful for testing this subsystem.

 use std::sync::Arc;
@@ -22,43 +21,44 @@ use std::sync::Arc;
 use sp_keyring::Sr25519Keyring;

 use polkadot_erasure_coding::{branches, obtain_chunks_v1 as obtain_chunks};
+use polkadot_node_primitives::{AvailableData, BlockData, ErasureChunk, PoV};
 use polkadot_primitives::v1::{
-	CandidateCommitments, CandidateDescriptor, CandidateHash,
-	CommittedCandidateReceipt, GroupIndex, Hash, HeadData, Id as ParaId,
-	OccupiedCore, PersistedValidationData, SessionInfo, ValidatorIndex
+	CandidateCommitments, CandidateDescriptor, CandidateHash, CommittedCandidateReceipt,
+	GroupIndex, Hash, HeadData, Id as ParaId, OccupiedCore, PersistedValidationData, SessionInfo,
+	ValidatorIndex,
 };
-use polkadot_node_primitives::{PoV, ErasureChunk, AvailableData, BlockData};
-

 /// Create dummy session info with two validator groups.
 pub fn make_session_info() -> SessionInfo {
-		let validators = vec![
-			Sr25519Keyring::Ferdie, // <- this node, role: validator
-			Sr25519Keyring::Alice,
-			Sr25519Keyring::Bob,
-			Sr25519Keyring::Charlie,
-			Sr25519Keyring::Dave,
-			Sr25519Keyring::Eve,
-			Sr25519Keyring::One,
-		];
+	let validators = vec![
+		Sr25519Keyring::Ferdie, // <- this node, role: validator
+		Sr25519Keyring::Alice,
+		Sr25519Keyring::Bob,
+		Sr25519Keyring::Charlie,
+		Sr25519Keyring::Dave,
+		Sr25519Keyring::Eve,
+		Sr25519Keyring::One,
+	];

-		let validator_groups: Vec<Vec<ValidatorIndex>> = [vec![5, 0, 3], vec![1, 6, 2, 4]]
-			.iter().map(|g| g.into_iter().map(|v| ValidatorIndex(*v)).collect()).collect();
+	let validator_groups: Vec<Vec<ValidatorIndex>> = [vec![5, 0, 3], vec![1, 6, 2, 4]]
+		.iter()
+		.map(|g| g.into_iter().map(|v| ValidatorIndex(*v)).collect())
+		.collect();

-		SessionInfo {
-			discovery_keys: validators.iter().map(|k| k.public().into()).collect(),
-			// Not used:
-			n_cores: validator_groups.len() as u32,
-			validator_groups,
-			// Not used values:
-			validators: validators.iter().map(|k| k.public().into()).collect(),
-			assignment_keys: Vec::new(),
-			zeroth_delay_tranche_width: 0,
-			relay_vrf_modulo_samples: 0,
-			n_delay_tranches: 0,
-			no_show_slots: 0,
-			needed_approvals: 0,
-		}
+	SessionInfo {
+		discovery_keys: validators.iter().map(|k| k.public().into()).collect(),
+		// Not used:
+		n_cores: validator_groups.len() as u32,
+		validator_groups,
+		// Not used values:
+		validators: validators.iter().map(|k| k.public().into()).collect(),
+		assignment_keys: Vec::new(),
+		zeroth_delay_tranche_width: 0,
+		relay_vrf_modulo_samples: 0,
+		n_delay_tranches: 0,
+		no_show_slots: 0,
+		needed_approvals: 0,
+	}
 }

 /// Builder for constructing occupied cores.
@@ -72,9 +72,7 @@ pub struct OccupiedCoreBuilder {

 impl OccupiedCoreBuilder {
 	pub fn build(self) -> (OccupiedCore, (CandidateHash, ErasureChunk)) {
-		let pov = PoV {
-			block_data: BlockData(vec![45, 46, 47]),
-		};
+		let pov = PoV { block_data: BlockData(vec![45, 46, 47]) };
 		let pov_hash = pov.hash();
 		let (erasure_root, chunk) = get_valid_chunk_data(pov.clone());
 		let candidate_receipt = TestCandidateBuilder {
@@ -83,7 +81,8 @@ impl OccupiedCoreBuilder {
 			relay_parent: self.relay_parent,
 			erasure_root,
 			..Default::default()
-		}.build();
+		}
+		.build();
 		let core = OccupiedCore {
 			next_up_on_available: None,
 			occupied_since: 0,
@@ -117,10 +116,7 @@ impl TestCandidateBuilder {
 				erasure_root: self.erasure_root,
 				..Default::default()
 			},
-			commitments: CandidateCommitments {
-				head_data: self.head_data,
-				..Default::default()
-			},
+			commitments: CandidateCommitments { head_data: self.head_data, ..Default::default() },
 		}
 	}
 }
@@ -134,18 +130,18 @@ pub fn get_valid_chunk_data(pov: PoV) -> (Hash, ErasureChunk) {
 		max_pov_size: 1024,
 		relay_parent_storage_root: Default::default(),
 	};
-	let available_data = AvailableData {
-		validation_data: persisted, pov: Arc::new(pov),
-	};
+	let available_data = AvailableData { validation_data: persisted, pov: Arc::new(pov) };
 	let chunks = obtain_chunks(fake_validator_count, &available_data).unwrap();
 	let branches = branches(chunks.as_ref());
 	let root = branches.root();
-	let chunk = branches.enumerate()
-			.map(|(index, (proof, chunk))| ErasureChunk {
-				chunk: chunk.to_vec(),
-				index: ValidatorIndex(index as _),
-				proof,
-			})
-			.next().expect("There really should be 10 chunks.");
+	let chunk = branches
+		.enumerate()
+		.map(|(index, (proof, chunk))| ErasureChunk {
+			chunk: chunk.to_vec(),
+			index: ValidatorIndex(index as _),
+			proof,
+		})
+		.next()
+		.expect("There really should be 10 chunks.");
 	(root, chunk)
 }
@@ -27,7 +27,7 @@ use super::*;

 mod state;
 /// State for test harnesses.
-use state::{TestState, TestHarness};
+use state::{TestHarness, TestState};

 /// Mock data useful for testing.
 pub(crate) mod mock;
@@ -60,9 +60,7 @@ fn test_harness<T: Future<Output = ()>>(
 #[test]
 fn check_basic() {
 	let state = TestState::default();
-	test_harness(state.keystore.clone(), move |harness| {
-		state.run(harness)
-	});
+	test_harness(state.keystore.clone(), move |harness| state.run(harness));
 }

 /// Check whether requester tries all validators in group.
@@ -75,9 +73,7 @@ fn check_fetch_tries_all() {
 		v.push(None);
 		v.push(None);
 	}
-	test_harness(state.keystore.clone(), move |harness| {
-		state.run(harness)
-	});
+	test_harness(state.keystore.clone(), move |harness| state.run(harness));
 }

 /// Check whether requester tries all validators in group
@@ -87,10 +83,9 @@ fn check_fetch_tries_all() {
 #[test]
 fn check_fetch_retry() {
 	let mut state = TestState::default();
-	state.cores.insert(
-		state.relay_chain[2],
-		state.cores.get(&state.relay_chain[1]).unwrap().clone(),
-	);
+	state
+		.cores
+		.insert(state.relay_chain[2], state.cores.get(&state.relay_chain[1]).unwrap().clone());
 	// We only care about the first three blocks.
 	// 1. scheduled
 	// 2. occupied
@@ -98,20 +93,18 @@ fn check_fetch_retry() {
 	state.relay_chain.truncate(3);

 	// Get rid of unused valid chunks:
-	let valid_candidate_hashes: HashSet<_> = state.cores
+	let valid_candidate_hashes: HashSet<_> = state
+		.cores
 		.get(&state.relay_chain[1])
 		.iter()
 		.flat_map(|v| v.iter())
-		.filter_map(|c| {
-			match c {
-				CoreState::Occupied(core) => Some(core.candidate_hash),
-				_ => None,
-			}
+		.filter_map(|c| match c {
+			CoreState::Occupied(core) => Some(core.candidate_hash),
+			_ => None,
 		})
 		.collect();
 	state.valid_chunks.retain(|(ch, _)| valid_candidate_hashes.contains(ch));

-
 	for (_, v) in state.chunks.iter_mut() {
 		// This should still succeed as cores are still pending availability on next block.
 		v.push(None);
@@ -120,7 +113,5 @@ fn check_fetch_retry() {
 		v.push(None);
 		v.push(None);
 	}
-	test_harness(state.keystore.clone(), move |harness| {
-		state.run(harness)
-	});
+	test_harness(state.keystore.clone(), move |harness| state.run(harness));
 }
@@ -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!"),
 	}
 }