pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-29 18:27:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make BlockImport and Verifier async (#8472)

Browse Source 
* Make grandpa work

* Introduce `SharedData`

* Add test and fix bugs

* Switch to `SharedData`

* Make grandpa tests working

* More Babe work

* Make it async

* Fix fix

* Use `async_trait` in sc-consensus-slots

This makes the code a little bit easier to read and also expresses that
there can always only be one call at a time to `on_slot`.

* Make grandpa tests compile

* More Babe tests work

* Fix network test

* Start fixing service test

* Finish service-test

* Fix sc-consensus-aura

* Fix fix fix

* More fixes

* Make everything compile *yeah*

* Fix build when we have Rust 1.51

* Update client/consensus/common/src/shared_data.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/common/src/shared_data.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/common/src/shared_data.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/common/src/shared_data.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/common/src/shared_data.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/babe/src/tests.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Update client/consensus/babe/src/tests.rs

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>

* Fix warning

Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>
This commit is contained in:
Bastian Köcher
2021-03-30 11:19:49 +02:00
committed by GitHub
parent 2998b42311
commit 217c4be226
65 changed files with 1241 additions and 715 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/test-utils/client/src/client_ext.rs
+56 -21
View File
@@ -43,18 +43,20 @@ pub trait ClientExt<Block: BlockT>: Sized {
}
/// Extension trait for a test client around block importing.
#[async_trait::async_trait]
pub trait ClientBlockImportExt<Block: BlockT>: Sized {
/// Import block to the chain. No finality.
fn import(&mut self, origin: BlockOrigin, block: Block) -> Result<(), ConsensusError>;
async fn import(&mut self, origin: BlockOrigin, block: Block) -> Result<(), ConsensusError>;
/// Import a block and make it our best block if possible.
fn import_as_best(&mut self, origin: BlockOrigin, block: Block) -> Result<(), ConsensusError>;
async fn import_as_best(&mut self, origin: BlockOrigin, block: Block) -> Result<(), ConsensusError>;
/// Import a block and finalize it.
fn import_as_final(&mut self, origin: BlockOrigin, block: Block) -> Result<(), ConsensusError>;
async fn import_as_final(&mut self, origin: BlockOrigin, block: Block)
-> Result<(), ConsensusError>;
/// Import block with justification(s), finalizes block.
fn import_justified(
async fn import_justified(
&mut self,
origin: BlockOrigin,
block: Block,
@@ -83,38 +85,54 @@ impl<B, E, RA, Block> ClientExt<Block> for Client<B, E, Block, RA>
}
/// This implementation is required, because of the weird api requirements around `BlockImport`.
#[async_trait::async_trait]
impl<Block: BlockT, T, Transaction> ClientBlockImportExt<Block> for std::sync::Arc<T>
where for<'r> &'r T: BlockImport<Block, Error = ConsensusError, Transaction = Transaction>
where
for<'r> &'r T: BlockImport<Block, Error = ConsensusError, Transaction = Transaction>,
Transaction: Send + 'static,
T: Send + Sync,
{
fn import(&mut self, origin: BlockOrigin, block: Block) -> Result<(), ConsensusError> {
async fn import(
&mut self,
origin: BlockOrigin,
block: Block,
) -> Result<(), ConsensusError> {
let (header, extrinsics) = block.deconstruct();
let mut import = BlockImportParams::new(origin, header);
import.body = Some(extrinsics);
import.fork_choice = Some(ForkChoiceStrategy::LongestChain);
BlockImport::import_block(self, import, HashMap::new()).map(|_| ())
BlockImport::import_block(self, import, HashMap::new()).await.map(|_| ())
}
fn import_as_best(&mut self, origin: BlockOrigin, block: Block) -> Result<(), ConsensusError> {
async fn import_as_best(
&mut self,
origin: BlockOrigin,
block: Block,
) -> Result<(), ConsensusError> {
let (header, extrinsics) = block.deconstruct();
let mut import = BlockImportParams::new(origin, header);
import.body = Some(extrinsics);
import.fork_choice = Some(ForkChoiceStrategy::Custom(true));
BlockImport::import_block(self, import, HashMap::new()).map(|_| ())
BlockImport::import_block(self, import, HashMap::new()).await.map(|_| ())
}
fn import_as_final(&mut self, origin: BlockOrigin, block: Block) -> Result<(), ConsensusError> {
async fn import_as_final(
&mut self,
origin: BlockOrigin,
block: Block,
) -> Result<(), ConsensusError> {
let (header, extrinsics) = block.deconstruct();
let mut import = BlockImportParams::new(origin, header);
import.body = Some(extrinsics);
import.finalized = true;
import.fork_choice = Some(ForkChoiceStrategy::Custom(true));
BlockImport::import_block(self, import, HashMap::new()).map(|_| ())
BlockImport::import_block(self, import, HashMap::new()).await.map(|_| ())
}
fn import_justified(
async fn import_justified(
&mut self,
origin: BlockOrigin,
block: Block,
@@ -127,43 +145,60 @@ impl<Block: BlockT, T, Transaction> ClientBlockImportExt<Block> for std::sync::A
import.finalized = true;
import.fork_choice = Some(ForkChoiceStrategy::LongestChain);
BlockImport::import_block(self, import, HashMap::new()).map(|_| ())
BlockImport::import_block(self, import, HashMap::new()).await.map(|_| ())
}
}
#[async_trait::async_trait]
impl<B, E, RA, Block: BlockT> ClientBlockImportExt<Block> for Client<B, E, Block, RA>
where
Self: BlockImport<Block, Error = ConsensusError>,
RA: Send,
B: Send + Sync,
E: Send,
<Self as BlockImport<Block>>::Transaction: Send,
{
fn import(&mut self, origin: BlockOrigin, block: Block) -> Result<(), ConsensusError> {
async fn import(
&mut self,
origin: BlockOrigin,
block: Block,
) -> Result<(), ConsensusError> {
let (header, extrinsics) = block.deconstruct();
let mut import = BlockImportParams::new(origin, header);
import.body = Some(extrinsics);
import.fork_choice = Some(ForkChoiceStrategy::LongestChain);
BlockImport::import_block(self, import, HashMap::new()).map(|_| ())
BlockImport::import_block(self, import, HashMap::new()).await.map(|_| ())
}
fn import_as_best(&mut self, origin: BlockOrigin, block: Block) -> Result<(), ConsensusError> {
async fn import_as_best(
&mut self,
origin: BlockOrigin,
block: Block,
) -> Result<(), ConsensusError> {
let (header, extrinsics) = block.deconstruct();
let mut import = BlockImportParams::new(origin, header);
import.body = Some(extrinsics);
import.fork_choice = Some(ForkChoiceStrategy::Custom(true));
BlockImport::import_block(self, import, HashMap::new()).map(|_| ())
BlockImport::import_block(self, import, HashMap::new()).await.map(|_| ())
}
fn import_as_final(&mut self, origin: BlockOrigin, block: Block) -> Result<(), ConsensusError> {
async fn import_as_final(
&mut self,
origin: BlockOrigin,
block: Block,
) -> Result<(), ConsensusError> {
let (header, extrinsics) = block.deconstruct();
let mut import = BlockImportParams::new(origin, header);
import.body = Some(extrinsics);
import.finalized = true;
import.fork_choice = Some(ForkChoiceStrategy::Custom(true));
BlockImport::import_block(self, import, HashMap::new()).map(|_| ())
BlockImport::import_block(self, import, HashMap::new()).await.map(|_| ())
}
fn import_justified(
async fn import_justified(
&mut self,
origin: BlockOrigin,
block: Block,
@@ -176,6 +211,6 @@ impl<B, E, RA, Block: BlockT> ClientBlockImportExt<Block> for Client<B, E, Block
import.finalized = true;
import.fork_choice = Some(ForkChoiceStrategy::LongestChain);
BlockImport::import_block(self, import, HashMap::new()).map(|_| ())
BlockImport::import_block(self, import, HashMap::new()).await.map(|_| ())
}
}