cargo +nightly fmt (#3540)

* cargo +nightly fmt

* add cargo-fmt check to ci

* update ci

* fmt

* fmt

* skip macro

* ignore bridges

polkadot/node/core/pvf/src/prepare/mod.rs

@@ -26,6 +26,6 @@ mod pool;
 mod queue;
 mod worker;
 
-pub use queue::{ToQueue, FromQueue, start as start_queue};
 pub use pool::start as start_pool;
+pub use queue::{start as start_queue, FromQueue, ToQueue};
 pub use worker::worker_entrypoint;

polkadot/node/core/pvf/src/prepare/pool.rs

@@ -14,21 +14,19 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
+use super::worker::{self, Outcome};
 use crate::{
 	worker_common::{IdleWorker, WorkerHandle},
 	LOG_TARGET,
 };
-use super::{
-	worker::{self, Outcome},
-};
-use std::{fmt, sync::Arc, task::Poll, time::Duration};
+use always_assert::never;
+use assert_matches::assert_matches;
 use async_std::path::{Path, PathBuf};
 use futures::{
-	Future, FutureExt, StreamExt, channel::mpsc, future::BoxFuture, stream::FuturesUnordered,
+	channel::mpsc, future::BoxFuture, stream::FuturesUnordered, Future, FutureExt, StreamExt,
 };
 use slotmap::HopSlotMap;
-use assert_matches::assert_matches;
-use always_assert::never;
+use std::{fmt, sync::Arc, task::Poll, time::Duration};
 
 slotmap::new_key_type! { pub struct Worker; }
 
@@ -170,7 +168,7 @@ async fn purge_dead(
 			// The idle token is missing, meaning this worker is now occupied: skip it. This is
 			// because the worker process is observed by the work task and should it reach the
 			// deadline or be terminated it will be handled by the corresponding mux event.
-			continue;
+			continue
 		}
 
 		if let Poll::Ready(()) = futures::poll!(&mut data.handle) {
@@ -197,13 +195,8 @@ fn handle_to_pool(
 	match to_pool {
 		ToPool::Spawn => {
 			mux.push(spawn_worker_task(program_path.to_owned(), spawn_timeout).boxed());
-		}
-		ToPool::StartWork {
-			worker,
-			code,
-			artifact_path,
-			background_priority,
-		} => {
+		},
+		ToPool::StartWork { worker, code, artifact_path, background_priority } => {
 			if let Some(data) = spawned.get_mut(worker) {
 				if let Some(idle) = data.idle.take() {
 					mux.push(
@@ -213,7 +206,7 @@ fn handle_to_pool(
 							code,
 							cache_path.to_owned(),
 							artifact_path,
-							background_priority
+							background_priority,
 						)
 						.boxed(),
 					);
@@ -229,16 +222,15 @@ fn handle_to_pool(
 				// That's a relatively normal situation since the queue may send `start_work` and
 				// before receiving it the pool would report that the worker died.
 			}
-		}
+		},
 		ToPool::Kill(worker) => {
 			// It may be absent if it were previously already removed by `purge_dead`.
 			let _ = spawned.remove(worker);
-		}
-		ToPool::BumpPriority(worker) => {
+		},
+		ToPool::BumpPriority(worker) =>
 			if let Some(data) = spawned.get(worker) {
 				worker::bump_priority(&data.handle);
-			}
-		}
+			},
 	}
 }
 
@@ -249,15 +241,11 @@ async fn spawn_worker_task(program_path: PathBuf, spawn_timeout: Duration) -> Po
 		match worker::spawn(&program_path, spawn_timeout).await {
 			Ok((idle, handle)) => break PoolEvent::Spawn(idle, handle),
 			Err(err) => {
-				tracing::warn!(
-					target: LOG_TARGET,
-					"failed to spawn a prepare worker: {:?}",
-					err,
-				);
+				tracing::warn!(target: LOG_TARGET, "failed to spawn a prepare worker: {:?}", err,);
 
 				// Assume that the failure intermittent and retry after a delay.
 				Delay::new(Duration::from_secs(3)).await;
-			}
+			},
 		}
 	}
 }
