pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-26 08:47:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reusable bench-db & bench-keyring (#4955)

Browse Source 
* move to node-testing/bench

* to tabs
This commit is contained in:
Nikolay Volf
2020-02-18 12:57:58 +03:00
committed by GitHub
parent aea2e9427b
commit 24e151d3e9
5 changed files with 435 additions and 379 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/bin/node/testing/Cargo.toml
+2 -3
View File
@@ -41,12 +41,11 @@ sp-block-builder = { version = "2.0.0", path = "../../../primitives/block-builde
sp-inherents = { version = "2.0.0", path = "../../../primitives/inherents" }
sp-blockchain = { version = "2.0.0", path = "../../../primitives/blockchain" }
log = "0.4.8"
tempdir = "0.3"
fs_extra = "1"
[dev-dependencies]
criterion = "0.3.0"
tempdir = "0.3"
fs_extra = "1"
hex-literal = "0.2.1"
sc-cli = { version = "0.8.0", path = "../../../client/cli" }
sc-service = { version = "0.8.0", path = "../../../client/service", features = ["rocksdb"] }
substrate/bin/node/testing/benches/import.rs
+8 -374
View File
@@ -28,44 +28,10 @@
//! to much configuring - just block full of randomized transactions.
//! It is not supposed to measure runtime modules weight correctness
use std::{sync::Arc, path::Path, collections::BTreeMap};
use node_primitives::Block;
use node_testing::client::{Client, Backend};
use node_testing::keyring::*;
use sc_client_db::PruningMode;
use sc_executor::{NativeExecutor, WasmExecutionMethod};
use sp_consensus::{
BlockOrigin, BlockImport, BlockImportParams,
ForkChoiceStrategy, ImportResult, ImportedAux
};
use sp_runtime::{
generic::BlockId,
OpaqueExtrinsic,
traits::{Block as BlockT, Verify, Zero, IdentifyAccount},
};
use codec::{Decode, Encode};
use node_runtime::{
Call,
CheckedExtrinsic,
constants::currency::DOLLARS,
UncheckedExtrinsic,
MinimumPeriod,
BalancesCall,
AccountId,
Signature,
};
use sp_core::ExecutionContext;
use sp_api::ProvideRuntimeApi;
use sp_block_builder::BlockBuilder;
use sp_inherents::InherentData;
use sc_client_api::{
Backend as _, ExecutionStrategy,
execution_extensions::{ExecutionExtensions, ExecutionStrategies},
};
use sp_core::{Pair, Public, sr25519};
use node_testing::bench::{BenchDb, Profile};
use sp_runtime::generic::BlockId;
use criterion::{Criterion, criterion_group, criterion_main};
use sc_client_api::backend::Backend;
criterion_group!(
name = benches;
@@ -79,344 +45,13 @@ criterion_group!(
);
criterion_main!(benches, profile);
fn genesis(keyring: &BenchKeyring) -> node_runtime::GenesisConfig {
node_testing::genesis::config_endowed(
false,
Some(node_runtime::WASM_BINARY),
keyring.collect_account_ids(),
)
}
// this is deterministic keyring of ordered accounts
// //endowed-user//00
// //endowed-user//01
// ...
// //endowed-user//N
#[derive(Clone)]
struct BenchKeyring {
accounts: BTreeMap<AccountId, sr25519::Pair>,
}
// This is prepared database with genesis and keyring
// that can be cloned and then used for any benchmarking.
struct BenchDb {
keyring: BenchKeyring,
directory_guard: Guard,
}
impl Clone for BenchDb {
fn clone(&self) -> Self {
let keyring = self.keyring.clone();
let dir = tempdir::TempDir::new("sub-bench").expect("temp dir creation failed");
let seed_dir = self.directory_guard.0.path();
log::trace!(
target: "bench-logistics",
"Copying seed db from {} to {}",
seed_dir.to_string_lossy(),
dir.path().to_string_lossy(),
);
let seed_db_files = std::fs::read_dir(seed_dir)
.expect("failed to list file in seed dir")
.map(|f_result|
f_result.expect("failed to read file in seed db")
.path()
.clone()
).collect();
fs_extra::copy_items(
&seed_db_files,
dir.path(),
&fs_extra::dir::CopyOptions::new(),
).expect("Copy of seed database is ok");
BenchDb { keyring, directory_guard: Guard(dir) }
}
}
impl BenchDb {
fn new(keyring_length: usize) -> Self {
let keyring = BenchKeyring::new(keyring_length);
let dir = tempdir::TempDir::new("sub-bench").expect("temp dir creation failed");
log::trace!(
target: "bench-logistics",
"Created seed db at {}",
dir.path().to_string_lossy(),
);
let (_client, _backend) = bench_client(dir.path(), Profile::Native, &keyring);
let directory_guard = Guard(dir);
BenchDb { keyring, directory_guard }
}
fn generate_block(&mut self) -> Block {
let (client, _backend) = bench_client(
self.directory_guard.path(),
Profile::Wasm,
&self.keyring,
);
let version = client.runtime_version_at(&BlockId::number(0))
.expect("There should be runtime version at 0")
.spec_version;
let genesis_hash = client.block_hash(Zero::zero())
.expect("Database error?")
.expect("Genesis block always exists; qed")
.into();
let mut block = client
.new_block(Default::default())
.expect("Block creation failed");
let timestamp = 1 * MinimumPeriod::get();
let mut inherent_data = InherentData::new();
inherent_data.put_data(sp_timestamp::INHERENT_IDENTIFIER, &timestamp)
.expect("Put timestamp failed");
inherent_data.put_data(sp_finality_tracker::INHERENT_IDENTIFIER, &0)
.expect("Put finality tracker failed");
for extrinsic in client.runtime_api()
.inherent_extrinsics_with_context(
&BlockId::number(0),
ExecutionContext::BlockConstruction,
inherent_data,
).expect("Get inherents failed")
{
block.push(extrinsic).expect("Push inherent failed");
}
let mut iteration = 0;
let start = std::time::Instant::now();
for _ in 0..100 {
let sender = self.keyring.at(iteration);
let receiver = get_account_id_from_seed::<sr25519::Public>(
&format!("random-user//{}", iteration)
);
let signed = self.keyring.sign(
CheckedExtrinsic {
signed: Some((sender, signed_extra(0, 1*DOLLARS))),
function: Call::Balances(
BalancesCall::transfer(
pallet_indices::address::Address::Id(receiver),
1*DOLLARS
)
),
},
version,
genesis_hash,
);
let encoded = Encode::encode(&signed);
let opaque = OpaqueExtrinsic::decode(&mut &encoded[..])
.expect("Failed to decode opaque");
match block.push(opaque) {
Err(sp_blockchain::Error::ApplyExtrinsicFailed(
sp_blockchain::ApplyExtrinsicFailed::Validity(e)
)) if e.exhausted_resources() => {
break;
},
Err(err) => panic!("Error pushing transaction: {:?}", err),
Ok(_) => {},
}
iteration += 1;
}
let block = block.build().expect("Block build failed").block;
log::info!(
target: "bench-logistics",
"Block construction: {:#?} ({} tx)",
start.elapsed(), block.extrinsics.len()
);
block
}
fn path(&self) -> &Path {
self.directory_guard.path()
}
fn create_context(&self, profile: Profile) -> BenchContext {
let BenchDb { directory_guard, keyring } = self.clone();
let (client, backend) = bench_client(directory_guard.path(), profile, &keyring);
BenchContext {
client, backend, db_guard: directory_guard,
}
}
}
impl BenchKeyring {
// `length` is the number of random accounts generated.
fn new(length: usize) -> Self {
let mut accounts = BTreeMap::new();
for n in 0..length {
let seed = format!("//endowed-user/{}", n);
let pair = sr25519::Pair::from_string(&seed, None).expect("failed to generate pair");
let account_id = AccountPublic::from(pair.public()).into_account();
accounts.insert(account_id, pair);
}
Self { accounts }
}
fn collect_account_ids(&self) -> Vec<AccountId> {
self.accounts.keys().cloned().collect()
}
fn at(&self, index: usize) -> AccountId {
self.accounts.keys().nth(index).expect("Failed to get account").clone()
}
fn sign(&self, xt: CheckedExtrinsic, version: u32, genesis_hash: [u8; 32]) -> UncheckedExtrinsic {
match xt.signed {
Some((signed, extra)) => {
let payload = (xt.function, extra.clone(), version, genesis_hash, genesis_hash);
let key = self.accounts.get(&signed).expect("Account id not found in keyring");
let signature = payload.using_encoded(|b| {
if b.len() > 256 {
key.sign(&sp_io::hashing::blake2_256(b))
} else {
key.sign(b)
}
}).into();
UncheckedExtrinsic {
signature: Some((pallet_indices::address::Address::Id(signed), signature, extra)),
function: payload.0,
}
}
None => UncheckedExtrinsic {
signature: None,
function: xt.function,
},
}
}
}
#[derive(Clone, Copy, Debug)]
enum Profile {
Native,
Wasm,
}
impl Profile {
fn into_execution_strategies(self) -> ExecutionStrategies {
match self {
Profile::Wasm => ExecutionStrategies {
syncing: ExecutionStrategy::AlwaysWasm,
importing: ExecutionStrategy::AlwaysWasm,
block_construction: ExecutionStrategy::AlwaysWasm,
offchain_worker: ExecutionStrategy::AlwaysWasm,
other: ExecutionStrategy::AlwaysWasm,
},
Profile::Native => ExecutionStrategies {
syncing: ExecutionStrategy::NativeElseWasm,
importing: ExecutionStrategy::NativeElseWasm,
block_construction: ExecutionStrategy::NativeElseWasm,
offchain_worker: ExecutionStrategy::NativeElseWasm,
other: ExecutionStrategy::NativeElseWasm,
}
}
}
}
// This should return client that is doing everything that full node
// is doing.
//
// - This client should use best wasm execution method.
// - This client should work with real database only.
fn bench_client(dir: &std::path::Path, profile: Profile, keyring: &BenchKeyring) -> (Client, std::sync::Arc<Backend>) {
let db_config = sc_client_db::DatabaseSettings {
state_cache_size: 16*1024*1024,
state_cache_child_ratio: Some((0, 100)),
pruning: PruningMode::ArchiveAll,
source: sc_client_db::DatabaseSettingsSrc::Path {
path: dir.into(),
cache_size: None,
},
};
let (client, backend) = sc_client_db::new_client(
db_config,
NativeExecutor::new(WasmExecutionMethod::Compiled, None),
&genesis(keyring),
None,
None,
ExecutionExtensions::new(profile.into_execution_strategies(), None),
).expect("Should not fail");
(client, backend)
}
struct Guard(tempdir::TempDir);
impl Guard {
fn path(&self) -> &Path {
self.0.path()
}
}
struct BenchContext {
client: Client,
backend: Arc<Backend>,
db_guard: Guard,
}
type AccountPublic = <Signature as Verify>::Signer;
pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
TPublic::Pair::from_string(&format!("//{}", seed), None)
.expect("static values are valid; qed")
.public()
}
pub fn get_account_id_from_seed<TPublic: Public>(seed: &str) -> AccountId
where
AccountPublic: From<<TPublic::Pair as Pair>::Public>
{
AccountPublic::from(get_from_seed::<TPublic>(seed)).into_account()
}
// Import generated block.
fn import_block(client: &mut Client, block: Block) {
let mut import_params = BlockImportParams::new(BlockOrigin::NetworkBroadcast, block.header.clone());
import_params.body = Some(block.extrinsics().to_vec());
import_params.fork_choice = Some(ForkChoiceStrategy::LongestChain);
assert_eq!(client.chain_info().best_number, 0);
assert_eq!(
client.import_block(import_params, Default::default())
.expect("Failed to import block"),
ImportResult::Imported(
ImportedAux {
header_only: false,
clear_justification_requests: false,
needs_justification: false,
bad_justification: false,
needs_finality_proof: false,
is_new_best: true,
}
)
);
assert_eq!(client.chain_info().best_number, 1);
}
fn bench_block_import(c: &mut Criterion) {
sc_cli::init_logger("");
// for future uses, uncomment if something wrong.
// sc_cli::init_logger("sc_client=debug");
let mut bench_db = BenchDb::new(128);
let block = bench_db.generate_block();
let block = bench_db.generate_block(100);
log::trace!(
target: "bench-logistics",
@@ -438,14 +73,14 @@ fn bench_block_import(c: &mut Criterion) {
log::trace!(
target: "bench-logistics",
"Next iteration database directory: {}, runtime version: {}",
context.db_guard.0.path().to_string_lossy(), version,
context.path().display(), version,
);
context
},
|mut context| {
let start = std::time::Instant::now();
import_block(&mut context.client, block.clone());
context.import_block(block.clone());
let elapsed = start.elapsed();
log::info!(
@@ -469,7 +104,6 @@ fn bench_block_import(c: &mut Criterion) {
);
}
// This is not an actual benchmark, so don't use it to measure anything.
// It just produces special pattern of cpu load that allows easy picking
// the part of block import for the profiling in the tool of choice.
@@ -477,7 +111,7 @@ fn profile_block_import(c: &mut Criterion) {
sc_cli::init_logger("");
let mut bench_db = BenchDb::new(128);
let block = bench_db.generate_block();
let block = bench_db.generate_block(100);
c.bench_function("profile block",
move |bencher| {
@@ -490,7 +124,7 @@ fn profile_block_import(c: &mut Criterion) {
// in rust, we just pause everything completely to help choosing
// actual profiling interval
std::thread::park_timeout(std::time::Duration::from_secs(2));
import_block(&mut context.client, block.clone());
context.import_block(block.clone());
// and here as well
std::thread::park_timeout(std::time::Duration::from_secs(2));
log::info!(
substrate/bin/node/testing/src/bench.rs
+424
View File
@@ -0,0 +1,424 @@
// Copyright 2019-2020 Parity Technologies (UK) Ltd.
// This file is part of Substrate.
// Substrate is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Substrate is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Substrate. If not, see <http://www.gnu.org/licenses/>.
//! Benchmarking module.
//!
//! Utilities to do full-scale benchmarks involving database. With `BenchDb` you
//! can pregenerate seed database and `clone` it for every iteration of your benchmarks
//! or tests to get consistent, smooth benchmark experience!
use std::{sync::Arc, path::Path, collections::BTreeMap};
use node_primitives::Block;
use crate::client::{Client, Backend};
use crate::keyring::*;
use sc_client_db::PruningMode;
use sc_executor::{NativeExecutor, WasmExecutionMethod};
use sp_consensus::{
BlockOrigin, BlockImport, BlockImportParams,
ForkChoiceStrategy, ImportResult, ImportedAux
};
use sp_runtime::{
generic::BlockId,
OpaqueExtrinsic,
traits::{Block as BlockT, Verify, Zero, IdentifyAccount},
};
use codec::{Decode, Encode};
use node_runtime::{
Call,
CheckedExtrinsic,
constants::currency::DOLLARS,
UncheckedExtrinsic,
MinimumPeriod,
BalancesCall,
AccountId,
Signature,
};
use sp_core::ExecutionContext;
use sp_api::ProvideRuntimeApi;
use sp_block_builder::BlockBuilder;
use sp_inherents::InherentData;
use sc_client_api::{
ExecutionStrategy,
execution_extensions::{ExecutionExtensions, ExecutionStrategies},
};
use sp_core::{Pair, Public, sr25519};
/// Keyring full of accounts for benching.
///
/// Accounts are ordered:
/// //endowed-user//00
/// //endowed-user//01
/// ...
/// //endowed-user//N
#[derive(Clone)]
pub struct BenchKeyring {
accounts: BTreeMap<AccountId, sr25519::Pair>,
}
/// Pre-initialized benchmarking database.
///
/// This is prepared database with genesis and keyring
/// that can be cloned and then used for any benchmarking.
pub struct BenchDb {
keyring: BenchKeyring,
directory_guard: Guard,
}
impl Clone for BenchDb {
fn clone(&self) -> Self {
let keyring = self.keyring.clone();
let dir = tempdir::TempDir::new("sub-bench").expect("temp dir creation failed");
let seed_dir = self.directory_guard.0.path();
log::trace!(
target: "bench-logistics",
"Copying seed db from {} to {}",
seed_dir.to_string_lossy(),
dir.path().to_string_lossy(),
);
let seed_db_files = std::fs::read_dir(seed_dir)
.expect("failed to list file in seed dir")
.map(|f_result|
f_result.expect("failed to read file in seed db")
.path()
.clone()
).collect();
fs_extra::copy_items(
&seed_db_files,
dir.path(),
&fs_extra::dir::CopyOptions::new(),
).expect("Copy of seed database is ok");
BenchDb { keyring, directory_guard: Guard(dir) }
}
}
impl BenchDb {
/// New immutable benchmarking database.
///
/// This will generate database files in random temporary directory
/// and keep it there until struct is dropped.
///
/// You can `clone` this database or you can `create_context` from it
/// (which also do `clone`) to run actual operation against new database
/// which will be identical to this.
pub fn new(keyring_length: usize) -> Self {
let keyring = BenchKeyring::new(keyring_length);
let dir = tempdir::TempDir::new("sub-bench").expect("temp dir creation failed");
log::trace!(
target: "bench-logistics",
"Created seed db at {}",
dir.path().to_string_lossy(),
);
let (_client, _backend) = Self::bench_client(dir.path(), Profile::Native, &keyring);
let directory_guard = Guard(dir);
BenchDb { keyring, directory_guard }
}
// This should return client that is doing everything that full node
// is doing.
//
// - This client should use best wasm execution method.
// - This client should work with real database only.
fn bench_client(dir: &std::path::Path, profile: Profile, keyring: &BenchKeyring) -> (Client, std::sync::Arc<Backend>) {
let db_config = sc_client_db::DatabaseSettings {
state_cache_size: 16*1024*1024,
state_cache_child_ratio: Some((0, 100)),
pruning: PruningMode::ArchiveAll,
source: sc_client_db::DatabaseSettingsSrc::Path {
path: dir.into(),
cache_size: None,
},
};
let (client, backend) = sc_client_db::new_client(
db_config,
NativeExecutor::new(WasmExecutionMethod::Compiled, None),
&keyring.generate_genesis(),
None,
None,
ExecutionExtensions::new(profile.into_execution_strategies(), None),
).expect("Should not fail");
(client, backend)
}
/// Generate new block using this database.
pub fn generate_block(&mut self, transactions: usize) -> Block {
let (client, _backend) = Self::bench_client(
self.directory_guard.path(),
Profile::Wasm,
&self.keyring,
);
let version = client.runtime_version_at(&BlockId::number(0))
.expect("There should be runtime version at 0")
.spec_version;
let genesis_hash = client.block_hash(Zero::zero())
.expect("Database error?")
.expect("Genesis block always exists; qed")
.into();
let mut block = client
.new_block(Default::default())
.expect("Block creation failed");
let timestamp = 1 * MinimumPeriod::get();
let mut inherent_data = InherentData::new();
inherent_data.put_data(sp_timestamp::INHERENT_IDENTIFIER, &timestamp)
.expect("Put timestamp failed");
inherent_data.put_data(sp_finality_tracker::INHERENT_IDENTIFIER, &0)
.expect("Put finality tracker failed");
for extrinsic in client.runtime_api()
.inherent_extrinsics_with_context(
&BlockId::number(0),
ExecutionContext::BlockConstruction,
inherent_data,
).expect("Get inherents failed")
{
block.push(extrinsic).expect("Push inherent failed");
}
let mut iteration = 0;
let start = std::time::Instant::now();
for _ in 0..transactions {
let sender = self.keyring.at(iteration);
let receiver = get_account_id_from_seed::<sr25519::Public>(
&format!("random-user//{}", iteration)
);
let signed = self.keyring.sign(
CheckedExtrinsic {
signed: Some((sender, signed_extra(0, 1*DOLLARS))),
function: Call::Balances(
BalancesCall::transfer(
pallet_indices::address::Address::Id(receiver),
1*DOLLARS
)
),
},
version,
genesis_hash,
);
let encoded = Encode::encode(&signed);
let opaque = OpaqueExtrinsic::decode(&mut &encoded[..])
.expect("Failed to decode opaque");
match block.push(opaque) {
Err(sp_blockchain::Error::ApplyExtrinsicFailed(
sp_blockchain::ApplyExtrinsicFailed::Validity(e)
)) if e.exhausted_resources() => {
break;
},
Err(err) => panic!("Error pushing transaction: {:?}", err),
Ok(_) => {},
}
iteration += 1;
}
let block = block.build().expect("Block build failed").block;
log::info!(
target: "bench-logistics",
"Block construction: {:#?} ({} tx)",
start.elapsed(), block.extrinsics.len()
);
block
}
/// Database path.
pub fn path(&self) -> &Path {
self.directory_guard.path()
}
/// Clone this database and create context for testing/benchmarking.
pub fn create_context(&self, profile: Profile) -> BenchContext {
let BenchDb { directory_guard, keyring } = self.clone();
let (client, backend) = Self::bench_client(directory_guard.path(), profile, &keyring);
BenchContext {
client, backend, db_guard: directory_guard,
}
}
}
impl BenchKeyring {
/// New keyring.
///
/// `length` is the number of accounts generated.
pub fn new(length: usize) -> Self {
let mut accounts = BTreeMap::new();
for n in 0..length {
let seed = format!("//endowed-user/{}", n);
let pair = sr25519::Pair::from_string(&seed, None).expect("failed to generate pair");
let account_id = AccountPublic::from(pair.public()).into_account();
accounts.insert(account_id, pair);
}
Self { accounts }
}
/// Generated account id-s from keyring keypairs.
pub fn collect_account_ids(&self) -> Vec<AccountId> {
self.accounts.keys().cloned().collect()
}
/// Get account id at position `index`
pub fn at(&self, index: usize) -> AccountId {
self.accounts.keys().nth(index).expect("Failed to get account").clone()
}
/// Sign transaction with keypair from this keyring.
pub fn sign(&self, xt: CheckedExtrinsic, version: u32, genesis_hash: [u8; 32]) -> UncheckedExtrinsic {
match xt.signed {
Some((signed, extra)) => {
let payload = (xt.function, extra.clone(), version, genesis_hash, genesis_hash);
let key = self.accounts.get(&signed).expect("Account id not found in keyring");
let signature = payload.using_encoded(|b| {
if b.len() > 256 {
key.sign(&sp_io::hashing::blake2_256(b))
} else {
key.sign(b)
}
}).into();
UncheckedExtrinsic {
signature: Some((pallet_indices::address::Address::Id(signed), signature, extra)),
function: payload.0,
}
}
None => UncheckedExtrinsic {
signature: None,
function: xt.function,
},
}
}
/// Generate genesis with accounts from this keyring endowed with some balance.
pub fn generate_genesis(&self) -> node_runtime::GenesisConfig {
crate::genesis::config_endowed(
false,
Some(node_runtime::WASM_BINARY),
self.collect_account_ids(),
)
}
}
/// Profile for exetion strategies.
#[derive(Clone, Copy, Debug)]
pub enum Profile {
/// As native as possible.
Native,
/// As wasm as possible.
Wasm,
}
impl Profile {
fn into_execution_strategies(self) -> ExecutionStrategies {
match self {
Profile::Wasm => ExecutionStrategies {
syncing: ExecutionStrategy::AlwaysWasm,
importing: ExecutionStrategy::AlwaysWasm,
block_construction: ExecutionStrategy::AlwaysWasm,
offchain_worker: ExecutionStrategy::AlwaysWasm,
other: ExecutionStrategy::AlwaysWasm,
},
Profile::Native => ExecutionStrategies {
syncing: ExecutionStrategy::NativeElseWasm,
importing: ExecutionStrategy::NativeElseWasm,
block_construction: ExecutionStrategy::NativeElseWasm,
offchain_worker: ExecutionStrategy::NativeElseWasm,
other: ExecutionStrategy::NativeElseWasm,
}
}
}
}
struct Guard(tempdir::TempDir);
impl Guard {
fn path(&self) -> &Path {
self.0.path()
}
}
/// Benchmarking/test context holding instantiated client and backend references.
pub struct BenchContext {
/// Node client.
pub client: Client,
/// Node backend.
pub backend: Arc<Backend>,
db_guard: Guard,
}
type AccountPublic = <Signature as Verify>::Signer;
fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
TPublic::Pair::from_string(&format!("//{}", seed), None)
.expect("static values are valid; qed")
.public()
}
fn get_account_id_from_seed<TPublic: Public>(seed: &str) -> AccountId
where
AccountPublic: From<<TPublic::Pair as Pair>::Public>
{
AccountPublic::from(get_from_seed::<TPublic>(seed)).into_account()
}
impl BenchContext {
/// Import some block.
pub fn import_block(&mut self, block: Block) {
let mut import_params = BlockImportParams::new(BlockOrigin::NetworkBroadcast, block.header.clone());
import_params.body = Some(block.extrinsics().to_vec());
import_params.fork_choice = Some(ForkChoiceStrategy::LongestChain);
assert_eq!(self.client.chain_info().best_number, 0);
assert_eq!(
self.client.import_block(import_params, Default::default())
.expect("Failed to import block"),
ImportResult::Imported(
ImportedAux {
header_only: false,
clear_justification_requests: false,
needs_justification: false,
bad_justification: false,
needs_finality_proof: false,
is_new_best: true,
}
)
);
assert_eq!(self.client.chain_info().best_number, 1);
}
/// Database path for the current context.
pub fn path(&self) -> &Path {
self.db_guard.path()
}
}
substrate/bin/node/testing/src/lib.rs
+1 -1
View File
@@ -21,4 +21,4 @@
pub mod client;
pub mod genesis;
pub mod keyring;
pub mod bench;