cargo +nightly fmt (#3540)

* cargo +nightly fmt

* add cargo-fmt check to ci

* update ci

* fmt

* fmt

* skip macro

* ignore bridges

polkadot/node/network/bitfield-distribution/src/lib.rs

@@ -24,19 +24,19 @@
 
 use futures::{channel::oneshot, FutureExt};
 
-use polkadot_subsystem::messages::*;
-use polkadot_subsystem::{
-	PerLeafSpan, ActiveLeavesUpdate, FromOverseer, OverseerSignal, SpawnedSubsystem,
-	SubsystemContext, SubsystemResult, SubsystemError,
-	jaeger,
-	overseer,
+use polkadot_node_network_protocol::{
+	v1 as protocol_v1, OurView, PeerId, UnifiedReputationChange as Rep, View,
 };
 use polkadot_node_subsystem_util::{
+	self as util,
 	metrics::{self, prometheus},
-	self as util, MIN_GOSSIP_PEERS,
+	MIN_GOSSIP_PEERS,
 };
 use polkadot_primitives::v1::{Hash, SignedAvailabilityBitfield, SigningContext, ValidatorId};
-use polkadot_node_network_protocol::{v1 as protocol_v1, PeerId, View, UnifiedReputationChange as Rep, OurView};
+use polkadot_subsystem::{
+	jaeger, messages::*, overseer, ActiveLeavesUpdate, FromOverseer, OverseerSignal, PerLeafSpan,
+	SpawnedSubsystem, SubsystemContext, SubsystemError, SubsystemResult,
+};
 use std::collections::{HashMap, HashSet};
 
 #[cfg(test)]
@@ -46,8 +46,10 @@ const COST_SIGNATURE_INVALID: Rep = Rep::CostMajor("Bitfield signature invalid")
 const COST_VALIDATOR_INDEX_INVALID: Rep = Rep::CostMajor("Bitfield validator index invalid");
 const COST_MISSING_PEER_SESSION_KEY: Rep = Rep::CostMinor("Missing peer session key");
 const COST_NOT_IN_VIEW: Rep = Rep::CostMinor("Not interested in that parent hash");
-const COST_PEER_DUPLICATE_MESSAGE: Rep = Rep::CostMinorRepeated("Peer sent the same message multiple times");
-const BENEFIT_VALID_MESSAGE_FIRST: Rep = Rep::BenefitMinorFirst("Valid message with new information");
+const COST_PEER_DUPLICATE_MESSAGE: Rep =
+	Rep::CostMinorRepeated("Peer sent the same message multiple times");
+const BENEFIT_VALID_MESSAGE_FIRST: Rep =
+	Rep::BenefitMinorFirst("Valid message with new information");
 const BENEFIT_VALID_MESSAGE: Rep = Rep::BenefitMinor("Valid message");
 
 /// Checked signed availability bitfield that is distributed
@@ -62,14 +64,10 @@ struct BitfieldGossipMessage {
 
 impl BitfieldGossipMessage {
 	fn into_validation_protocol(self) -> protocol_v1::ValidationProtocol {
-		protocol_v1::ValidationProtocol::BitfieldDistribution(
-			self.into_network_message()
-		)
+		protocol_v1::ValidationProtocol::BitfieldDistribution(self.into_network_message())
 	}
 
-	fn into_network_message(self)
-		-> protocol_v1::BitfieldDistributionMessage
-	{
+	fn into_network_message(self) -> protocol_v1::BitfieldDistributionMessage {
 		protocol_v1::BitfieldDistributionMessage::Bitfield(
 			self.relay_parent,
 			self.signed_availability.into(),
@@ -124,7 +122,11 @@ struct PerRelayParentData {
 
 impl PerRelayParentData {
 	/// Create a new instance.
-	fn new(signing_context: SigningContext, validator_set: Vec<ValidatorId>, span: PerLeafSpan) -> Self {
+	fn new(
+		signing_context: SigningContext,
+		validator_set: Vec<ValidatorId>,
+		span: PerLeafSpan,
+	) -> Self {
 		Self {
 			signing_context,
 			validator_set,
@@ -141,8 +143,14 @@ impl PerRelayParentData {
 		peer: &PeerId,
 		validator: &ValidatorId,
 	) -> bool {
-		self.message_sent_to_peer.get(peer).map(|v| !v.contains(validator)).unwrap_or(true)
-			&& self.message_received_from_peer.get(peer).map(|v| !v.contains(validator)).unwrap_or(true)
+		self.message_sent_to_peer
+			.get(peer)
+			.map(|v| !v.contains(validator))
+			.unwrap_or(true) &&
+			self.message_received_from_peer
+				.get(peer)
+				.map(|v| !v.contains(validator))
+				.unwrap_or(true)
 	}
 }
 
@@ -172,34 +180,34 @@ impl BitfieldDistribution {
 				Ok(message) => message,
 				Err(e) => {
 					tracing::debug!(target: LOG_TARGET, err = ?e, "Failed to receive a message from Overseer, exiting");
-					return;
+					return
 				},
 			};
 			match message {
 				FromOverseer::Communication {
 					msg: BitfieldDistributionMessage::DistributeBitfield(hash, signed_availability),
 				} => {
-					tracing::trace!(
-						target: LOG_TARGET,
-						?hash,
-						"Processing DistributeBitfield"
-					);
+					tracing::trace!(target: LOG_TARGET, ?hash, "Processing DistributeBitfield");
 					handle_bitfield_distribution(
 						&mut ctx,
 						&mut state,
 						&self.metrics,
 						hash,
 						signed_availability,
-					).await;
-				}
+					)
+					.await;
+				},
 				FromOverseer::Communication {
 					msg: BitfieldDistributionMessage::NetworkBridgeUpdateV1(event),
 				} => {
 					tracing::trace!(target: LOG_TARGET, "Processing NetworkMessage");
 					// a network message was received
 					handle_network_msg(&mut ctx, &mut state, &self.metrics, event).await;
-				}
-				FromOverseer::Signal(OverseerSignal::ActiveLeaves(ActiveLeavesUpdate { activated, .. })) => {
+				},
+				FromOverseer::Signal(OverseerSignal::ActiveLeaves(ActiveLeavesUpdate {
+					activated,
+					..
+				})) => {
 					let _timer = self.metrics.time_active_leaves_update();
 
 					for activated in activated {
@@ -221,41 +229,34 @@ impl BitfieldDistribution {
 									relay_parent,
 									PerRelayParentData::new(signing_context, validator_set, span),
 								);
-							}
+							},
 							Err(e) => {
 								tracing::warn!(target: LOG_TARGET, err = ?e, "query_basics has failed");
-							}
+							},
 							_ => {},
 						}
 					}
-				}
+				},
 				FromOverseer::Signal(OverseerSignal::BlockFinalized(hash, number)) => {
 					tracing::trace!(target: LOG_TARGET, hash = %hash, number = %number, "block finalized");
-				}
+				},
 				FromOverseer::Signal(OverseerSignal::Conclude) => {
 					tracing::trace!(target: LOG_TARGET, "Conclude");
-					return;
-				}
+					return
+				},
 			}
 		}
 	}
 }
 
 /// Modify the reputation of a peer based on its behavior.
