Changed errors to bubble up from reprioritization

node/core/dispute-coordinator/src/initialized.rs

@@ -271,10 +271,11 @@ impl Initialized {
 	) -> Result<()> {
 		let scraped_updates =
 			self.scraper.process_active_leaves_update(ctx.sender(), &update).await?;
-		let errors = self.participation.prioritize_newly_included(ctx, &scraped_updates.included_receipts).await;
-		for error in errors {
-			log_error(error)?;
-		}
+		log_error(
+			self.participation
+				.prioritize_newly_included(ctx, &scraped_updates.included_receipts)
+				.await,
+		)?;
 		self.participation.process_active_leaves_update(ctx, &update).await?;
 
 		if let Some(new_leaf) = update.activated {

node/core/dispute-coordinator/src/participation/mod.rs

@@ -217,22 +217,11 @@ impl Participation {
 		&mut self,
 		ctx: &mut Context,
 		included_receipts: &Vec<CandidateReceipt>,
-	) -> Vec<Result<()>> {
-		let mut errors: Vec<Result<()>> = Vec::new();
+	) -> Result<()> {
 		for receipt in included_receipts {
-			let r = self.queue.prioritize_if_present(ctx.sender(), receipt).await;
-			match r {
-				Ok(priority_full) => {
-					if priority_full == true {
-						return errors // Avoid working through the rest of the vec
-					}
-				},
-				Err(error) => {
-					errors.push(Err(error)); // Don't want to stop reprioritizing included receipts if just one fails
-				}
-			}
+			self.queue.prioritize_if_present(ctx.sender(), receipt).await?;
 		}
-		errors
+		Ok(())
 	}
 
 	/// Dequeue until `MAX_PARALLEL_PARTICIPATIONS` is reached.

node/core/dispute-coordinator/src/participation/queues/mod.rs

@@ -161,23 +161,30 @@ impl Queues {
 
 	/// Reprioritizes any participation requests pertaining to the
 	/// passed candidates from best effort to priority.
-	/// 
+	///
 	/// Returns: Either a bool telling the caller whether the priority queue is now full
 	/// or an error resulting from the failed creation of a comparator.
 	pub async fn prioritize_if_present(
 		&mut self,
 		sender: &mut impl overseer::DisputeCoordinatorSenderTrait,
 		receipt: &CandidateReceipt,
-	) -> Result<bool> {
+	) -> Result<()> {
+		let comparator = CandidateComparator::new(sender, receipt).await?;
+		self.prioritize_with_comparator(comparator)?;
+		Ok(())
+	}
+
+	fn prioritize_with_comparator(
+		&mut self,
+		comparator: CandidateComparator,
+	) -> std::result::Result<(), QueueError> {
 		if self.priority.len() >= PRIORITY_QUEUE_SIZE {
-			return Ok(true)
+			return Err(QueueError::PriorityFull)
 		}
-		let comparator = CandidateComparator::new(sender, receipt)
-			.await?;
 		if let Some(request) = self.best_effort.remove(&comparator) {
 			self.priority.insert(comparator, request);
 		}
-		Ok(false)
+		Ok(())
 	}
 
 	fn queue_with_comparator(

node/core/dispute-coordinator/src/scraping/mod.rs

@@ -52,10 +52,10 @@ const LRU_OBSERVED_BLOCKS_CAPACITY: NonZeroUsize = match NonZeroUsize::new(20) {
 };
 
 /// ScrapedUpdates
-/// 
-/// Updates to on_chain_votes and included receipts for new active leaf and its unprocessed 
+///
+/// Updates to on_chain_votes and included receipts for new active leaf and its unprocessed
 /// ancestors.
-/// 
+///
 /// on_chain_votes: New votes as seen on chain
 /// included_receipts: Newly included parachain block candidate receipts as seen on chain
 pub struct ScrapedUpdates {
@@ -65,10 +65,7 @@ pub struct ScrapedUpdates {
 
 impl ScrapedUpdates {
 	pub fn new() -> Self {
-		Self {
-			on_chain_votes: Vec::new(),
-			included_receipts: Vec::new(),
-		}
+		Self { on_chain_votes: Vec::new(), included_receipts: Vec::new() }
 	}
 }
 
@@ -220,8 +217,8 @@ impl ChainScraper {
 	/// Process candidate events of a block.
 	///
 	/// Keep track of all included and backed candidates.
-	/// 
-	/// Returns freshly included candidate receipts 
+	///
+	/// Returns freshly included candidate receipts
 	async fn process_candidate_events<Sender>(
 		&mut self,
 		sender: &mut Sender,