@@ -282,15 +270,12 @@ fn handle_mux(
 ) -> Result<(), Fatal> {
 	match event {
 		PoolEvent::Spawn(idle, handle) => {
-			let worker = spawned.insert(WorkerData {
-				idle: Some(idle),
-				handle,
-			});
+			let worker = spawned.insert(WorkerData { idle: Some(idle), handle });
 
 			reply(from_pool, FromPool::Spawned(worker))?;
 
 			Ok(())
-		}
+		},
 		PoolEvent::StartWork(worker, outcome) => {
 			match outcome {
 				Outcome::Concluded(idle) => {
@@ -298,8 +283,8 @@ fn handle_mux(
 						None => {
 							// Perhaps the worker was killed meanwhile and the result is no longer
 							// relevant.
-							return Ok(());
-						}
+							return Ok(())
+						},
 						Some(data) => data,
 					};
 
@@ -311,23 +296,23 @@ fn handle_mux(
 					reply(from_pool, FromPool::Concluded(worker, false))?;
 
 					Ok(())
-				}
+				},
 				Outcome::Unreachable => {
 					if spawned.remove(worker).is_some() {
 						reply(from_pool, FromPool::Rip(worker))?;
 					}
 
 					Ok(())
-				}
+				},
 				Outcome::DidntMakeIt => {
 					if spawned.remove(worker).is_some() {
 						reply(from_pool, FromPool::Concluded(worker, true))?;
 					}
 
 					Ok(())
-				}
+				},
 			}
-		}
+		},
 	}
 }
 
@@ -340,11 +325,7 @@ pub fn start(
 	program_path: PathBuf,
 	cache_path: PathBuf,
 	spawn_timeout: Duration,
-) -> (
-	mpsc::Sender<ToPool>,
-	mpsc::UnboundedReceiver<FromPool>,
-	impl Future<Output = ()>,
-) {
+) -> (mpsc::Sender<ToPool>, mpsc::UnboundedReceiver<FromPool>, impl Future<Output = ()>) {
 	let (to_pool_tx, to_pool_rx) = mpsc::channel(10);
 	let (from_pool_tx, from_pool_rx) = mpsc::unbounded();
 

polkadot/node/core/pvf/src/prepare/queue.rs

@@ -16,14 +16,12 @@
 
 //! A queue that handles requests for PVF preparation.
 
-use super::{
-	pool::{self, Worker},
-};
-use crate::{LOG_TARGET, Priority, Pvf, artifacts::ArtifactId};
-use futures::{Future, SinkExt, channel::mpsc, stream::StreamExt as _};
-use std::collections::{HashMap, VecDeque};
-use async_std::path::PathBuf;
+use super::pool::{self, Worker};
+use crate::{artifacts::ArtifactId, Priority, Pvf, LOG_TARGET};
 use always_assert::{always, never};
+use async_std::path::PathBuf;
+use futures::{channel::mpsc, stream::StreamExt as _, Future, SinkExt};
+use std::collections::{HashMap, VecDeque};
 
 /// A request to pool.
 #[derive(Debug)]
@@ -35,10 +33,7 @@ pub enum ToQueue {
 	/// [`ToQueue::Amend`].
 	Enqueue { priority: Priority, pvf: Pvf },
 	/// Amends the priority for the given [`ArtifactId`] if it is running. If it's not, then it's noop.
-	Amend {
-		priority: Priority,
-		artifact_id: ArtifactId,
-	},
+	Amend { priority: Priority, artifact_id: ArtifactId },
 }
 
 /// A response from queue.
@@ -62,11 +57,7 @@ struct Limits {
 impl Limits {
 	/// Returns `true` if the queue is allowed to request one more worker.
 	fn can_afford_one_more(&self, spawned_num: usize, critical: bool) -> bool {
-		let cap = if critical {
-			self.hard_capacity
-		} else {
-			self.soft_capacity
-		};
+		let cap = if critical { self.hard_capacity } else { self.soft_capacity };
 		spawned_num < cap
 	}
 
@@ -179,10 +170,7 @@ impl Queue {
 			from_pool_rx,
 			cache_path,
 			spawn_inflight: 0,
-			limits: Limits {
-				hard_capacity,
-				soft_capacity,
-			},
+			limits: Limits { hard_capacity, soft_capacity },
 			jobs: slotmap::SlotMap::with_key(),
 			unscheduled: Unscheduled::default(),
 			artifact_id_to_job: HashMap::new(),
@@ -194,7 +182,7 @@ impl Queue {
 		macro_rules! break_if_fatal {
 			($expr:expr) => {
 				if let Err(Fatal) = $expr {
-					break;
+					break
 				}
 			};
 		}
@@ -215,13 +203,10 @@ async fn handle_to_queue(queue: &mut Queue, to_queue: ToQueue) -> Result<(), Fat
 	match to_queue {
 		ToQueue::Enqueue { priority, pvf } => {
 			handle_enqueue(queue, priority, pvf).await?;
-		}
-		ToQueue::Amend {
-			priority,
-			artifact_id,
-		} => {
+		},
+		ToQueue::Amend { priority, artifact_id } => {
 			handle_amend(queue, priority, artifact_id).await?;
-		}
+		},
 	}
 	Ok(())
 }
@@ -241,14 +226,10 @@ async fn handle_enqueue(queue: &mut Queue, priority: Priority, pvf: Pvf) -> Resu
 			"duplicate `enqueue` command received for {:?}",
 			artifact_id,
 		);
-		return Ok(());
+		return Ok(())
 	}
 
-	let job = queue.jobs.insert(JobData {
-		priority,
-		pvf,
-		worker: None,
-	});
+	let job = queue.jobs.insert(JobData { priority, pvf, worker: None });
 	queue.artifact_id_to_job.insert(artifact_id, job);
 
 	if let Some(available) = find_idle_worker(queue) {
@@ -264,12 +245,7 @@ async fn handle_enqueue(queue: &mut Queue, priority: Priority, pvf: Pvf) -> Resu
 }
 
 fn find_idle_worker(queue: &mut Queue) -> Option<Worker> {
-	queue
-		.workers
-		.iter()
-		.filter(|(_, data)| data.is_idle())
-		.map(|(k, _)| k)
-		.next()
+	queue.workers.iter().filter(|(_, data)| data.is_idle()).map(|(k, _)| k).next()
 }
 
 async fn handle_amend(
@@ -336,8 +312,8 @@ async fn handle_worker_concluded(
 					// Assume the conditions holds, then this never is not hit;
 					// qed.
 					never!("never_none, {}", stringify!($expr));
-					return Ok(());
-				}
+					return Ok(())
+				},
 			}
 		};
 	}