-async fn modify_reputation<Context>(
-	ctx: &mut Context,
-	peer: PeerId,
-	rep: Rep,
-)
+async fn modify_reputation<Context>(ctx: &mut Context, peer: PeerId, rep: Rep)
 where
 	Context: SubsystemContext<Message = BitfieldDistributionMessage>,
 {
 	tracing::trace!(target: LOG_TARGET, ?rep, peer_id = %peer, "reputation change");
 
-	ctx.send_message(
-		NetworkBridgeMessage::ReportPeer(peer, rep),
-	)
-	.await
+	ctx.send_message(NetworkBridgeMessage::ReportPeer(peer, rep)).await
 }
 
 /// Distribute a given valid and signature checked bitfield message.
@@ -267,8 +268,7 @@ async fn handle_bitfield_distribution<Context>(
 	metrics: &Metrics,
 	relay_parent: Hash,
 	signed_availability: SignedAvailabilityBitfield,
-)
-where
+) where
 	Context: SubsystemContext<Message = BitfieldDistributionMessage>,
 {
 	let _timer = metrics.time_handle_bitfield_distribution();
@@ -284,26 +284,27 @@ where
 			"Not supposed to work on relay parent related data",
 		);
 
-		return;
+		return
 	};
 	let validator_set = &job_data.validator_set;
 	if validator_set.is_empty() {
 		tracing::trace!(target: LOG_TARGET, relay_parent = %relay_parent, "validator set is empty");
-		return;
+		return
 	}
 
 	let validator_index = signed_availability.validator_index().0 as usize;
 	let validator = if let Some(validator) = validator_set.get(validator_index) {
 		validator.clone()
 	} else {
-		tracing::trace!(target: LOG_TARGET, "Could not find a validator for index {}", validator_index);
-		return;
+		tracing::trace!(
+			target: LOG_TARGET,
+			"Could not find a validator for index {}",
+			validator_index
+		);
+		return
 	};
 
-	let msg = BitfieldGossipMessage {
-		relay_parent,
-		signed_availability,
-	};
+	let msg = BitfieldGossipMessage { relay_parent, signed_availability };
 
 	let gossip_peers = &state.gossip_peers;
 	let peer_views = &mut state.peer_views;
@@ -322,23 +323,17 @@ async fn relay_message<Context>(
 	peer_views: &mut HashMap<PeerId, View>,
 	validator: ValidatorId,
 	message: BitfieldGossipMessage,
-)
-where
+) where
 	Context: SubsystemContext<Message = BitfieldDistributionMessage>,
 {
 	let span = job_data.span.child("relay-msg");
 
 	let _span = span.child("provisionable");
 	// notify the overseer about a new and valid signed bitfield
-	ctx.send_message(
-		ProvisionerMessage::ProvisionableData(
-			message.relay_parent,
-			ProvisionableData::Bitfield(
-				message.relay_parent,
-				message.signed_availability.clone(),
-			),
-		),
-	)
+	ctx.send_message(ProvisionerMessage::ProvisionableData(
+		message.relay_parent,
+		ProvisionableData::Bitfield(message.relay_parent, message.signed_availability.clone()),
+	))
 	.await;
 
 	drop(_span);
@@ -350,7 +345,8 @@ where
 		.filter_map(|(peer, view)| {
 			// check interest in the peer in this message's relay parent
 			if view.contains(&message.relay_parent) {
-				let message_needed = job_data.message_from_validator_needed_by_peer(&peer, &validator);
+				let message_needed =
+					job_data.message_from_validator_needed_by_peer(&peer, &validator);
 				if message_needed {
 					Some(peer.clone())
 				} else {
@@ -366,14 +362,14 @@ where
 		interested_peers,
 		MIN_GOSSIP_PEERS,
 	);
-	interested_peers.iter()
-		.for_each(|peer|{
-			// track the message as sent for this peer
-			job_data.message_sent_to_peer
-				.entry(peer.clone())
-				.or_default()
-				.insert(validator.clone());
-		});
+	interested_peers.iter().for_each(|peer| {
+		// track the message as sent for this peer
+		job_data
+			.message_sent_to_peer
+			.entry(peer.clone())
+			.or_default()
+			.insert(validator.clone());
+	});
 
 	drop(_span);
 
@@ -385,12 +381,10 @@ where
 		);
 	} else {
 		let _span = span.child("gossip");
-		ctx.send_message(
-			NetworkBridgeMessage::SendValidationMessage(
-				interested_peers,
-				message.into_validation_protocol(),
-			),
-		)
+		ctx.send_message(NetworkBridgeMessage::SendValidationMessage(
+			interested_peers,
+			message.into_validation_protocol(),
+		))
 		.await;
 	}
 }
@@ -402,8 +396,7 @@ async fn process_incoming_peer_message<Context>(
 	metrics: &Metrics,
 	origin: PeerId,
 	message: protocol_v1::BitfieldDistributionMessage,
-)
-where
+) where
 	Context: SubsystemContext<Message = BitfieldDistributionMessage>,
 {
 	let protocol_v1::BitfieldDistributionMessage::Bitfield(relay_parent, bitfield) = message;
@@ -416,7 +409,7 @@ where
 	// we don't care about this, not part of our view.
 	if !state.view.contains(&relay_parent) {
 		modify_reputation(ctx, origin, COST_NOT_IN_VIEW).await;
-		return;
+		return
 	}
 
 	// Ignore anything the overseer did not tell this subsystem to work on.
@@ -425,16 +418,17 @@ where
 		job_data
 	} else {
 		modify_reputation(ctx, origin, COST_NOT_IN_VIEW).await;
-		return;
+		return
 	};
 
 	let validator_index = bitfield.unchecked_validator_index();
 
