cargo +nightly fmt (#3540)

* cargo +nightly fmt * add cargo-fmt check to ci * update ci * fmt * fmt * skip macro * ignore bridges
2026-04-29 17:17:56 +00:00 · 2021-08-02 12:47:33 +02:00
parent 30e3012270
commit ff5d56fb76
350 changed files with 20617 additions and 21266 deletions
@@ -24,25 +24,29 @@ use futures::{
 	channel::{mpsc, oneshot},
 	prelude::*,
 };
+use futures_timer::Delay;
 use polkadot_node_subsystem::{
-	errors::{ChainApiError, RuntimeApiError}, PerLeafSpan, SubsystemSender, jaeger,
+	errors::{ChainApiError, RuntimeApiError},
+	jaeger,
 	messages::{
-		CandidateBackingMessage, ChainApiMessage, ProvisionableData, ProvisionerInherentData,
-		ProvisionerMessage, DisputeCoordinatorMessage,
+		CandidateBackingMessage, ChainApiMessage, DisputeCoordinatorMessage, ProvisionableData,
+		ProvisionerInherentData, ProvisionerMessage,
 	},
+	PerLeafSpan, SubsystemSender,
 };
 use polkadot_node_subsystem_util::{
-	self as util, JobSubsystem, JobSender,
-	request_availability_cores, request_persisted_validation_data, JobTrait, metrics::{self, prometheus},
+	self as util,
+	metrics::{self, prometheus},
+	request_availability_cores, request_persisted_validation_data, JobSender, JobSubsystem,
+	JobTrait,
 };
 use polkadot_primitives::v1::{
-	BackedCandidate, BlockNumber, CandidateReceipt, CoreState, Hash, OccupiedCoreAssumption,
-	SignedAvailabilityBitfield, ValidatorIndex, MultiDisputeStatementSet, DisputeStatementSet,
-	DisputeStatement,
+	BackedCandidate, BlockNumber, CandidateReceipt, CoreState, DisputeStatement,
+	DisputeStatementSet, Hash, MultiDisputeStatementSet, OccupiedCoreAssumption,
+	SignedAvailabilityBitfield, ValidatorIndex,
 };
-use std::{pin::Pin, collections::BTreeMap, sync::Arc};
+use std::{collections::BTreeMap, pin::Pin, sync::Arc};
 use thiserror::Error;
-use futures_timer::Delay;

 #[cfg(test)]
 mod tests;
@@ -92,7 +96,7 @@ pub struct ProvisioningJob {
 	signed_bitfields: Vec<SignedAvailabilityBitfield>,
 	metrics: Metrics,
 	inherent_after: InherentAfter,
-	awaiting_inherent: Vec<oneshot::Sender<ProvisionerInherentData>>
+	awaiting_inherent: Vec<oneshot::Sender<ProvisionerInherentData>>,
 }

 /// Errors in the provisioner.
@@ -132,7 +136,9 @@ pub enum Error {
 	#[error("failed to send return message with Inherents")]
 	InherentDataReturnChannel,

-	#[error("backed candidate does not correspond to selected candidate; check logic in provisioner")]
+	#[error(
+		"backed candidate does not correspond to selected candidate; check logic in provisioner"
+	)]
 	BackedCandidateOrderingProblem,
 }

@@ -156,13 +162,10 @@ impl JobTrait for ProvisioningJob {
 		mut sender: JobSender<S>,
 	) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send>> {
 		async move {
-			let job = ProvisioningJob::new(
-				relay_parent,
-				metrics,
-				receiver,
-			);
+			let job = ProvisioningJob::new(relay_parent, metrics, receiver);

-			job.run_loop(sender.subsystem_sender(), PerLeafSpan::new(span, "provisioner")).await
+			job.run_loop(sender.subsystem_sender(), PerLeafSpan::new(span, "provisioner"))
+				.await
 		}
 		.boxed()
 	}