@@ -388,10 +364,7 @@ async fn handle_worker_concluded(
 			spawn_extra_worker(queue, false).await?;
 		}
 	} else {
-		if queue
-			.limits
-			.should_cull(queue.workers.len() + queue.spawn_inflight)
-		{
+		if queue.limits.should_cull(queue.workers.len() + queue.spawn_inflight) {
 			// We no longer need services of this worker. Kill it.
 			queue.workers.remove(worker);
 			send_pool(&mut queue.to_pool_tx, pool::ToPool::Kill(worker)).await?;
@@ -412,20 +385,16 @@ async fn handle_worker_rip(queue: &mut Queue, worker: Worker) -> Result<(), Fata
 	if let Some(WorkerData { job: Some(job), .. }) = worker_data {
 		// This is an edge case where the worker ripped after we sent assignment but before it
 		// was received by the pool.
-		let priority = queue
-			.jobs
-			.get(job)
-			.map(|data| data.priority)
-			.unwrap_or_else(|| {
-				// job is inserted upon enqueue and removed on concluded signal;
-				// this is enclosed in the if statement that narrows the situation to before
-				// conclusion;
-				// that means that the job still exists and is known;
-				// this path cannot be hit;
-				// qed.
-				never!("the job of the ripped worker must be known but it is not");
-				Priority::Normal
-			});
+		let priority = queue.jobs.get(job).map(|data| data.priority).unwrap_or_else(|| {
+			// job is inserted upon enqueue and removed on concluded signal;
+			// this is enclosed in the if statement that narrows the situation to before
+			// conclusion;
+			// that means that the job still exists and is known;
+			// this path cannot be hit;
+			// qed.
+			never!("the job of the ripped worker must be known but it is not");
+			Priority::Normal
+		});
 		queue.unscheduled.readd(priority, job);
 	}
 
@@ -500,11 +469,7 @@ pub fn start(
 	cache_path: PathBuf,
 	to_pool_tx: mpsc::Sender<pool::ToPool>,
 	from_pool_rx: mpsc::UnboundedReceiver<pool::FromPool>,
-) -> (
-	mpsc::Sender<ToQueue>,
-	mpsc::UnboundedReceiver<FromQueue>,
-	impl Future<Output = ()>,
-) {
+) -> (mpsc::Sender<ToQueue>, mpsc::UnboundedReceiver<FromQueue>, impl Future<Output = ()>) {
 	let (to_queue_tx, to_queue_rx) = mpsc::channel(150);
 	let (from_queue_tx, from_queue_rx) = mpsc::unbounded();
 
@@ -524,11 +489,11 @@ pub fn start(
 
 #[cfg(test)]
 mod tests {
-	use slotmap::SlotMap;
-	use assert_matches::assert_matches;
-	use futures::{FutureExt, future::BoxFuture};
-	use std::task::Poll;
 	use super::*;
+	use assert_matches::assert_matches;
+	use futures::{future::BoxFuture, FutureExt};
+	use slotmap::SlotMap;
+	use std::task::Poll;
 
 	/// Creates a new PVF which artifact id can be uniquely identified by the given number.
 	fn pvf(descriminator: u32) -> Pvf {
@@ -549,7 +514,7 @@ mod tests {
 			}
 
 			if let Poll::Ready(r) = futures::poll!(&mut *fut) {
-				break r;
+				break r
 			}
 
 			if futures::poll!(&mut *task).is_ready() {
@@ -597,37 +562,21 @@ mod tests {
 		}
 
 		fn send_queue(&mut self, to_queue: ToQueue) {
-			self.to_queue_tx
-				.send(to_queue)
-				.now_or_never()
-				.unwrap()
-				.unwrap();
+			self.to_queue_tx.send(to_queue).now_or_never().unwrap().unwrap();
 		}
 
 		async fn poll_and_recv_from_queue(&mut self) -> FromQueue {
 			let from_queue_rx = &mut self.from_queue_rx;
-			run_until(
-				&mut self.run,
-				async { from_queue_rx.next().await.unwrap() }.boxed(),
-			)
-			.await
+			run_until(&mut self.run, async { from_queue_rx.next().await.unwrap() }.boxed()).await
 		}
 
 		fn send_from_pool(&mut self, from_pool: pool::FromPool) {
-			self.from_pool_tx
-				.send(from_pool)
-				.now_or_never()
-				.unwrap()
-				.unwrap();
+			self.from_pool_tx.send(from_pool).now_or_never().unwrap().unwrap();
 		}
 
 		async fn poll_and_recv_to_pool(&mut self) -> pool::ToPool {
 			let to_pool_rx = &mut self.to_pool_rx;
-			run_until(
-				&mut self.run,
-				async { to_pool_rx.next().await.unwrap() }.boxed(),
-			)
-			.await
+			run_until(&mut self.run, async { to_pool_rx.next().await.unwrap() }.boxed()).await
 		}
 
 		async fn poll_ensure_to_pool_is_empty(&mut self) {
@@ -655,10 +604,7 @@ mod tests {
 	async fn properly_concludes() {
 		let mut test = Test::new(2, 2);
 
-		test.send_queue(ToQueue::Enqueue {
-			priority: Priority::Background,
-			pvf: pvf(1),
-		});
+		test.send_queue(ToQueue::Enqueue { priority: Priority::Background, pvf: pvf(1) });
 		assert_eq!(test.poll_and_recv_to_pool().await, pool::ToPool::Spawn);
 
 		let w = test.workers.insert(());
@@ -675,18 +621,9 @@ mod tests {
 	async fn dont_spawn_over_soft_limit_unless_critical() {
 		let mut test = Test::new(2, 3);
 
-		test.send_queue(ToQueue::Enqueue {
-			priority: Priority::Normal,
-			pvf: pvf(1),
-		});
-		test.send_queue(ToQueue::Enqueue {
-			priority: Priority::Normal,
-			pvf: pvf(2),
-		});
-		test.send_queue(ToQueue::Enqueue {
-			priority: Priority::Normal,
-			pvf: pvf(3),
-		});
+		test.send_queue(ToQueue::Enqueue { priority: Priority::Normal, pvf: pvf(1) });
+		test.send_queue(ToQueue::Enqueue { priority: Priority::Normal, pvf: pvf(2) });
+		test.send_queue(ToQueue::Enqueue { priority: Priority::Normal, pvf: pvf(3) });
 
 		// Receive only two spawns.
 		assert_eq!(test.poll_and_recv_to_pool().await, pool::ToPool::Spawn);
@@ -699,27 +636,15 @@ mod tests {
 		test.send_from_pool(pool::FromPool::Spawned(w2));
 
 		// Get two start works.
-		assert_matches!(
-			test.poll_and_recv_to_pool().await,
-			pool::ToPool::StartWork { .. }
-		);
-		assert_matches!(
-			test.poll_and_recv_to_pool().await,
-			pool::ToPool::StartWork { .. }
-		);
+		assert_matches!(test.poll_and_recv_to_pool().await, pool::ToPool::StartWork { .. });
+		assert_matches!(test.poll_and_recv_to_pool().await, pool::ToPool::StartWork { .. });
 
 		test.send_from_pool(pool::FromPool::Concluded(w1, false));
 
-		assert_matches!(
-			test.poll_and_recv_to_pool().await,
-			pool::ToPool::StartWork { .. }
-		);
+		assert_matches!(test.poll_and_recv_to_pool().await, pool::ToPool::StartWork { .. });
 
 		// Enqueue a critical job.
-		test.send_queue(ToQueue::Enqueue {
-			priority: Priority::Critical,
-			pvf: pvf(4),
-		});
+		test.send_queue(ToQueue::Enqueue { priority: Priority::Critical, pvf: pvf(4) });
 
 		// 2 out of 2 are working, but there is a critical job incoming. That means that spawning
 		// another worker is warranted.
@@ -730,23 +655,14 @@ mod tests {
 	async fn cull_unwanted() {
 		let mut test = Test::new(1, 2);
 
-		test.send_queue(ToQueue::Enqueue {
-			priority: Priority::Normal,
-			pvf: pvf(1),
-		});
+		test.send_queue(ToQueue::Enqueue { priority: Priority::Normal, pvf: pvf(1) });
 		assert_eq!(test.poll_and_recv_to_pool().await, pool::ToPool::Spawn);
 		let w1 = test.workers.insert(());
 		test.send_from_pool(pool::FromPool::Spawned(w1));
-		assert_matches!(
-			test.poll_and_recv_to_pool().await,
-			pool::ToPool::StartWork { .. }
-		);
+		assert_matches!(test.poll_and_recv_to_pool().await, pool::ToPool::StartWork { .. });
 
 		// Enqueue a critical job, which warrants spawning over the soft limit.
-		test.send_queue(ToQueue::Enqueue {
-			priority: Priority::Critical,
-			pvf: pvf(2),
-		});
+		test.send_queue(ToQueue::Enqueue { priority: Priority::Critical, pvf: pvf(2) });
 		assert_eq!(test.poll_and_recv_to_pool().await, pool::ToPool::Spawn);
 
 		// However, before the new worker had a chance to spawn, the first worker finishes with its
@@ -764,47 +680,29 @@ mod tests {
 	async fn bump_prio_on_urgency_change() {
 		let mut test = Test::new(2, 2);
 
-		test.send_queue(ToQueue::Enqueue {
-			priority: Priority::Background,
-			pvf: pvf(1),
-		});
+		test.send_queue(ToQueue::Enqueue { priority: Priority::Background, pvf: pvf(1) });
 
 		assert_eq!(test.poll_and_recv_to_pool().await, pool::ToPool::Spawn);
 
 		let w = test.workers.insert(());
 		test.send_from_pool(pool::FromPool::Spawned(w));
 
-		assert_matches!(
-			test.poll_and_recv_to_pool().await,
-			pool::ToPool::StartWork { .. }
-		);
+		assert_matches!(test.poll_and_recv_to_pool().await, pool::ToPool::StartWork { .. });
 		test.send_queue(ToQueue::Amend {
 			priority: Priority::Normal,
 			artifact_id: pvf(1).as_artifact_id(),
 		});
 
-		assert_eq!(
-			test.poll_and_recv_to_pool().await,
-			pool::ToPool::BumpPriority(w)
-		);
+		assert_eq!(test.poll_and_recv_to_pool().await, pool::ToPool::BumpPriority(w));
 	}
 
 	#[async_std::test]
 	async fn worker_mass_die_out_doesnt_stall_queue() {
 		let mut test = Test::new(2, 2);
 
-		test.send_queue(ToQueue::Enqueue {
-			priority: Priority::Normal,
-			pvf: pvf(1),
-		});
-		test.send_queue(ToQueue::Enqueue {
-			priority: Priority::Normal,
-			pvf: pvf(2),
-		});
-		test.send_queue(ToQueue::Enqueue {
-			priority: Priority::Normal,
-			pvf: pvf(3),
-		});
+		test.send_queue(ToQueue::Enqueue { priority: Priority::Normal, pvf: pvf(1) });
+		test.send_queue(ToQueue::Enqueue { priority: Priority::Normal, pvf: pvf(2) });
+		test.send_queue(ToQueue::Enqueue { priority: Priority::Normal, pvf: pvf(3) });
 
 		assert_eq!(test.poll_and_recv_to_pool().await, pool::ToPool::Spawn);
 		assert_eq!(test.poll_and_recv_to_pool().await, pool::ToPool::Spawn);
@@ -815,14 +713,8 @@ mod tests {
 		test.send_from_pool(pool::FromPool::Spawned(w1));
 		test.send_from_pool(pool::FromPool::Spawned(w2));
 
-		assert_matches!(
-			test.poll_and_recv_to_pool().await,
-			pool::ToPool::StartWork { .. }
-		);
-		assert_matches!(
-			test.poll_and_recv_to_pool().await,
-			pool::ToPool::StartWork { .. }
-		);
+		assert_matches!(test.poll_and_recv_to_pool().await, pool::ToPool::StartWork { .. });
+		assert_matches!(test.poll_and_recv_to_pool().await, pool::ToPool::StartWork { .. });
 
 		// Conclude worker 1 and rip it.
 		test.send_from_pool(pool::FromPool::Concluded(w1, true));
@@ -840,20 +732,14 @@ mod tests {
 	async fn doesnt_resurrect_ripped_worker_if_no_work() {
 		let mut test = Test::new(2, 2);
 
-		test.send_queue(ToQueue::Enqueue {
-			priority: Priority::Normal,
-			pvf: pvf(1),
-		});
+		test.send_queue(ToQueue::Enqueue { priority: Priority::Normal, pvf: pvf(1) });
 
 		assert_eq!(test.poll_and_recv_to_pool().await, pool::ToPool::Spawn);
 
 		let w1 = test.workers.insert(());
 		test.send_from_pool(pool::FromPool::Spawned(w1));
 
-		assert_matches!(
-			test.poll_and_recv_to_pool().await,
-			pool::ToPool::StartWork { .. }
-		);
+		assert_matches!(test.poll_and_recv_to_pool().await, pool::ToPool::StartWork { .. });
 
 		test.send_from_pool(pool::FromPool::Concluded(w1, true));
 		test.poll_ensure_to_pool_is_empty().await;
@@ -863,10 +749,7 @@ mod tests {
 	async fn rip_for_start_work() {
 		let mut test = Test::new(2, 2);
 
-		test.send_queue(ToQueue::Enqueue {
-			priority: Priority::Normal,
-			pvf: pvf(1),
-		});
+		test.send_queue(ToQueue::Enqueue { priority: Priority::Normal, pvf: pvf(1) });
 
 		assert_eq!(test.poll_and_recv_to_pool().await, pool::ToPool::Spawn);
 
@@ -875,10 +758,7 @@ mod tests {
 
 		// Now, to the interesting part. After the queue normally issues the start_work command to
 		// the pool, before receiving the command the queue may report that the worker ripped.
-		assert_matches!(
-			test.poll_and_recv_to_pool().await,
-			pool::ToPool::StartWork { .. }
-		);
+		assert_matches!(test.poll_and_recv_to_pool().await, pool::ToPool::StartWork { .. });
 		test.send_from_pool(pool::FromPool::Rip(w1));
 
 		// In this case, the pool should spawn a new worker and request it to work on the item.
@@ -886,9 +766,6 @@ mod tests {
 
 		let w2 = test.workers.insert(());
 		test.send_from_pool(pool::FromPool::Spawned(w2));
-		assert_matches!(
-			test.poll_and_recv_to_pool().await,
-			pool::ToPool::StartWork { .. }
-		);
+		assert_matches!(test.poll_and_recv_to_pool().await, pool::ToPool::StartWork { .. });
 	}
 }

polkadot/node/core/pvf/src/prepare/worker.rs

@@ -15,17 +15,17 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use crate::{
-	LOG_TARGET,
 	artifacts::Artifact,
 	worker_common::{
-		IdleWorker, SpawnErr, WorkerHandle, bytes_to_path, framed_recv, framed_send, path_to_bytes,
-		spawn_with_program_path, tmpfile_in, worker_event_loop,
+		bytes_to_path, framed_recv, framed_send, path_to_bytes, spawn_with_program_path,
+		tmpfile_in, worker_event_loop, IdleWorker, SpawnErr, WorkerHandle,
 	},
+	LOG_TARGET,
 };
 use async_std::{
 	io,
 	os::unix::net::UnixStream,
-	path::{PathBuf, Path},
+	path::{Path, PathBuf},
 };
 use futures::FutureExt as _;
 use futures_timer::Delay;
@@ -43,13 +43,7 @@ pub async fn spawn(
 	program_path: &Path,
 	spawn_timeout: Duration,
 ) -> Result<(IdleWorker, WorkerHandle), SpawnErr> {
-	spawn_with_program_path(
-		"prepare",
-		program_path,
-		&["prepare-worker"],
-		spawn_timeout,
-	)
-	.await
+	spawn_with_program_path("prepare", program_path, &["prepare-worker"], spawn_timeout).await
 }
 
 pub enum Outcome {
@@ -99,7 +93,7 @@ pub async fn start_work(
 				"failed to send a prepare request: {:?}",
 				err,
 			);
-			return Outcome::Unreachable;
+			return Outcome::Unreachable
 		}
 
 		// Wait for the result from the worker, keeping in mind that there may be a timeout, the
@@ -172,13 +166,13 @@ pub async fn start_work(
 			Selected::Done => {
 				renice(pid, NICENESS_FOREGROUND);
 				Outcome::Concluded(IdleWorker { stream, pid })
-			}
+			},
 			Selected::IoErr | Selected::Deadline => {
 				let bytes = Artifact::DidntMakeIt.serialize();
 				// best effort: there is nothing we can do here if the write fails.
 				let _ = async_std::fs::write(&artifact_path, &bytes).await;
 				Outcome::DidntMakeIt
-			}
+			},
 		}
 	})
 	.await
@@ -202,8 +196,8 @@ where
 				"failed to create a temp file for the artifact: {:?}",
 				err,
 			);
-			return Outcome::DidntMakeIt;
-		}
+			return Outcome::DidntMakeIt
+		},
 	};
 
 	let outcome = f(tmp_file.clone()).await;
@@ -223,7 +217,7 @@ where
 				"failed to remove the tmp file: {:?}",
 				err,
 			);
-		}
+		},
 	}
 
 	outcome
@@ -304,9 +298,7 @@ pub fn worker_entrypoint(socket_path: &str) {
 
 fn prepare_artifact(code: &[u8]) -> Artifact {
 	let blob = match crate::executor_intf::prevalidate(code) {
-		Err(err) => {
-			return Artifact::PrevalidationErr(format!("{:?}", err));
-		}
+		Err(err) => return Artifact::PrevalidationErr(format!("{:?}", err)),
 		Ok(b) => b,
 	};