-	let mut _span = job_data.span
-			.child("msg-received")
-			.with_peer_id(&origin)
-			.with_claimed_validator_index(validator_index)
-			.with_stage(jaeger::Stage::BitfieldDistribution);
+	let mut _span = job_data
+		.span
+		.child("msg-received")
+		.with_peer_id(&origin)
+		.with_claimed_validator_index(validator_index)
+		.with_stage(jaeger::Stage::BitfieldDistribution);
 
 	let validator_set = &job_data.validator_set;
 	if validator_set.is_empty() {
@@ -445,7 +439,7 @@ where
 			"Validator set is empty",
 		);
 		modify_reputation(ctx, origin, COST_MISSING_PEER_SESSION_KEY).await;
-		return;
+		return
 	}
 
 	// Use the (untrusted) validator index provided by the signed payload
@@ -455,28 +449,20 @@ where
 		validator.clone()
 	} else {
 		modify_reputation(ctx, origin, COST_VALIDATOR_INDEX_INVALID).await;
-		return;
+		return
 	};
 
 	// Check if the peer already sent us a message for the validator denoted in the message earlier.
 	// Must be done after validator index verification, in order to avoid storing an unbounded
 	// number of set entries.
-	let received_set = job_data
-		.message_received_from_peer
-		.entry(origin.clone())
-		.or_default();
+	let received_set = job_data.message_received_from_peer.entry(origin.clone()).or_default();
 
 	if !received_set.contains(&validator) {
 		received_set.insert(validator.clone());
 	} else {
-		tracing::trace!(
-			target: LOG_TARGET,
-			?validator_index,
-			?origin,
-			"Duplicate message",
-		);
+		tracing::trace!(target: LOG_TARGET, ?validator_index, ?origin, "Duplicate message",);
 		modify_reputation(ctx, origin, COST_PEER_DUPLICATE_MESSAGE).await;
-		return;
+		return
 	};
 
 	let one_per_validator = &mut (job_data.one_per_validator);
@@ -491,25 +477,23 @@ where
 		if old_message.signed_availability.as_unchecked() == &bitfield {
 			modify_reputation(ctx, origin, BENEFIT_VALID_MESSAGE).await;
 		}
-		return;
+		return
 	}
 	let signed_availability = match bitfield.try_into_checked(&signing_context, &validator) {
 		Err(_) => {
 			modify_reputation(ctx, origin, COST_SIGNATURE_INVALID).await;
-			return;
+			return
 		},
 		Ok(bitfield) => bitfield,
 	};
 
-	let message = BitfieldGossipMessage {
-		relay_parent,
-		signed_availability,
-	};
+	let message = BitfieldGossipMessage { relay_parent, signed_availability };
 
 	metrics.on_bitfield_received();
 	one_per_validator.insert(validator.clone(), message.clone());
 
-	relay_message(ctx, job_data, &state.gossip_peers, &mut state.peer_views, validator, message).await;
+	relay_message(ctx, job_data, &state.gossip_peers, &mut state.peer_views, validator, message)
+		.await;
 
 	modify_reputation(ctx, origin, BENEFIT_VALID_MESSAGE_FIRST).await
 }
@@ -521,32 +505,22 @@ async fn handle_network_msg<Context>(
 	state: &mut ProtocolState,
 	metrics: &Metrics,
 	bridge_message: NetworkBridgeEvent<protocol_v1::BitfieldDistributionMessage>,
-)
-where
+) where
 	Context: SubsystemContext<Message = BitfieldDistributionMessage>,
 {
 	let _timer = metrics.time_handle_network_msg();
 
 	match bridge_message {
 		NetworkBridgeEvent::PeerConnected(peerid, role, _) => {
-			tracing::trace!(
-				target: LOG_TARGET,
-				?peerid,
-				?role,
-				"Peer connected",
-			);
+			tracing::trace!(target: LOG_TARGET, ?peerid, ?role, "Peer connected",);
 			// insert if none already present
 			state.peer_views.entry(peerid).or_default();
-		}
+		},
 		NetworkBridgeEvent::PeerDisconnected(peerid) => {
-			tracing::trace!(
-				target: LOG_TARGET,
-				?peerid,
-				"Peer disconnected",
-			);
+			tracing::trace!(target: LOG_TARGET, ?peerid, "Peer disconnected",);
 			// get rid of superfluous data
 			state.peer_views.remove(&peerid);
-		}
+		},
 		NetworkBridgeEvent::NewGossipTopology(peers) => {
 			let newly_added: Vec<PeerId> = peers.difference(&state.gossip_peers).cloned().collect();
 			state.gossip_peers = peers;
@@ -555,24 +529,15 @@ where
 					handle_peer_view_change(ctx, state, peer, view).await;
 				}
 			}
