Asynchronous-backing compatible Aura, not plugged in (#2573)

* rough draft of potential parent search

* get things compiling

* fmt

* add new function to all RelayChainInterface implementations

* fix compilation

* set slot and timestamp based on relay parent, prepare for find-parent

* skeleton of new aura logic

* fmt

* introduce a collator module in the Aura crate

* extract different implementations into own modules

* make interface more convenient

* docs and todos for lookahead

* refactor basic collator to use new collator utility

* some more refactoring

* finish most of the control flow for new aura

* introduce backend as parameter

* fix compilation

* fix a couple more TODOs

* add an `announce_block` function to collator service

* announce with barrier

* rename block announcement validator to be more specific

* fmt

* clean up unused import errors

* update references to BlockAnnounceValidator

* rename unstable_reimpl

* add AuraUnincludedSegmentApi

* finish rename

* integrate AuraUnincludedSegmentApi

* add a new block announcement validator for backwards compatibility

* add some naive equivocation defenses

* rustfmt

* clean up remaining TODO [now]s

* fmt

* try to fix inprocess-interface

* actually fix compilation

* ignored -> rejected rephrase

* fix test compilation

* fmt

* clippy

cumulus/client/collator/src/service.rs

@@ -58,12 +58,18 @@ pub trait ServiceInterface<Block: BlockT> {
 		candidate: ParachainCandidate<Block>,
 	) -> Option<(Collation, ParachainBlockData<Block>)>;
 
-	/// Inform networking systems that the block should be announced after an appropriate
-	/// signal has been received. This returns the sending half of the signal.
+	/// Inform networking systems that the block should be announced after a signal has
+	/// been received to indicate the block has been seconded by a relay-chain validator.
+	///
+	/// This sets up the barrier and returns the sending side of a channel, for the signal
+	/// to be passed through.
 	fn announce_with_barrier(
 		&self,
 		block_hash: Block::Hash,
 	) -> oneshot::Sender<CollationSecondedSignal>;
+
+	/// Directly announce a block on the network.
+	fn announce_block(&self, block_hash: Block::Hash, data: Option<Vec<u8>>);
 }
 
 /// The [`CollatorService`] provides common utilities for parachain consensus and authoring.
@@ -74,6 +80,7 @@ pub trait ServiceInterface<Block: BlockT> {
 pub struct CollatorService<Block: BlockT, BS, RA> {
 	block_status: Arc<BS>,
 	wait_to_announce: Arc<Mutex<WaitToAnnounce<Block>>>,
+	announce_block: Arc<dyn Fn(Block::Hash, Option<Vec<u8>>) + Send + Sync>,
 	runtime_api: Arc<RA>,
 }
 
@@ -82,6 +89,7 @@ impl<Block: BlockT, BS, RA> Clone for CollatorService<Block, BS, RA> {
 		Self {
 			block_status: self.block_status.clone(),
 			wait_to_announce: self.wait_to_announce.clone(),
+			announce_block: self.announce_block.clone(),
 			runtime_api: self.runtime_api.clone(),
 		}
 	}
@@ -101,9 +109,10 @@ where
 		announce_block: Arc<dyn Fn(Block::Hash, Option<Vec<u8>>) + Send + Sync>,
 		runtime_api: Arc<RA>,
 	) -> Self {
-		let wait_to_announce = Arc::new(Mutex::new(WaitToAnnounce::new(spawner, announce_block)));
+		let wait_to_announce =
+			Arc::new(Mutex::new(WaitToAnnounce::new(spawner, announce_block.clone())));
 
-		Self { block_status, wait_to_announce, runtime_api }
+		Self { block_status, wait_to_announce, announce_block, runtime_api }
 	}
 
 	/// Checks the status of the given block hash in the Parachain.
@@ -315,4 +324,8 @@ where
 	) -> oneshot::Sender<CollationSecondedSignal> {
 		CollatorService::announce_with_barrier(self, block_hash)
 	}
+
+	fn announce_block(&self, block_hash: Block::Hash, data: Option<Vec<u8>>) {
+		(self.announce_block)(block_hash, data)
+	}
 }