@@ -190,9 +193,7 @@ impl ProvisioningJob {
 		sender: &mut impl SubsystemSender,
 		span: PerLeafSpan,
 	) -> Result<(), Error> {
-		use ProvisionerMessage::{
-			ProvisionableData, RequestInherentData,
-		};
+		use ProvisionerMessage::{ProvisionableData, RequestInherentData};
 		loop {
 			futures::select! {
 				msg = self.receiver.next() => match msg {
@@ -248,17 +249,21 @@ impl ProvisioningJob {
 		}
 	}

-	fn note_provisionable_data(&mut self, span: &jaeger::Span, provisionable_data: ProvisionableData) {
+	fn note_provisionable_data(
+		&mut self,
+		span: &jaeger::Span,
+		provisionable_data: ProvisionableData,
+	) {
 		match provisionable_data {
-			ProvisionableData::Bitfield(_, signed_bitfield) => {
-				self.signed_bitfields.push(signed_bitfield)
-			}
+			ProvisionableData::Bitfield(_, signed_bitfield) =>
+				self.signed_bitfields.push(signed_bitfield),
 			ProvisionableData::BackedCandidate(backed_candidate) => {
-				let _span = span.child("provisionable-backed")
+				let _span = span
+					.child("provisionable-backed")
 					.with_para_id(backed_candidate.descriptor().para_id);
 				self.backed_candidates.push(backed_candidate)
-			}
-			_ => {}
+			},
+			_ => {},
 		}
 	}
 }
@@ -291,27 +296,23 @@ async fn send_inherent_data(
 ) -> Result<(), Error> {
 	let availability_cores = request_availability_cores(relay_parent, from_job)
 		.await
-		.await.map_err(|err| Error::CanceledAvailabilityCores(err))??;
+		.await
+		.map_err(|err| Error::CanceledAvailabilityCores(err))??;

 	let bitfields = select_availability_bitfields(&availability_cores, bitfields);
-	let candidates = select_candidates(
-		&availability_cores,
-		&bitfields,
-		candidates,
-		relay_parent,
-		from_job,
-	).await?;
+	let candidates =
+		select_candidates(&availability_cores, &bitfields, candidates, relay_parent, from_job)
+			.await?;

 	let disputes = select_disputes(from_job).await?;

-	let inherent_data = ProvisionerInherentData {
-		bitfields,
-		backed_candidates: candidates,
-		disputes,
-	};
+	let inherent_data =
+		ProvisionerInherentData { bitfields, backed_candidates: candidates, disputes };

 	for return_sender in return_senders {
-		return_sender.send(inherent_data.clone()).map_err(|_data| Error::InherentDataReturnChannel)?;
+		return_sender
+			.send(inherent_data.clone())
+			.map_err(|_data| Error::InherentDataReturnChannel)?;
 	}

 	Ok(())
@@ -333,16 +334,18 @@ fn select_availability_bitfields(
 ) -> Vec<SignedAvailabilityBitfield> {
 	let mut selected: BTreeMap<ValidatorIndex, SignedAvailabilityBitfield> = BTreeMap::new();

-	'a:
-	for bitfield in bitfields.iter().cloned() {
+	'a: for bitfield in bitfields.iter().cloned() {
 		if bitfield.payload().0.len() != cores.len() {
 			continue
 		}

-		let is_better = selected.get(&bitfield.validator_index())
+		let is_better = selected
+			.get(&bitfield.validator_index())
 			.map_or(true, |b| b.payload().0.count_ones() < bitfield.payload().0.count_ones());

-		if !is_better { continue }
+		if !is_better {
+			continue
+		}

 		for (idx, _) in cores.iter().enumerate().filter(|v| !v.1.is_occupied()) {
 			// Bit is set for an unoccupied core - invalid
@@ -374,23 +377,24 @@ async fn select_candidates(
 		let (scheduled_core, assumption) = match core {
 			CoreState::Scheduled(scheduled_core) => (scheduled_core, OccupiedCoreAssumption::Free),
 			CoreState::Occupied(occupied_core) => {
-				if bitfields_indicate_availability(core_idx, bitfields, &occupied_core.availability) {
+				if bitfields_indicate_availability(core_idx, bitfields, &occupied_core.availability)
+				{
 					if let Some(ref scheduled_core) = occupied_core.next_up_on_available {
 						(scheduled_core, OccupiedCoreAssumption::Included)
 					} else {
-						continue;
+						continue
 					}
 				} else {
 					if occupied_core.time_out_at != block_number {
-						continue;
+						continue
 					}
 					if let Some(ref scheduled_core) = occupied_core.next_up_on_time_out {
 						(scheduled_core, OccupiedCoreAssumption::TimedOut)
 					} else {
-						continue;
+						continue
 					}
 				}
-			}
+			},
 			CoreState::Free => continue,
 		};

@@ -401,7 +405,8 @@ async fn select_candidates(
 			sender,
 		)
 		.await
-		.await.map_err(|err| Error::CanceledPersistedValidationData(err))??
+		.await
+		.map_err(|err| Error::CanceledPersistedValidationData(err))??
 		{
 			Some(v) => v,
 			None => continue,
@@ -412,8 +417,8 @@ async fn select_candidates(
 		// we arbitrarily pick the first of the backed candidates which match the appropriate selection criteria
 		if let Some(candidate) = candidates.iter().find(|backed_candidate| {
 			let descriptor = &backed_candidate.descriptor;
-			descriptor.para_id == scheduled_core.para_id
-				&& descriptor.persisted_validation_data_hash == computed_validation_data_hash
+			descriptor.para_id == scheduled_core.para_id &&
+				descriptor.persisted_validation_data_hash == computed_validation_data_hash
 		}) {
 			let candidate_hash = candidate.hash();
 			tracing::trace!(
@@ -430,11 +435,16 @@ async fn select_candidates(

 	// now get the backed candidates corresponding to these candidate receipts
 	let (tx, rx) = oneshot::channel();
-	sender.send_message(CandidateBackingMessage::GetBackedCandidates(
-		relay_parent,
-		selected_candidates.clone(),
-		tx,
-	).into()).await;
+	sender
+		.send_message(
+			CandidateBackingMessage::GetBackedCandidates(
+				relay_parent,
+				selected_candidates.clone(),
+				tx,
+			)
+			.into(),
+		)
+		.await;
 	let mut candidates = rx.await.map_err(|err| Error::CanceledBackedCandidates(err))?;

 	// `selected_candidates` is generated in ascending order by core index, and `GetBackedCandidates`
@@ -445,7 +455,9 @@ async fn select_candidates(
 	// in order, we can ensure that the backed candidates are also in order.
 	let mut backed_idx = 0;
 	for selected in selected_candidates {
-		if selected == candidates.get(backed_idx).ok_or(Error::BackedCandidateOrderingProblem)?.hash() {
+		if selected ==
+			candidates.get(backed_idx).ok_or(Error::BackedCandidateOrderingProblem)?.hash()
+		{
 			backed_idx += 1;
 		}
 	}
@@ -484,12 +496,7 @@ async fn get_block_number_under_construction(
 	sender: &mut impl SubsystemSender,
 ) -> Result<BlockNumber, Error> {
 	let (tx, rx) = oneshot::channel();
-	sender
-		.send_message(ChainApiMessage::BlockNumber(
-			relay_parent,
-			tx,
-		).into())
-		.await;
+	sender.send_message(ChainApiMessage::BlockNumber(relay_parent, tx).into()).await;

 	match rx.await.map_err(|err| Error::CanceledBlockNumber(err))? {
 		Ok(Some(n)) => Ok(n + 1),
@@ -528,8 +535,8 @@ fn bitfields_indicate_availability(
 					availability_len,
 				);

-				return false;
-			}
+				return false
+			},
 			Some(mut bit_mut) => *bit_mut |= bitfield.payload().0[core_idx],
 		}
 	}
@@ -562,16 +569,17 @@ async fn select_disputes(
 			);

 			Vec::new()
-		}
+		},
 	};

 	// Load all votes for all disputes from the coordinator.
 	let dispute_candidate_votes = {
 		let (tx, rx) = oneshot::channel();
-		sender.send_message(DisputeCoordinatorMessage::QueryCandidateVotes(
-			recent_disputes,
-			tx,
-		).into()).await;
+		sender
+			.send_message(
+				DisputeCoordinatorMessage::QueryCandidateVotes(recent_disputes, tx).into(),
+			)
+			.await;

 		match rx.await {
 			Ok(v) => v,
@@ -581,24 +589,29 @@ async fn select_disputes(
 					"Unable to query candidate votes - subsystem disconnected?",
 				);
 				Vec::new()
-			}
+			},
 		}
 	};

 	// Transform all `CandidateVotes` into `MultiDisputeStatementSet`.
-	Ok(dispute_candidate_votes.into_iter().map(|(session_index, candidate_hash, votes)| {
-		let valid_statements = votes.valid.into_iter()
-			.map(|(s, i, sig)| (DisputeStatement::Valid(s), i, sig));
+	Ok(dispute_candidate_votes
+		.into_iter()
+		.map(|(session_index, candidate_hash, votes)| {
+			let valid_statements =
+				votes.valid.into_iter().map(|(s, i, sig)| (DisputeStatement::Valid(s), i, sig));

-		let invalid_statements = votes.invalid.into_iter()
-			.map(|(s, i, sig)| (DisputeStatement::Invalid(s), i, sig));
+			let invalid_statements = votes
+				.invalid
+				.into_iter()
+				.map(|(s, i, sig)| (DisputeStatement::Invalid(s), i, sig));

-		DisputeStatementSet {
-			candidate_hash,
-			session: session_index,
-			statements: valid_statements.chain(invalid_statements).collect(),
-		}
-	}).collect())
+			DisputeStatementSet {
+				candidate_hash,
+				session: session_index,
+				statements: valid_statements.chain(invalid_statements).collect(),
+			}
+		})
+		.collect())
 }

 #[derive(Clone)]
@@ -623,7 +636,9 @@ impl Metrics {
 	}

 	/// Provide a timer for `request_inherent_data` which observes on drop.
-	fn time_request_inherent_data(&self) -> Option<metrics::prometheus::prometheus::HistogramTimer> {
+	fn time_request_inherent_data(
+		&self,
+	) -> Option<metrics::prometheus::prometheus::HistogramTimer> {
 		self.0.as_ref().map(|metrics| metrics.request_inherent_data.start_timer())
 	}

@@ -647,21 +662,17 @@ impl metrics::Metrics for Metrics {
 				registry,
 			)?,
 			request_inherent_data: prometheus::register(
-				prometheus::Histogram::with_opts(
-					prometheus::HistogramOpts::new(
-						"parachain_provisioner_request_inherent_data",
-						"Time spent within `provisioner::request_inherent_data`",
-					)
-				)?,
+				prometheus::Histogram::with_opts(prometheus::HistogramOpts::new(
+					"parachain_provisioner_request_inherent_data",
+					"Time spent within `provisioner::request_inherent_data`",
+				))?,
 				registry,
 			)?,
 			provisionable_data: prometheus::register(
-				prometheus::Histogram::with_opts(
-					prometheus::HistogramOpts::new(
-						"parachain_provisioner_provisionable_data",
-						"Time spent within `provisioner::provisionable_data`",
-					)
-				)?,
+				prometheus::Histogram::with_opts(prometheus::HistogramOpts::new(
+					"parachain_provisioner_provisionable_data",
+					"Time spent within `provisioner::provisionable_data`",
+				))?,
 				registry,
 			)?,
 		};
@@ -669,6 +680,5 @@ impl metrics::Metrics for Metrics {
 	}
 }

-
 /// The provisioning subsystem.
 pub type ProvisioningSubsystem<Spawner> = JobSubsystem<ProvisioningJob, Spawner>;
@@ -34,20 +34,16 @@ pub fn default_bitvec(n_cores: usize) -> CoreAvailability {
 }

 pub fn scheduled_core(id: u32) -> ScheduledCore {
-	ScheduledCore {
-		para_id: id.into(),
-		..Default::default()
-	}
+	ScheduledCore { para_id: id.into(), ..Default::default() }
 }

 mod select_availability_bitfields {
-	use super::super::*;
-	use super::{default_bitvec, occupied_core};
+	use super::{super::*, default_bitvec, occupied_core};
 	use futures::executor::block_on;
-	use std::sync::Arc;
-	use polkadot_primitives::v1::{SigningContext, ValidatorIndex, ValidatorId};
+	use polkadot_primitives::v1::{SigningContext, ValidatorId, ValidatorIndex};
 	use sp_application_crypto::AppKey;
-	use sp_keystore::{CryptoStore, SyncCryptoStorePtr, testing::KeyStore};
+	use sp_keystore::{testing::KeyStore, CryptoStore, SyncCryptoStorePtr};
+	use std::sync::Arc;

 	async fn signed_bitfield(
 		keystore: &SyncCryptoStorePtr,
@@ -63,7 +59,11 @@ mod select_availability_bitfields {
 			&<SigningContext<Hash>>::default(),
 			validator_idx,
 			&public.into(),
-		).await.ok().flatten().expect("Should be signed")
+		)
+		.await
+		.ok()
+		.flatten()
+		.expect("Should be signed")
 	}

 	#[test]
@@ -109,11 +109,8 @@ mod select_availability_bitfields {
 		let mut bitvec2 = bitvec.clone();
 		bitvec2.set(2, true);

-		let cores = vec![
-			CoreState::Free,
-			CoreState::Scheduled(Default::default()),
-			occupied_core(2),
-		];
+		let cores =
+			vec![CoreState::Free, CoreState::Scheduled(Default::default()), occupied_core(2)];

 		let bitfields = vec![
 			block_on(signed_bitfield(&keystore, bitvec0, ValidatorIndex(0))),
@@ -191,16 +188,18 @@ mod select_availability_bitfields {
 }

 mod select_candidates {
-	use super::super::*;
-	use super::{build_occupied_core, occupied_core, scheduled_core, default_bitvec};
+	use super::{super::*, build_occupied_core, default_bitvec, occupied_core, scheduled_core};
 	use polkadot_node_subsystem::messages::{
 		AllMessages, RuntimeApiMessage,
-		RuntimeApiRequest::{AvailabilityCores, PersistedValidationData as PersistedValidationDataReq},
-	};
-	use polkadot_primitives::v1::{
-		BlockNumber, CandidateDescriptor, PersistedValidationData, CommittedCandidateReceipt, CandidateCommitments,
+		RuntimeApiRequest::{
+			AvailabilityCores, PersistedValidationData as PersistedValidationDataReq,
+		},
 	};
 	use polkadot_node_subsystem_test_helpers::TestSubsystemSender;
+	use polkadot_primitives::v1::{
+		BlockNumber, CandidateCommitments, CandidateDescriptor, CommittedCandidateReceipt,
+		PersistedValidationData,
+	};

 	const BLOCK_UNDER_PRODUCTION: BlockNumber = 128;

@@ -307,21 +306,21 @@ mod select_candidates {

 		while let Some(from_job) = receiver.next().await {
 			match from_job {
-				AllMessages::ChainApi(BlockNumber(_relay_parent, tx)) => {
-					tx.send(Ok(Some(BLOCK_UNDER_PRODUCTION - 1))).unwrap()
-				}
+				AllMessages::ChainApi(BlockNumber(_relay_parent, tx)) =>
+					tx.send(Ok(Some(BLOCK_UNDER_PRODUCTION - 1))).unwrap(),
 				AllMessages::RuntimeApi(Request(
 					_parent_hash,
 					PersistedValidationDataReq(_para_id, _assumption, tx),
 				)) => tx.send(Ok(Some(Default::default()))).unwrap(),
-				AllMessages::RuntimeApi(Request(_parent_hash, AvailabilityCores(tx))) => {
-					tx.send(Ok(mock_availability_cores())).unwrap()
-				}
-				AllMessages::CandidateBacking(
-					CandidateBackingMessage::GetBackedCandidates(_, _, sender)
-				) => {
+				AllMessages::RuntimeApi(Request(_parent_hash, AvailabilityCores(tx))) =>
+					tx.send(Ok(mock_availability_cores())).unwrap(),
+				AllMessages::CandidateBacking(CandidateBackingMessage::GetBackedCandidates(
+					_,
+					_,
+					sender,
+				)) => {
 					let _ = sender.send(expected.clone());
-				}
+				},
 				_ => panic!("Unexpected message: {:?}", from_job),
 			}
 		}
@@ -329,9 +328,12 @@ mod select_candidates {

 	#[test]
 	fn can_succeed() {
-		test_harness(|r| mock_overseer(r, Vec::new()), |mut tx: TestSubsystemSender| async move {
-			select_candidates(&[], &[], &[], Default::default(), &mut tx).await.unwrap();
-		})
+		test_harness(
+			|r| mock_overseer(r, Vec::new()),
+			|mut tx: TestSubsystemSender| async move {
+				select_candidates(&[], &[], &[], Default::default(), &mut tx).await.unwrap();
+			},
+		)
 	}

 	// this tests that only the appropriate candidates get selected.
@@ -368,8 +370,7 @@ mod select_candidates {
 					candidate
 				} else if idx < mock_cores.len() * 2 {
 					// for the second repetition of the candidates, give them the wrong hash
-					candidate.descriptor.persisted_validation_data_hash
-						= Default::default();
+					candidate.descriptor.persisted_validation_data_hash = Default::default();
 					candidate
 				} else {
 					// third go-around: right hash, wrong para_id
@@ -380,34 +381,38 @@ mod select_candidates {
 			.collect();

 		// why those particular indices? see the comments on mock_availability_cores()
-		let expected_candidates: Vec<_> = [1, 4, 7, 8, 10]
-			.iter()
-			.map(|&idx| candidates[idx].clone())
-			.collect();
+		let expected_candidates: Vec<_> =
+			[1, 4, 7, 8, 10].iter().map(|&idx| candidates[idx].clone()).collect();

 		let expected_backed = expected_candidates
 			.iter()
 			.map(|c| BackedCandidate {
-				candidate: CommittedCandidateReceipt { descriptor: c.descriptor.clone(), ..Default::default() },
+				candidate: CommittedCandidateReceipt {
+					descriptor: c.descriptor.clone(),
+					..Default::default()
+				},
 				validity_votes: Vec::new(),
 				validator_indices: default_bitvec(n_cores),
 			})
 			.collect();

-		test_harness(|r| mock_overseer(r, expected_backed), |mut tx: TestSubsystemSender| async move {
-			let result =
-				select_candidates(&mock_cores, &[], &candidates, Default::default(), &mut tx)
-					.await.unwrap();
+		test_harness(
+			|r| mock_overseer(r, expected_backed),
+			|mut tx: TestSubsystemSender| async move {
+				let result =
+					select_candidates(&mock_cores, &[], &candidates, Default::default(), &mut tx)
+						.await
+						.unwrap();

-			result.into_iter()
-				.for_each(|c|
+				result.into_iter().for_each(|c| {
 					assert!(
 						expected_candidates.iter().any(|c2| c.candidate.corresponds_to(c2)),
 						"Failed to find candidate: {:?}",
 						c,
 					)
-				);
-		})
+				});
+			},
+		)
 	}

 	#[test]
@@ -430,7 +435,11 @@ mod select_candidates {
 					..Default::default()
 				},
 				commitments: CandidateCommitments {
-					new_validation_code: if cores_with_code.contains(&i) { Some(vec![].into()) } else { None },
+					new_validation_code: if cores_with_code.contains(&i) {
+						Some(vec![].into())
+					} else {
+						None
+					},
 					..Default::default()
 				},
 				..Default::default()
@@ -439,10 +448,8 @@ mod select_candidates {

 		let candidates: Vec<_> = committed_receipts.iter().map(|r| r.to_plain()).collect();

-		let expected_candidates: Vec<_> = cores
-			.iter()
-			.map(|&idx| candidates[idx].clone())
-			.collect();
+		let expected_candidates: Vec<_> =
+			cores.iter().map(|&idx| candidates[idx].clone()).collect();

 		let expected_backed: Vec<_> = cores
 			.iter()
@@ -453,19 +460,22 @@ mod select_candidates {
 			})
 			.collect();

-		test_harness(|r| mock_overseer(r, expected_backed), |mut tx: TestSubsystemSender| async move {
-			let result =
-				select_candidates(&mock_cores, &[], &candidates, Default::default(), &mut tx)
-					.await.unwrap();
+		test_harness(
+			|r| mock_overseer(r, expected_backed),
+			|mut tx: TestSubsystemSender| async move {
+				let result =
+					select_candidates(&mock_cores, &[], &candidates, Default::default(), &mut tx)
+						.await
+						.unwrap();

-			result.into_iter()
-				.for_each(|c|
+				result.into_iter().for_each(|c| {
 					assert!(
 						expected_candidates.iter().any(|c2| c.candidate.corresponds_to(c2)),
 						"Failed to find candidate: {:?}",
 						c,
 					)
-				);
-		})
+				});
+			},
+		)
 	}
 }