-		}
+		},
 		NetworkBridgeEvent::PeerViewChange(peerid, view) => {
-			tracing::trace!(
-				target: LOG_TARGET,
-				?peerid,
-				?view,
-				"Peer view change",
-			);
+			tracing::trace!(target: LOG_TARGET, ?peerid, ?view, "Peer view change",);
 			handle_peer_view_change(ctx, state, peerid, view).await;
-		}
+		},
 		NetworkBridgeEvent::OurViewChange(view) => {
-			tracing::trace!(
-				target: LOG_TARGET,
-				?view,
-				"Our view change",
-			);
+			tracing::trace!(target: LOG_TARGET, ?view, "Our view change",);
 			handle_our_view_change(state, view);
-		}
+		},
 		NetworkBridgeEvent::PeerMessage(remote, message) =>
 			process_incoming_peer_message(ctx, state, metrics, remote, message).await,
 	}
@@ -598,7 +563,6 @@ fn handle_our_view_change(state: &mut ProtocolState, view: OurView) {
 	}
 }
 
-
 // Send the difference between two views which were not sent
 // to that particular peer.
 async fn handle_peer_view_change<Context>(
@@ -606,25 +570,27 @@ async fn handle_peer_view_change<Context>(
 	state: &mut ProtocolState,
 	origin: PeerId,
 	view: View,
-)
-where
+) where
 	Context: SubsystemContext<Message = BitfieldDistributionMessage>,
 {
-	let added = state.peer_views.entry(origin.clone()).or_default().replace_difference(view).cloned().collect::<Vec<_>>();
+	let added = state
+		.peer_views
+		.entry(origin.clone())
+		.or_default()
+		.replace_difference(view)
+		.cloned()
+		.collect::<Vec<_>>();
 
 	let is_gossip_peer = state.gossip_peers.contains(&origin);
-	let lucky = is_gossip_peer || util::gen_ratio(
-		util::MIN_GOSSIP_PEERS.saturating_sub(state.gossip_peers.len()),
-		util::MIN_GOSSIP_PEERS,
-	);
+	let lucky = is_gossip_peer ||
+		util::gen_ratio(
+			util::MIN_GOSSIP_PEERS.saturating_sub(state.gossip_peers.len()),
+			util::MIN_GOSSIP_PEERS,
+		);
 
 	if !lucky {
-		tracing::trace!(
-			target: LOG_TARGET,
-			?origin,
-			"Peer view change is ignored",
-		);
-		return;
+		tracing::trace!(target: LOG_TARGET, ?origin, "Peer view change is ignored",);
+		return
 	}
 
 	// Send all messages we've seen before and the peer is now interested
@@ -637,14 +603,10 @@ where
 				// to the peer `origin`...
 				let one_per_validator = job_data.one_per_validator.clone();
 				let origin = origin.clone();
-				Some(
-					one_per_validator
-						.into_iter()
-						.filter(move |(validator, _message)| {
-							// ..except for the ones the peer already has.
-							job_data.message_from_validator_needed_by_peer(&origin, validator)
-						}),
-				)
+				Some(one_per_validator.into_iter().filter(move |(validator, _message)| {
+					// ..except for the ones the peer already has.
+					job_data.message_from_validator_needed_by_peer(&origin, validator)
+				}))
 			} else {
 				// A relay parent is in the peers view, which is not in ours, ignore those.
 				None
@@ -665,14 +627,13 @@ async fn send_tracked_gossip_message<Context>(
 	dest: PeerId,
 	validator: ValidatorId,
 	message: BitfieldGossipMessage,
-)
-where
+) where
 	Context: SubsystemContext<Message = BitfieldDistributionMessage>,
 {
 	let job_data = if let Some(job_data) = state.per_relay_parent.get_mut(&message.relay_parent) {
 		job_data
 	} else {
-		return;
+		return
 	};
 
 	let _span = job_data.span.child("gossip");
@@ -684,17 +645,17 @@ where
 		"Sending gossip message"
 	);
 
-	job_data.message_sent_to_peer
+	job_data
+		.message_sent_to_peer
 		.entry(dest.clone())
 		.or_default()
 		.insert(validator.clone());
 
-	ctx.send_message(
-		NetworkBridgeMessage::SendValidationMessage(
-			vec![dest],
-			message.into_validation_protocol(),
-		),
-	).await;
+	ctx.send_message(NetworkBridgeMessage::SendValidationMessage(
+		vec![dest],
+		message.into_validation_protocol(),
+	))
+	.await;
 }
 
 impl<Context> overseer::Subsystem<Context, SubsystemError> for BitfieldDistribution
@@ -703,14 +664,9 @@ where
 	Context: overseer::SubsystemContext<Message = BitfieldDistributionMessage>,
 {
 	fn start(self, ctx: Context) -> SpawnedSubsystem {
-		let future = self.run(ctx)
-			.map(|_| Ok(()))
-			.boxed();
+		let future = self.run(ctx).map(|_| Ok(())).boxed();
 
-		SpawnedSubsystem {
-			name: "bitfield-distribution-subsystem",
-			future,
-		}
+		SpawnedSubsystem { name: "bitfield-distribution-subsystem", future }
 	}
 }
 
@@ -729,23 +685,23 @@ where
 	ctx.send_message(RuntimeApiMessage::Request(
 		relay_parent.clone(),
 		RuntimeApiRequest::Validators(validators_tx),
-	)).await;
+	))
+	.await;
 
 	// query signing context
 	ctx.send_message(RuntimeApiMessage::Request(
 		relay_parent.clone(),
 		RuntimeApiRequest::SessionIndexForChild(session_tx),
-	)).await;
+	))
+	.await;
 
 	match (validators_rx.await?, session_rx.await?) {
-		(Ok(v), Ok(s)) => Ok(Some((
-			v,
-			SigningContext { parent_hash: relay_parent, session_index: s },
-		))),
+		(Ok(v), Ok(s)) =>
+			Ok(Some((v, SigningContext { parent_hash: relay_parent, session_index: s }))),
 		(Err(e), _) | (_, Err(e)) => {
 			tracing::warn!(target: LOG_TARGET, err = ?e, "Failed to fetch basics from runtime API");
 			Ok(None)
-		}
+		},
 	}
 }
 
@@ -781,8 +737,12 @@ impl Metrics {
 	}
 
 	/// Provide a timer for `handle_bitfield_distribution` which observes on drop.
-	fn time_handle_bitfield_distribution(&self) -> Option<metrics::prometheus::prometheus::HistogramTimer> {
-		self.0.as_ref().map(|metrics| metrics.handle_bitfield_distribution.start_timer())
+	fn time_handle_bitfield_distribution(
+		&self,
+	) -> Option<metrics::prometheus::prometheus::HistogramTimer> {
+		self.0
+			.as_ref()
+			.map(|metrics| metrics.handle_bitfield_distribution.start_timer())
 	}
 
 	/// Provide a timer for `handle_network_msg` which observes on drop.
@@ -797,42 +757,36 @@ impl metrics::Metrics for Metrics {
 			gossipped_own_availability_bitfields: prometheus::register(
 				prometheus::Counter::new(
 					"parachain_gossipped_own_availabilty_bitfields_total",
-					"Number of own availability bitfields sent to other peers."
+					"Number of own availability bitfields sent to other peers.",
 				)?,
 				registry,
 			)?,
 			received_availability_bitfields: prometheus::register(
 				prometheus::Counter::new(
 					"parachain_received_availabilty_bitfields_total",
-					"Number of valid availability bitfields received from other peers."
+					"Number of valid availability bitfields received from other peers.",
 				)?,
 				registry,
 			)?,
 			active_leaves_update: prometheus::register(
-				prometheus::Histogram::with_opts(
-					prometheus::HistogramOpts::new(
-						"parachain_bitfield_distribution_active_leaves_update",
-						"Time spent within `bitfield_distribution::active_leaves_update`",
-					)
-				)?,
+				prometheus::Histogram::with_opts(prometheus::HistogramOpts::new(
+					"parachain_bitfield_distribution_active_leaves_update",
+					"Time spent within `bitfield_distribution::active_leaves_update`",
+				))?,
 				registry,
 			)?,
 			handle_bitfield_distribution: prometheus::register(
-				prometheus::Histogram::with_opts(
-					prometheus::HistogramOpts::new(
-						"parachain_bitfield_distribution_handle_bitfield_distribution",
-						"Time spent within `bitfield_distribution::handle_bitfield_distribution`",
-					)
-				)?,
+				prometheus::Histogram::with_opts(prometheus::HistogramOpts::new(
+					"parachain_bitfield_distribution_handle_bitfield_distribution",
+					"Time spent within `bitfield_distribution::handle_bitfield_distribution`",
+				))?,
 				registry,
 			)?,
 			handle_network_msg: prometheus::register(
-				prometheus::Histogram::with_opts(
-					prometheus::HistogramOpts::new(
-						"parachain_bitfield_distribution_handle_network_msg",
-						"Time spent within `bitfield_distribution::handle_network_msg`",
-					)
-				)?,
+				prometheus::Histogram::with_opts(prometheus::HistogramOpts::new(
+					"parachain_bitfield_distribution_handle_network_msg",
+					"Time spent within `bitfield_distribution::handle_network_msg`",
+				))?,
 				registry,
 			)?,
 		};

polkadot/node/network/bitfield-distribution/src/tests.rs

@@ -15,28 +15,24 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use super::*;
+use assert_matches::assert_matches;
 use bitvec::bitvec;
 use futures::executor;
 use maplit::hashmap;
-use polkadot_primitives::v1::{Signed, AvailabilityBitfield, ValidatorIndex};
+use polkadot_node_network_protocol::{our_view, view, ObservedRole};
 use polkadot_node_subsystem_test_helpers::make_subsystem_context;
 use polkadot_node_subsystem_util::TimeoutExt;
-use sp_keystore::{SyncCryptoStorePtr, SyncCryptoStore};
-use sp_application_crypto::AppKey;
-use sp_keystore::testing::KeyStore;
-use std::sync::Arc;
-use std::time::Duration;
-use std::iter::FromIterator as _;
-use assert_matches::assert_matches;
-use polkadot_node_network_protocol::{view, ObservedRole, our_view};
+use polkadot_primitives::v1::{AvailabilityBitfield, Signed, ValidatorIndex};
 use polkadot_subsystem::jaeger;
+use sp_application_crypto::AppKey;
+use sp_keystore::{testing::KeyStore, SyncCryptoStore, SyncCryptoStorePtr};
+use std::{iter::FromIterator as _, sync::Arc, time::Duration};
 
 macro_rules! launch {
 	($fut:expr) => {
-		$fut
-		.timeout(Duration::from_millis(10))
-		.await
-		.expect("10ms is more than enough for sending messages.")
+		$fut.timeout(Duration::from_millis(10))
+			.await
+			.expect("10ms is more than enough for sending messages.")
 	};
 }
 
@@ -64,11 +60,7 @@ fn prewarmed_state(
 					span: PerLeafSpan::new(Arc::new(jaeger::Span::Disabled), "test"),
 				},
 		},
-		peer_views: peers
-			.iter()
-			.cloned()
-			.map(|peer| (peer, view!(relay_parent)))
-			.collect(),
+		peer_views: peers.iter().cloned().map(|peer| (peer, view!(relay_parent))).collect(),
 		gossip_peers: peers.into_iter().collect(),
 		view: our_view!(relay_parent),
 	}
@@ -80,26 +72,28 @@ fn state_with_view(
 ) -> (ProtocolState, SigningContext, SyncCryptoStorePtr, ValidatorId) {
 	let mut state = ProtocolState::default();
 
-	let signing_context = SigningContext {
-		session_index: 1,
-		parent_hash: relay_parent.clone(),
-	};
+	let signing_context = SigningContext { session_index: 1, parent_hash: relay_parent.clone() };
 
-	let keystore : SyncCryptoStorePtr = Arc::new(KeyStore::new());
+	let keystore: SyncCryptoStorePtr = Arc::new(KeyStore::new());
 	let validator = SyncCryptoStore::sr25519_generate_new(&*keystore, ValidatorId::ID, None)
 		.expect("generating sr25519 key not to fail");
 
-	state.per_relay_parent = view.iter().map(|relay_parent| {(
-			relay_parent.clone(),
-			PerRelayParentData {
-				signing_context: signing_context.clone(),
-				validator_set: vec![validator.clone().into()],
-				one_per_validator: hashmap!{},
-				message_received_from_peer: hashmap!{},
-				message_sent_to_peer: hashmap!{},
-				span: PerLeafSpan::new(Arc::new(jaeger::Span::Disabled), "test"),
-			})
-		}).collect();
+	state.per_relay_parent = view
+		.iter()
+		.map(|relay_parent| {
+			(
+				relay_parent.clone(),
+				PerRelayParentData {
+					signing_context: signing_context.clone(),
+					validator_set: vec![validator.clone().into()],
+					one_per_validator: hashmap! {},
+					message_received_from_peer: hashmap! {},
+					message_sent_to_peer: hashmap! {},
+					span: PerLeafSpan::new(Arc::new(jaeger::Span::Disabled), "test"),
+				},
+			)
+		})
+		.collect();
 
 	state.view = view;
 
@@ -119,13 +113,10 @@ fn receive_invalid_signature() {
 	let peer_b = PeerId::random();
 	assert_ne!(peer_a, peer_b);
 
-	let signing_context = SigningContext {
-		session_index: 1,
-		parent_hash: hash_a.clone(),
-	};
+	let signing_context = SigningContext { session_index: 1, parent_hash: hash_a.clone() };
 
 	// another validator not part of the validatorset
-	let keystore : SyncCryptoStorePtr = Arc::new(KeyStore::new());
+	let keystore: SyncCryptoStorePtr = Arc::new(KeyStore::new());
 	let malicious = SyncCryptoStore::sr25519_generate_new(&*keystore, ValidatorId::ID, None)
 		.expect("Malicious key created");
 	let validator_0 = SyncCryptoStore::sr25519_generate_new(&*keystore, ValidatorId::ID, None)
@@ -140,14 +131,20 @@ fn receive_invalid_signature() {
 		&signing_context,
 		ValidatorIndex(0),
 		&malicious.into(),
-	)).ok().flatten().expect("should be signed");
+	))
+	.ok()
+	.flatten()
+	.expect("should be signed");
 	let invalid_signed_2 = executor::block_on(Signed::<AvailabilityBitfield>::sign(
 		&keystore,
 		payload.clone(),
 		&signing_context,
 		ValidatorIndex(1),
 		&malicious.into(),
-	)).ok().flatten().expect("should be signed");
+	))
+	.ok()
+	.flatten()
+	.expect("should be signed");
 
 	let valid_signed = executor::block_on(Signed::<AvailabilityBitfield>::sign(
 		&keystore,
@@ -155,7 +152,10 @@ fn receive_invalid_signature() {
 		&signing_context,
 		ValidatorIndex(0),
 		&validator_0.into(),
-	)).ok().flatten().expect("should be signed");
+	))
+	.ok()
+	.flatten()
+	.expect("should be signed");
 
 	let invalid_msg = BitfieldGossipMessage {
 		relay_parent: hash_a.clone(),
@@ -171,8 +171,7 @@ fn receive_invalid_signature() {
 	};
 
 	let pool = sp_core::testing::TaskExecutor::new();
-	let (mut ctx, mut handle) =
-		make_subsystem_context::<BitfieldDistributionMessage, _>(pool);
+	let (mut ctx, mut handle) = make_subsystem_context::<BitfieldDistributionMessage, _>(pool);
 
 	let mut state = prewarmed_state(
 		validator_0.into(),
@@ -180,7 +179,9 @@ fn receive_invalid_signature() {
 		valid_msg,
 		vec![peer_b.clone()],
 	);
-	state.per_relay_parent.get_mut(&hash_a)
+	state
+		.per_relay_parent
+		.get_mut(&hash_a)
 		.unwrap()
 		.validator_set
 		.push(validator_1.into());
@@ -230,7 +231,8 @@ fn receive_invalid_validator_index() {
 	assert_ne!(peer_a, peer_b);
 
 	// validator 0 key pair
-	let (mut state, signing_context, keystore, validator) = state_with_view(our_view![hash_a, hash_b], hash_a.clone());
+	let (mut state, signing_context, keystore, validator) =
+		state_with_view(our_view![hash_a, hash_b], hash_a.clone());
 
 	state.peer_views.insert(peer_b.clone(), view![hash_a]);
 
@@ -241,16 +243,16 @@ fn receive_invalid_validator_index() {
 		&signing_context,
 		ValidatorIndex(42),
 		&validator,
-	)).ok().flatten().expect("should be signed");
+	))
+	.ok()
+	.flatten()
+	.expect("should be signed");
 
-	let msg = BitfieldGossipMessage {
-		relay_parent: hash_a.clone(),
-		signed_availability: signed.clone(),
-	};
+	let msg =
+		BitfieldGossipMessage { relay_parent: hash_a.clone(), signed_availability: signed.clone() };
 
 	let pool = sp_core::testing::TaskExecutor::new();
-	let (mut ctx, mut handle) =
-		make_subsystem_context::<BitfieldDistributionMessage, _>(pool);
+	let (mut ctx, mut handle) = make_subsystem_context::<BitfieldDistributionMessage, _>(pool);
 
 	executor::block_on(async move {
 		launch!(handle_network_msg(
@@ -288,7 +290,8 @@ fn receive_duplicate_messages() {
 	assert_ne!(peer_a, peer_b);
 
 	// validator 0 key pair
-	let (mut state, signing_context, keystore, validator) = state_with_view(our_view![hash_a, hash_b], hash_a.clone());
+	let (mut state, signing_context, keystore, validator) =
+		state_with_view(our_view![hash_a, hash_b], hash_a.clone());
 
 	// create a signed message by validator 0
 	let payload = AvailabilityBitfield(bitvec![bitvec::order::Lsb0, u8; 1u8; 32]);
@@ -298,7 +301,10 @@ fn receive_duplicate_messages() {
 		&signing_context,
 		ValidatorIndex(0),
 		&validator,
-	)).ok().flatten().expect("should be signed");
+	))
+	.ok()
+	.flatten()
+	.expect("should be signed");
 
 	let msg = BitfieldGossipMessage {
 		relay_parent: hash_a.clone(),
@@ -306,8 +312,7 @@ fn receive_duplicate_messages() {
 	};
 
 	let pool = sp_core::testing::TaskExecutor::new();
-	let (mut ctx, mut handle) =
-		make_subsystem_context::<BitfieldDistributionMessage, _>(pool);
+	let (mut ctx, mut handle) = make_subsystem_context::<BitfieldDistributionMessage, _>(pool);
 
 	executor::block_on(async move {
 		// send a first message
@@ -315,10 +320,7 @@ fn receive_duplicate_messages() {
 			&mut ctx,
 			&mut state,
 			&Default::default(),
-			NetworkBridgeEvent::PeerMessage(
-				peer_b.clone(),
-				msg.clone().into_network_message(),
-			),
+			NetworkBridgeEvent::PeerMessage(peer_b.clone(), msg.clone().into_network_message(),),
 		));
 
 		// none of our peers has any interest in any messages
@@ -350,10 +352,7 @@ fn receive_duplicate_messages() {
 			&mut ctx,
 			&mut state,
 			&Default::default(),
-			NetworkBridgeEvent::PeerMessage(
-				peer_a.clone(),
-				msg.clone().into_network_message(),
-			),
+			NetworkBridgeEvent::PeerMessage(peer_a.clone(), msg.clone().into_network_message(),),
 		));
 
 		assert_matches!(
@@ -371,10 +370,7 @@ fn receive_duplicate_messages() {
 			&mut ctx,
 			&mut state,
 			&Default::default(),
-			NetworkBridgeEvent::PeerMessage(
-				peer_b.clone(),
-				msg.clone().into_network_message(),
-			),
+			NetworkBridgeEvent::PeerMessage(peer_b.clone(), msg.clone().into_network_message(),),
 		));
 
 		assert_matches!(
@@ -403,7 +399,8 @@ fn do_not_relay_message_twice() {
 	assert_ne!(peer_a, peer_b);
 
 	// validator 0 key pair
-	let (mut state, signing_context, keystore, validator) = state_with_view(our_view![hash], hash.clone());
+	let (mut state, signing_context, keystore, validator) =
+		state_with_view(our_view![hash], hash.clone());
 
 	// create a signed message by validator 0
 	let payload = AvailabilityBitfield(bitvec![bitvec::order::Lsb0, u8; 1u8; 32]);
@@ -413,7 +410,10 @@ fn do_not_relay_message_twice() {
 		&signing_context,
 		ValidatorIndex(0),
 		&validator,
-	)).ok().flatten().expect("should be signed");
+	))
+	.ok()
+	.flatten()
+	.expect("should be signed");
 
 	state.peer_views.insert(peer_b.clone(), view![hash]);
 	state.peer_views.insert(peer_a.clone(), view![hash]);
@@ -424,13 +424,10 @@ fn do_not_relay_message_twice() {
 	};
 
 	let pool = sp_core::testing::TaskExecutor::new();
-	let (mut ctx, mut handle) =
-		make_subsystem_context::<BitfieldDistributionMessage, _>(pool);
+	let (mut ctx, mut handle) = make_subsystem_context::<BitfieldDistributionMessage, _>(pool);
 
 	executor::block_on(async move {
-		let gossip_peers = HashSet::from_iter(vec![
-			peer_a.clone(), peer_b.clone(),
-		].into_iter());
+		let gossip_peers = HashSet::from_iter(vec![peer_a.clone(), peer_b.clone()].into_iter());
 		relay_message(
 			&mut ctx,
 			state.per_relay_parent.get_mut(&hash).unwrap(),
@@ -438,7 +435,8 @@ fn do_not_relay_message_twice() {
 			&mut state.peer_views,
 			validator.clone(),
 			msg.clone(),
-		).await;
+		)
+		.await;
 
 		assert_matches!(
 			handle.recv().await,
@@ -471,7 +469,8 @@ fn do_not_relay_message_twice() {
 			&mut state.peer_views,
 			validator.clone(),
 			msg.clone(),
-		).await;
+		)
+		.await;
 
 		assert_matches!(
 			handle.recv().await,
@@ -504,7 +503,8 @@ fn changing_view() {
 	assert_ne!(peer_a, peer_b);
 
 	// validator 0 key pair
-	let (mut state, signing_context, keystore, validator) = state_with_view(our_view![hash_a, hash_b], hash_a.clone());
+	let (mut state, signing_context, keystore, validator) =
+		state_with_view(our_view![hash_a, hash_b], hash_a.clone());
 
 	// create a signed message by validator 0
 	let payload = AvailabilityBitfield(bitvec![bitvec::order::Lsb0, u8; 1u8; 32]);
@@ -514,7 +514,10 @@ fn changing_view() {
 		&signing_context,
 		ValidatorIndex(0),
 		&validator,
-	)).ok().flatten().expect("should be signed");
+	))
+	.ok()
+	.flatten()
+	.expect("should be signed");
 
 	let msg = BitfieldGossipMessage {
 		relay_parent: hash_a.clone(),
@@ -522,8 +525,7 @@ fn changing_view() {
 	};
 
 	let pool = sp_core::testing::TaskExecutor::new();
-	let (mut ctx, mut handle) =
-		make_subsystem_context::<BitfieldDistributionMessage, _>(pool);
+	let (mut ctx, mut handle) = make_subsystem_context::<BitfieldDistributionMessage, _>(pool);
 
 	executor::block_on(async move {
 		launch!(handle_network_msg(
@@ -548,10 +550,7 @@ fn changing_view() {
 			&mut ctx,
 			&mut state,
 			&Default::default(),
-			NetworkBridgeEvent::PeerMessage(
-				peer_b.clone(),
-				msg.clone().into_network_message(),
-			),
+			NetworkBridgeEvent::PeerMessage(peer_b.clone(), msg.clone().into_network_message(),),
 		));
 
 		// gossip to the overseer
@@ -585,10 +584,7 @@ fn changing_view() {
 		));
 
 		assert!(state.peer_views.contains_key(&peer_b));
-		assert_eq!(
-			state.peer_views.get(&peer_b).expect("Must contain value for peer B"),
-			&view![]
-		);
+		assert_eq!(state.peer_views.get(&peer_b).expect("Must contain value for peer B"), &view![]);
 
 		// on rx of the same message, since we are not interested,
 		// should give penalty
@@ -596,10 +592,7 @@ fn changing_view() {
 			&mut ctx,
 			&mut state,
 			&Default::default(),
-			NetworkBridgeEvent::PeerMessage(
-				peer_b.clone(),
-				msg.clone().into_network_message(),
-			),
+			NetworkBridgeEvent::PeerMessage(peer_b.clone(), msg.clone().into_network_message(),),
 		));
 
 		// reputation change for peer B
@@ -629,10 +622,7 @@ fn changing_view() {
 			&mut ctx,
 			&mut state,
 			&Default::default(),
-			NetworkBridgeEvent::PeerMessage(
-				peer_a.clone(),
-				msg.clone().into_network_message(),
-			),
+			NetworkBridgeEvent::PeerMessage(peer_a.clone(), msg.clone().into_network_message(),),
 		));
 
 		// reputation change for peer B
@@ -645,7 +635,6 @@ fn changing_view() {
 				assert_eq!(rep, COST_NOT_IN_VIEW)
 			}
 		);
-
 	});
 }
 
@@ -673,7 +662,10 @@ fn do_not_send_message_back_to_origin() {
 		&signing_context,
 		ValidatorIndex(0),
 		&validator,
-	)).ok().flatten().expect("should be signed");
+	))
+	.ok()
+	.flatten()
+	.expect("should be signed");
 
 	state.peer_views.insert(peer_b.clone(), view![hash]);
 	state.peer_views.insert(peer_a.clone(), view![hash]);
@@ -684,8 +676,7 @@ fn do_not_send_message_back_to_origin() {
 	};
 
 	let pool = sp_core::testing::TaskExecutor::new();
-	let (mut ctx, mut handle) =
-		make_subsystem_context::<BitfieldDistributionMessage, _>(pool);
+	let (mut ctx, mut handle) = make_subsystem_context::<BitfieldDistributionMessage, _>(pool);
 
 	executor::block_on(async move {
 		// send a first message
@@ -693,10 +684,7 @@ fn do_not_send_message_back_to_origin() {
 			&mut ctx,
 			&mut state,
 			&Default::default(),
-			NetworkBridgeEvent::PeerMessage(
-				peer_b.clone(),
-				msg.clone().into_network_message(),
-			),
+			NetworkBridgeEvent::PeerMessage(peer_b.clone(), msg.clone().into_network_message(),),
 		));
 
 		assert_matches!(