> {
- match key.map(|k| H256::from_str(&k)) {
- Some(Ok(secret)) => Ok(Some(secret.into())),
- Some(Err(err)) => Err(create_input_err(format!("Error parsing node key: {}", err))),
- None => Ok(None),
+/// Create a `NodeKeyConfig` from the given `NodeKeyParams` in the context
+/// of an optional network config storage directory.
+fn node_key_config(params: NodeKeyParams, net_config_dir: &Option
)
+ -> error::Result
+where
+ P: AsRef
+{
+ match params.node_key_type {
+ NodeKeyType::Secp256k1 =>
+ params.node_key.as_ref().map(parse_secp256k1_secret).unwrap_or_else(||
+ Ok(params.node_key_file
+ .or_else(|| net_config_file(net_config_dir, NODE_KEY_SECP256K1_FILE))
+ .map(network::Secret::File)
+ .unwrap_or(network::Secret::New)))
+ .map(NodeKeyConfig::Secp256k1),
+
+ NodeKeyType::Ed25519 =>
+ params.node_key.as_ref().map(parse_ed25519_secret).unwrap_or_else(||
+ Ok(params.node_key_file
+ .or_else(|| net_config_file(net_config_dir, NODE_KEY_ED25519_FILE))
+ .map(network::Secret::File)
+ .unwrap_or(network::Secret::New)))
+ .map(NodeKeyConfig::Ed25519)
}
}
+fn net_config_file(net_config_dir: &Option
, name: &str) -> Option
+where
+ P: AsRef
+{
+ net_config_dir.as_ref().map(|d| d.as_ref().join(name))
+}
+
+/// Create an error caused by an invalid node key argument.
+fn invalid_node_key(e: impl std::fmt::Display) -> error::Error {
+ input_err(format!("Invalid node key: {}", e))
+}
+
+/// Parse a Secp256k1 secret key from a hex string into a `network::Secret`.
+fn parse_secp256k1_secret(hex: &String) -> error::Result {
+ H256::from_str(hex).map_err(invalid_node_key).and_then(|bytes|
+ network::identity::secp256k1::SecretKey::from_bytes(bytes)
+ .map(network::Secret::Input)
+ .map_err(invalid_node_key))
+}
+
+/// Parse a Ed25519 secret key from a hex string into a `network::Secret`.
+fn parse_ed25519_secret(hex: &String) -> error::Result {
+ H256::from_str(&hex).map_err(invalid_node_key).and_then(|bytes|
+ network::identity::ed25519::SecretKey::from_bytes(bytes)
+ .map(network::Secret::Input)
+ .map_err(invalid_node_key))
+}
+
/// Fill the given `PoolConfiguration` by looking at the cli parameters.
fn fill_transaction_pool_configuration(
options: &mut FactoryFullConfiguration,
@@ -294,7 +354,7 @@ fn fill_network_configuration(
config.public_addresses = Vec::new();
config.client_version = client_id;
- config.use_secret = parse_node_key(cli.node_key)?;
+ config.node_key = node_key_config(cli.node_key_params, &config.net_config_path)?;
config.in_peers = cli.in_peers;
config.out_peers = cli.out_peers;
@@ -316,14 +376,14 @@ where
config.impl_commit = version.commit;
config.impl_version = version.version;
- config.name = match cli.name {
+ config.name = match cli.name.or(cli.keyring.account.map(|a| a.to_string())) {
None => generate_node_name(),
Some(name) => name,
};
match is_node_name_valid(&config.name) {
Ok(_) => (),
Err(msg) => bail!(
- create_input_err(
+ input_err(
format!("Invalid node name '{}'. Reason: {}. If unsure, use none.",
config.name,
msg
@@ -346,7 +406,7 @@ where
Some(ref s) if s == "archive" => PruningMode::ArchiveAll,
None => PruningMode::default(),
Some(s) => PruningMode::keep_blocks(
- s.parse().map_err(|_| create_input_err("Invalid pruning mode specified"))?
+ s.parse().map_err(|_| input_err("Invalid pruning mode specified"))?
),
};
@@ -359,14 +419,25 @@ where
service::Roles::FULL
};
+ let exec = cli.execution_strategies;
config.execution_strategies = ExecutionStrategies {
- syncing: cli.syncing_execution.into(),
- importing: cli.importing_execution.into(),
- block_construction: cli.block_construction_execution.into(),
- other: cli.other_execution.into(),
+ syncing: exec.syncing_execution.into(),
+ importing: exec.importing_execution.into(),
+ block_construction: exec.block_construction_execution.into(),
+ offchain_worker: exec.offchain_worker_execution.into(),
+ other: exec.other_execution.into(),
+ };
+
+ config.offchain_worker = match (cli.offchain_worker, role) {
+ (params::OffchainWorkerEnabled::WhenValidating, service::Roles::AUTHORITY) => true,
+ (params::OffchainWorkerEnabled::Always, _) => true,
+ (params::OffchainWorkerEnabled::Never, _) => false,
+ (params::OffchainWorkerEnabled::WhenValidating, _) => false,
};
config.roles = role;
+ config.disable_grandpa = cli.no_grandpa;
+
let client_id = config.client_id();
fill_network_configuration(
cli.network_config,
@@ -386,7 +457,11 @@ where
}
if cli.shared_params.dev {
- config.keys.push("Alice".into());
+ config.keys.push("//Alice".into());
+ }
+
+ if let Some(account) = cli.keyring.account {
+ config.keys.push(format!("//{}", account));
}
let rpc_interface: &str = if cli.rpc_external { "0.0.0.0" } else { "127.0.0.1" };
@@ -401,11 +476,13 @@ where
// Override telemetry
if cli.no_telemetry {
- config.telemetry_url = None;
- } else if let Some(url) = cli.telemetry_url {
- config.telemetry_url = Some(url);
+ config.telemetry_endpoints = None;
+ } else if !cli.telemetry_endpoints.is_empty() {
+ config.telemetry_endpoints = Some(TelemetryEndpoints::new(cli.telemetry_endpoints));
}
+ config.force_authoring = cli.force_authoring;
+
Ok(config)
}
@@ -438,23 +515,19 @@ where
// 9926-9949 Unassigned
fn with_default_boot_node(
- mut spec: ChainSpec>,
- cli: &BuildSpecCmd,
+ spec: &mut ChainSpec>,
+ cli: BuildSpecCmd,
version: &VersionInfo,
-) -> error::Result>>
+) -> error::Result<()>
where
F: ServiceFactory
{
if spec.boot_nodes().is_empty() {
- let network_path =
- Some(network_path(&base_path(&cli.shared_params, version), spec.id()).to_string_lossy().into());
- let network_key = parse_node_key(cli.node_key.clone())?;
-
- let network_keys =
- network::obtain_private_key(&network_key, &network_path)
- .map_err(|err| format!("Error obtaining network key: {}", err))?;
-
- let peer_id = network_keys.to_peer_id();
+ let base_path = base_path(&cli.shared_params, version);
+ let storage_path = network_path(&base_path, spec.id());
+ let node_key = node_key_config(cli.node_key_params, &Some(storage_path))?;
+ let keys = node_key.into_keypair()?;
+ let peer_id = keys.public().into_peer_id();
let addr = build_multiaddr![
Ip4([127, 0, 0, 1]),
Tcp(30333u16),
@@ -462,7 +535,7 @@ where
];
spec.add_boot_node(addr)
}
- Ok(spec)
+ Ok(())
}
fn build_spec(
@@ -475,9 +548,10 @@ where
S: FnOnce(&str) -> Result>>, String>,
{
info!("Building chain spec");
- let spec = load_spec(&cli.shared_params, spec_factory)?;
- let spec = with_default_boot_node::(spec, &cli, version)?;
- let json = service::chain_ops::build_spec::>(spec, cli.raw)?;
+ let raw_output = cli.raw;
+ let mut spec = load_spec(&cli.shared_params, spec_factory)?;
+ with_default_boot_node::(&mut spec, cli, version)?;
+ let json = service::chain_ops::build_spec::>(spec, raw_output)?;
print!("{}", json);
@@ -573,23 +647,28 @@ where
S: FnOnce(&str) -> Result>>, String>,
{
let config = create_config_with_db_path::(spec_factory, &cli.shared_params, version)?;
-
let db_path = config.database_path;
- print!("Are you sure to remove {:?}? (y/n)", &db_path);
- stdout().flush().expect("failed to flush stdout");
-
- let mut input = String::new();
- stdin().read_line(&mut input)?;
- let input = input.trim();
-
- match input.chars().nth(0) {
- Some('y') | Some('Y') => {
- fs::remove_dir_all(&db_path)?;
- println!("{:?} removed.", &db_path);
- },
- _ => println!("Aborted"),
+
+ if cli.yes == false {
+ print!("Are you sure to remove {:?}? (y/n)", &db_path);
+ stdout().flush().expect("failed to flush stdout");
+
+ let mut input = String::new();
+ stdin().read_line(&mut input)?;
+ let input = input.trim();
+
+ match input.chars().nth(0) {
+ Some('y') | Some('Y') => {},
+ _ => {
+ println!("Aborted");
+ return Ok(());
+ },
+ }
}
+ fs::remove_dir_all(&db_path)?;
+ println!("{:?} removed.", &db_path);
+
Ok(())
}
@@ -697,6 +776,8 @@ fn kill_color(s: &str) -> String {
#[cfg(test)]
mod tests {
use super::*;
+ use tempdir::TempDir;
+ use network::identity::{secp256k1, ed25519};
#[test]
fn tests_node_name_good() {
@@ -712,4 +793,111 @@ mod tests {
assert!(is_node_name_valid("www.visit.me").is_err());
assert!(is_node_name_valid("email@domain").is_err());
}
+
+ #[test]
+ fn test_node_key_config_input() {
+ fn secret_input(net_config_dir: Option) -> error::Result<()> {
+ NodeKeyType::variants().into_iter().try_for_each(|t| {
+ let node_key_type = NodeKeyType::from_str(t).unwrap();
+ let sk = match node_key_type {
+ NodeKeyType::Secp256k1 => secp256k1::SecretKey::generate().as_ref().to_vec(),
+ NodeKeyType::Ed25519 => ed25519::SecretKey::generate().as_ref().to_vec()
+ };
+ let params = NodeKeyParams {
+ node_key_type,
+ node_key: Some(format!("{:x}", H256::from_slice(sk.as_ref()))),
+ node_key_file: None
+ };
+ node_key_config(params, &net_config_dir).and_then(|c| match c {
+ NodeKeyConfig::Secp256k1(network::Secret::Input(ref ski))
+ if node_key_type == NodeKeyType::Secp256k1 &&
+ &sk[..] == ski.as_ref() => Ok(()),
+ NodeKeyConfig::Ed25519(network::Secret::Input(ref ski))
+ if node_key_type == NodeKeyType::Ed25519 &&
+ &sk[..] == ski.as_ref() => Ok(()),
+ _ => Err(input_err("Unexpected node key config"))
+ })
+ })
+ }
+
+ assert!(secret_input(None).is_ok());
+ assert!(secret_input(Some("x".to_string())).is_ok());
+ }
+
+ #[test]
+ fn test_node_key_config_file() {
+ fn secret_file(net_config_dir: Option) -> error::Result<()> {
+ NodeKeyType::variants().into_iter().try_for_each(|t| {
+ let node_key_type = NodeKeyType::from_str(t).unwrap();
+ let tmp = TempDir::new("alice")?;
+ let file = tmp.path().join(format!("{}_mysecret", t)).to_path_buf();
+ let params = NodeKeyParams {
+ node_key_type,
+ node_key: None,
+ node_key_file: Some(file.clone())
+ };
+ node_key_config(params, &net_config_dir).and_then(|c| match c {
+ NodeKeyConfig::Secp256k1(network::Secret::File(ref f))
+ if node_key_type == NodeKeyType::Secp256k1 && f == &file => Ok(()),
+ NodeKeyConfig::Ed25519(network::Secret::File(ref f))
+ if node_key_type == NodeKeyType::Ed25519 && f == &file => Ok(()),
+ _ => Err(input_err("Unexpected node key config"))
+ })
+ })
+ }
+
+ assert!(secret_file(None).is_ok());
+ assert!(secret_file(Some("x".to_string())).is_ok());
+ }
+
+ #[test]
+ fn test_node_key_config_default() {
+ fn with_def_params(f: F) -> error::Result<()>
+ where
+ F: Fn(NodeKeyParams) -> error::Result<()>
+ {
+ NodeKeyType::variants().into_iter().try_for_each(|t| {
+ let node_key_type = NodeKeyType::from_str(t).unwrap();
+ f(NodeKeyParams {
+ node_key_type,
+ node_key: None,
+ node_key_file: None
+ })
+ })
+ }
+
+ fn no_config_dir() -> error::Result<()> {
+ with_def_params(|params| {
+ let typ = params.node_key_type;
+ node_key_config::(params, &None)
+ .and_then(|c| match c {
+ NodeKeyConfig::Secp256k1(network::Secret::New)
+ if typ == NodeKeyType::Secp256k1 => Ok(()),
+ NodeKeyConfig::Ed25519(network::Secret::New)
+ if typ == NodeKeyType::Ed25519 => Ok(()),
+ _ => Err(input_err("Unexpected node key config"))
+ })
+ })
+ }
+
+ fn some_config_dir(net_config_dir: String) -> error::Result<()> {
+ with_def_params(|params| {
+ let dir = PathBuf::from(net_config_dir.clone());
+ let typ = params.node_key_type;
+ node_key_config(params, &Some(net_config_dir.clone()))
+ .and_then(move |c| match c {
+ NodeKeyConfig::Secp256k1(network::Secret::File(ref f))
+ if typ == NodeKeyType::Secp256k1 &&
+ f == &dir.join(NODE_KEY_SECP256K1_FILE) => Ok(()),
+ NodeKeyConfig::Ed25519(network::Secret::File(ref f))
+ if typ == NodeKeyType::Ed25519 &&
+ f == &dir.join(NODE_KEY_ED25519_FILE) => Ok(()),
+ _ => Err(input_err("Unexpected node key config"))
+ })
+ })
+ }
+
+ assert!(no_config_dir().is_ok());
+ assert!(some_config_dir("x".to_string()).is_ok());
+ }
}
diff --git a/core/cli/src/params.rs b/core/cli/src/params.rs
index bd33c7f1f16b7dd86cdc40c920e4fe03bff74bc8..4c2fb5350279a97320d476965f40fe3b29138104 100644
--- a/core/cli/src/params.rs
+++ b/core/cli/src/params.rs
@@ -1,4 +1,4 @@
-// Copyright 2018 Parity Technologies (UK) Ltd.
+// Copyright 2018-2019 Parity Technologies (UK) Ltd.
// This file is part of Substrate.
// Substrate is free software: you can redistribute it and/or modify
@@ -17,7 +17,7 @@
use crate::traits::{AugmentClap, GetLogFilter};
use std::path::PathBuf;
-use structopt::{StructOpt, clap::{arg_enum, _clap_count_exprs, App, AppSettings, SubCommand}};
+use structopt::{StructOpt, clap::{arg_enum, _clap_count_exprs, App, AppSettings, SubCommand, Arg}};
use client;
/// Auxialary macro to implement `GetLogFilter` for all types that have the `shared_params` field.
@@ -39,6 +39,7 @@ arg_enum! {
Wasm,
Both,
NativeElseWasm,
+ NativeWhenPossible,
}
}
@@ -49,10 +50,21 @@ impl Into for ExecutionStrategy {
ExecutionStrategy::Wasm => client::ExecutionStrategy::AlwaysWasm,
ExecutionStrategy::Both => client::ExecutionStrategy::Both,
ExecutionStrategy::NativeElseWasm => client::ExecutionStrategy::NativeElseWasm,
+ ExecutionStrategy::NativeWhenPossible => client::ExecutionStrategy::NativeWhenPossible,
}
}
}
+arg_enum! {
+ /// How to execute blocks
+ #[derive(Debug, Clone)]
+ pub enum OffchainWorkerEnabled {
+ Always,
+ Never,
+ WhenValidating,
+ }
+}
+
/// Shared parameters used by all `CoreParams`.
#[derive(Debug, StructOpt, Clone)]
pub struct SharedParams {
@@ -68,7 +80,7 @@ pub struct SharedParams {
#[structopt(long = "base-path", short = "d", value_name = "PATH", parse(from_os_str))]
pub base_path: Option,
- ///Sets a custom logging filter
+ /// Sets a custom logging filter
#[structopt(short = "l", long = "log", value_name = "LOG_PATTERN")]
pub log: Option,
}
@@ -98,10 +110,6 @@ pub struct NetworkConfigurationParams {
#[structopt(long = "port", value_name = "PORT")]
pub port: Option,
- /// Specify node secret key (64-character hex string)
- #[structopt(long = "node-key", value_name = "KEY")]
- pub node_key: Option,
-
/// Specify the number of outgoing connections we're trying to maintain
#[structopt(long = "out-peers", value_name = "OUT_PEERS", default_value = "25")]
pub out_peers: u32,
@@ -109,6 +117,93 @@ pub struct NetworkConfigurationParams {
/// Specify the maximum number of incoming connections we're accepting
#[structopt(long = "in-peers", value_name = "IN_PEERS", default_value = "25")]
pub in_peers: u32,
+
+ #[allow(missing_docs)]
+ #[structopt(flatten)]
+ pub node_key_params: NodeKeyParams
+}
+
+arg_enum! {
+ #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+ pub enum NodeKeyType {
+ Secp256k1,
+ Ed25519
+ }
+}
+
+/// Parameters used to create the `NodeKeyConfig`, which determines the keypair
+/// used for libp2p networking.
+#[derive(Debug, StructOpt, Clone)]
+pub struct NodeKeyParams {
+ /// The secret key to use for libp2p networking.
+ ///
+ /// The value is a string that is parsed according to the choice of
+ /// `--node-key-type` as follows:
+ ///
+ /// `secp256k1`:
+ /// The value is parsed as a hex-encoded Secp256k1 32 bytes secret key,
+ /// i.e. 64 hex characters.
+ ///
+ /// `ed25519`:
+ /// The value is parsed as a hex-encoded Ed25519 32 bytes secret key,
+ /// i.e. 64 hex characters.
+ ///
+ /// The value of this option takes precedence over `--node-key-file`.
+ ///
+ /// WARNING: Secrets provided as command-line arguments are easily exposed.
+ /// Use of this option should be limited to development and testing. To use
+ /// an externally managed secret key, use `--node-key-file` instead.
+ #[structopt(long = "node-key", value_name = "KEY")]
+ pub node_key: Option,
+
+ /// The type of secret key to use for libp2p networking.
+ ///
+ /// The secret key of the node is obtained as follows:
+ ///
+ /// * If the `--node-key` option is given, the value is parsed as a secret key
+ /// according to the type. See the documentation for `--node-key`.
+ ///
+ /// * If the `--node-key-file` option is given, the secret key is read from the
+ /// specified file. See the documentation for `--node-key-file`.
+ ///
+ /// * Otherwise, the secret key is read from a file with a predetermined,
+ /// type-specific name from the chain-specific network config directory
+ /// inside the base directory specified by `--base-dir`. If this file does
+ /// not exist, it is created with a newly generated secret key of the
+ /// chosen type.
+ ///
+ /// The node's secret key determines the corresponding public key and hence the
+ /// node's peer ID in the context of libp2p.
+ ///
+ /// NOTE: The current default key type is `secp256k1` for a transition period only
+ /// but will eventually change to `ed25519` in a future release. To continue using
+ /// `secp256k1` keys, use `--node-key-type=secp256k1`.
+ #[structopt(
+ long = "node-key-type",
+ value_name = "TYPE",
+ raw(
+ possible_values = "&NodeKeyType::variants()",
+ case_insensitive = "true",
+ default_value = r#""Secp256k1""#
+ )
+ )]
+ pub node_key_type: NodeKeyType,
+
+ /// The file from which to read the node's secret key to use for libp2p networking.
+ ///
+ /// The contents of the file are parsed according to the choice of `--node-key-type`
+ /// as follows:
+ ///
+ /// `secp256k1`:
+ /// The file must contain an unencoded 32 bytes Secp256k1 secret key.
+ ///
+ /// `ed25519`:
+ /// The file must contain an unencoded 32 bytes Ed25519 secret key.
+ ///
+ /// If the file does not exist, it is created with a newly generated secret key of
+ /// the chosen type.
+ #[structopt(long = "node-key-file", value_name = "FILE")]
+ pub node_key_file: Option
}
/// Parameters used to create the pool configuration.
@@ -122,6 +217,70 @@ pub struct TransactionPoolParams {
pub pool_kbytes: usize,
}
+/// Execution strategies parameters.
+#[derive(Debug, StructOpt, Clone)]
+pub struct ExecutionStrategies {
+ /// The means of execution used when calling into the runtime while syncing blocks.
+ #[structopt(
+ long = "syncing-execution",
+ value_name = "STRATEGY",
+ raw(
+ possible_values = "&ExecutionStrategy::variants()",
+ case_insensitive = "true",
+ default_value = r#""NativeElseWasm""#
+ )
+ )]
+ pub syncing_execution: ExecutionStrategy,
+
+ /// The means of execution used when calling into the runtime while importing blocks.
+ #[structopt(
+ long = "importing-execution",
+ value_name = "STRATEGY",
+ raw(
+ possible_values = "&ExecutionStrategy::variants()",
+ case_insensitive = "true",
+ default_value = r#""NativeElseWasm""#
+ )
+ )]
+ pub importing_execution: ExecutionStrategy,
+
+ /// The means of execution used when calling into the runtime while constructing blocks.
+ #[structopt(
+ long = "block-construction-execution",
+ value_name = "STRATEGY",
+ raw(
+ possible_values = "&ExecutionStrategy::variants()",
+ case_insensitive = "true",
+ default_value = r#""Wasm""#
+ )
+ )]
+ pub block_construction_execution: ExecutionStrategy,
+
+ /// The means of execution used when calling into the runtime while constructing blocks.
+ #[structopt(
+ long = "offchain-worker-execution",
+ value_name = "STRATEGY",
+ raw(
+ possible_values = "&ExecutionStrategy::variants()",
+ case_insensitive = "true",
+ default_value = r#""NativeWhenPossible""#
+ )
+ )]
+ pub offchain_worker_execution: ExecutionStrategy,
+
+ /// The means of execution used when calling into the runtime while not syncing, importing or constructing blocks.
+ #[structopt(
+ long = "other-execution",
+ value_name = "STRATEGY",
+ raw(
+ possible_values = "&ExecutionStrategy::variants()",
+ case_insensitive = "true",
+ default_value = r#""Wasm""#
+ )
+ )]
+ pub other_execution: ExecutionStrategy,
+}
+
/// The `run` command used to run a node.
#[derive(Debug, StructOpt, Clone)]
pub struct RunCmd {
@@ -137,6 +296,10 @@ pub struct RunCmd {
#[structopt(long = "validator")]
pub validator: bool,
+ /// Disable GRANDPA when running in validator mode
+ #[structopt(long = "no-grandpa")]
+ pub no_grandpa: bool,
+
/// Run in light client mode
#[structopt(long = "light")]
pub light: bool,
@@ -169,63 +332,33 @@ pub struct RunCmd {
#[structopt(long = "name", value_name = "NAME")]
pub name: Option,
- /// Should not connect to the Substrate telemetry server (telemetry is on by default on global chains)
+ /// Disable connecting to the Substrate telemetry server (telemetry is on by default on global chains).
#[structopt(long = "no-telemetry")]
pub no_telemetry: bool,
- /// The URL of the telemetry server to connect to
- #[structopt(long = "telemetry-url", value_name = "TELEMETRY_URL")]
- pub telemetry_url: Option,
-
- /// The means of execution used when calling into the runtime while syncing blocks.
- #[structopt(
- long = "syncing-execution",
- value_name = "STRATEGY",
- raw(
- possible_values = "&ExecutionStrategy::variants()",
- case_insensitive = "true",
- default_value = r#""NativeElseWasm""#
- )
- )]
- pub syncing_execution: ExecutionStrategy,
-
- /// The means of execution used when calling into the runtime while importing blocks.
- #[structopt(
- long = "importing-execution",
- value_name = "STRATEGY",
- raw(
- possible_values = "&ExecutionStrategy::variants()",
- case_insensitive = "true",
- default_value = r#""NativeElseWasm""#
- )
- )]
- pub importing_execution: ExecutionStrategy,
+ /// The URL of the telemetry server to connect to. This flag can be passed multiple times
+ /// as a mean to specify multiple telemetry endpoints. Verbosity levels range from 0-9, with
+ /// 0 denoting the least verbosity. If no verbosity level is specified the default is 0.
+ #[structopt(long = "telemetry-url", value_name = "URL VERBOSITY", parse(try_from_str = "parse_telemetry_endpoints"))]
+ pub telemetry_endpoints: Vec<(String, u8)>,
- /// The means of execution used when calling into the runtime while constructing blocks.
+ /// Should execute offchain workers on every block. By default it's only enabled for nodes that are authoring new
+ /// blocks.
#[structopt(
- long = "block-construction-execution",
- value_name = "STRATEGY",
+ long = "offchain-worker",
+ value_name = "ENABLED",
raw(
- possible_values = "&ExecutionStrategy::variants()",
+ possible_values = "&OffchainWorkerEnabled::variants()",
case_insensitive = "true",
- default_value = r#""Wasm""#
+ default_value = r#""WhenValidating""#
)
)]
- pub block_construction_execution: ExecutionStrategy,
+ pub offchain_worker: OffchainWorkerEnabled,
- /// The means of execution used when calling into the runtime while not syncing, importing or constructing blocks.
- #[structopt(
- long = "other-execution",
- value_name = "STRATEGY",
- raw(
- possible_values = "&ExecutionStrategy::variants()",
- case_insensitive = "true",
- default_value = r#""Wasm""#
- )
- )]
- pub other_execution: ExecutionStrategy,
+ #[allow(missing_docs)]
+ #[structopt(flatten)]
+ pub execution_strategies: ExecutionStrategies,
-
#[allow(missing_docs)]
#[structopt(flatten)]
pub shared_params: SharedParams,
@@ -237,6 +370,99 @@ pub struct RunCmd {
#[allow(missing_docs)]
#[structopt(flatten)]
pub pool_config: TransactionPoolParams,
+
+ #[allow(missing_docs)]
+ #[structopt(flatten)]
+ pub keyring: Keyring,
+
+ /// Enable authoring even when offline.
+ #[structopt(long = "force-authoring")]
+ pub force_authoring: bool,
+}
+
+/// Stores all required Cli values for a keyring test account.
+struct KeyringTestAccountCliValues {
+ help: String,
+ conflicts_with: Vec,
+ name: String,
+ variant: keyring::AuthorityKeyring,
+}
+
+lazy_static::lazy_static! {
+ /// The Cli values for all test accounts.
+ static ref TEST_ACCOUNTS_CLI_VALUES: Vec = {
+ keyring::AuthorityKeyring::iter().map(|a| {
+ let help = format!("Shortcut for `--key //{} --name {}`.", a, a);
+ let conflicts_with = keyring::AuthorityKeyring::iter()
+ .filter(|b| a != *b)
+ .map(|b| b.to_string().to_lowercase())
+ .chain(["name", "key"].iter().map(|s| s.to_string()))
+ .collect::>();
+ let name = a.to_string().to_lowercase();
+
+ KeyringTestAccountCliValues {
+ help,
+ conflicts_with,
+ name,
+ variant: a,
+ }
+ }).collect()
+ };
+}
+
+/// Wrapper for exposing the keyring test accounts into the Cli.
+#[derive(Debug, Clone)]
+pub struct Keyring {
+ pub account: Option,
+}
+
+impl StructOpt for Keyring {
+ fn clap<'a, 'b>() -> App<'a, 'b> {
+ unimplemented!("Should not be called for `TestAccounts`.")
+ }
+
+ fn from_clap(m: &::structopt::clap::ArgMatches) -> Self {
+ Keyring {
+ account: TEST_ACCOUNTS_CLI_VALUES.iter().find(|a| m.is_present(&a.name)).map(|a| a.variant),
+ }
+ }
+}
+
+impl AugmentClap for Keyring {
+ fn augment_clap<'a, 'b>(app: App<'a, 'b>) -> App<'a, 'b> {
+ TEST_ACCOUNTS_CLI_VALUES.iter().fold(app, |app, a| {
+ let conflicts_with_strs = a.conflicts_with.iter().map(|s| s.as_str()).collect::>();
+
+ app.arg(
+ Arg::with_name(&a.name)
+ .long(&a.name)
+ .help(&a.help)
+ .conflicts_with_all(&conflicts_with_strs)
+ .takes_value(false)
+ )
+ })
+ }
+}
+
+impl Keyring {
+ fn is_subcommand() -> bool {
+ false
+ }
+}
+
+/// Default to verbosity level 0, if none is provided.
+fn parse_telemetry_endpoints(s: &str) -> Result<(String, u8), Box> {
+ let pos = s.find(' ');
+ match pos {
+ None => {
+ Ok((s.to_owned(), 0))
+ },
+ Some(pos_) => {
+ let verbosity = s[pos_ + 1..].parse()?;
+ let url = s[..pos_].parse()?;
+ Ok((url, verbosity))
+ }
+ }
}
impl_augment_clap!(RunCmd);
@@ -253,9 +479,9 @@ pub struct BuildSpecCmd {
#[structopt(flatten)]
pub shared_params: SharedParams,
- /// Specify node secret key (64-character hex string)
- #[structopt(long = "node-key", value_name = "KEY")]
- pub node_key: Option,
+ #[allow(missing_docs)]
+ #[structopt(flatten)]
+ pub node_key_params: NodeKeyParams,
}
impl_get_log_filter!(BuildSpecCmd);
@@ -321,6 +547,10 @@ impl_get_log_filter!(RevertCmd);
/// The `purge-chain` command used to remove the whole chain.
#[derive(Debug, StructOpt, Clone)]
pub struct PurgeChainCmd {
+ /// Skip interactive prompt by answering yes automatically.
+ #[structopt(short = "y")]
+ pub yes: bool,
+
#[allow(missing_docs)]
#[structopt(flatten)]
pub shared_params: SharedParams,
diff --git a/core/client/Cargo.toml b/core/client/Cargo.toml
index bc2911a0ae29579a296149f1dab6e9171ae3abaf..0f0eca441ad1b816fcc45bf0228edd031bc2094b 100644
--- a/core/client/Cargo.toml
+++ b/core/client/Cargo.toml
@@ -18,10 +18,9 @@ state-machine = { package = "substrate-state-machine", path = "../state-machine"
keyring = { package = "substrate-keyring", path = "../keyring", optional = true }
trie = { package = "substrate-trie", path = "../trie", optional = true }
substrate-telemetry = { path = "../telemetry", optional = true }
-hash-db = { version = "0.11", optional = true }
+hash-db = { version = "0.12", default-features = false }
kvdb = { git = "https://github.com/paritytech/parity-common", optional = true, rev="b0317f649ab2c665b7987b8475878fc4d2e1f81d" }
-parity-codec = { version = "3.0", default-features = false }
-parity-codec-derive = { version = "3.0", default-features = false }
+parity-codec = { version = "3.2", default-features = false, features = ["derive"] }
primitives = { package = "substrate-primitives", path = "../primitives", default-features = false }
runtime-primitives = { package = "sr-primitives", path = "../sr-primitives", default-features = false }
runtime-version = { package = "sr-version", path = "../sr-version", default-features = false }
@@ -36,11 +35,14 @@ kvdb-memorydb = { git = "https://github.com/paritytech/parity-common", rev="b031
[features]
default = ["std"]
std = [
+ "rstd/std",
"parity-codec/std",
- "parity-codec-derive/std",
- "consensus",
"primitives/std",
"inherents/std",
+ "runtime-primitives/std",
+ "runtime-version/std",
+ "hash-db/std",
+ "consensus",
"parking_lot",
"error-chain",
"fnv",
@@ -49,13 +51,9 @@ std = [
"futures",
"heapsize",
"executor",
- "runtime-primitives/std",
- "runtime-version/std",
- "rstd/std",
"state-machine",
"keyring",
"trie",
"substrate-telemetry",
- "hash-db",
"kvdb"
]
diff --git a/core/client/db/Cargo.toml b/core/client/db/Cargo.toml
index 6408fa0dc80b3716ffd8d50b02c834a3b6d95aa0..7fc1cc5d9575018a462dd731277600de8cf442b5 100644
--- a/core/client/db/Cargo.toml
+++ b/core/client/db/Cargo.toml
@@ -12,13 +12,12 @@ kvdb = { git = "https://github.com/paritytech/parity-common", rev="b0317f649ab2c
kvdb-rocksdb = { git = "https://github.com/paritytech/parity-common", rev="b0317f649ab2c665b7987b8475878fc4d2e1f81d" }
kvdb-memorydb = { git = "https://github.com/paritytech/parity-common", rev="b0317f649ab2c665b7987b8475878fc4d2e1f81d", optional = true }
lru-cache = "0.1.1"
-hash-db = { version = "0.11" }
+hash-db = { version = "0.12" }
primitives = { package = "substrate-primitives", path = "../../primitives" }
runtime_primitives = { package = "sr-primitives", path = "../../sr-primitives" }
client = { package = "substrate-client", path = "../../client" }
state-machine = { package = "substrate-state-machine", path = "../../state-machine" }
-parity-codec = "3.0"
-parity-codec-derive = "3.0"
+parity-codec = { version = "3.2", features = ["derive"] }
executor = { package = "substrate-executor", path = "../../executor" }
state_db = { package = "substrate-state-db", path = "../../state-db" }
trie = { package = "substrate-trie", path = "../../trie" }
diff --git a/core/client/db/src/cache/list_cache.rs b/core/client/db/src/cache/list_cache.rs
index f8e52e14c630f07b421eaff4b69ca1bd0071c4fc..1e641534f969c0d63eefe387e98c9ded8bb3c81a 100644
--- a/core/client/db/src/cache/list_cache.rs
+++ b/core/client/db/src/cache/list_cache.rs
@@ -1,4 +1,4 @@
-// Copyright 2017-2018 Parity Technologies (UK) Ltd.
+// Copyright 2017-2019 Parity Technologies (UK) Ltd.
// This file is part of Substrate.
// Substrate is free software: you can redistribute it and/or modify
diff --git a/core/client/db/src/cache/list_entry.rs b/core/client/db/src/cache/list_entry.rs
index b54094fa00deb3b6a5a8e1a8b02297de2b42a7f2..237ae9a268026744b87f6d85b7c6301cb82ee204 100644
--- a/core/client/db/src/cache/list_entry.rs
+++ b/core/client/db/src/cache/list_entry.rs
@@ -1,4 +1,4 @@
-// Copyright 2017-2018 Parity Technologies (UK) Ltd.
+// Copyright 2017-2019 Parity Technologies (UK) Ltd.
// This file is part of Substrate.
// Substrate is free software: you can redistribute it and/or modify
@@ -18,7 +18,7 @@
use client::error::Result as ClientResult;
use runtime_primitives::traits::{Block as BlockT, NumberFor};
-use parity_codec_derive::{Encode, Decode};
+use parity_codec::{Encode, Decode};
use crate::cache::{CacheItemT, ComplexBlockId};
use crate::cache::list_storage::{Storage};
diff --git a/core/client/db/src/cache/list_storage.rs b/core/client/db/src/cache/list_storage.rs
index b9bf99f67b884fba4ae85f358cb9c0b731cb834b..659a30507e136576a844624fa167eb1cfb08ddb9 100644
--- a/core/client/db/src/cache/list_storage.rs
+++ b/core/client/db/src/cache/list_storage.rs
@@ -1,4 +1,4 @@
-// Copyright 2017-2018 Parity Technologies (UK) Ltd.
+// Copyright 2017-2019 Parity Technologies (UK) Ltd.
// This file is part of Substrate.
// Substrate is free software: you can redistribute it and/or modify
diff --git a/core/client/db/src/cache/mod.rs b/core/client/db/src/cache/mod.rs
index 8df8e42518347e05019b2571febb78b58b536ce2..3d669e392d01c86fc4c6666aec40728c950862ef 100644
--- a/core/client/db/src/cache/mod.rs
+++ b/core/client/db/src/cache/mod.rs
@@ -1,4 +1,4 @@
-// Copyright 2017-2018 Parity Technologies (UK) Ltd.
+// Copyright 2017-2019 Parity Technologies (UK) Ltd.
// This file is part of Substrate.
// Substrate is free software: you can redistribute it and/or modify
@@ -24,7 +24,6 @@ use kvdb::{KeyValueDB, DBTransaction};
use client::blockchain::Cache as BlockchainCache;
use client::error::Result as ClientResult;
use parity_codec::{Encode, Decode};
-use parity_codec_derive::{Encode, Decode};
use runtime_primitives::generic::BlockId;
use runtime_primitives::traits::{Block as BlockT, Header as HeaderT, NumberFor, As, AuthorityIdFor};
use crate::utils::{self, COLUMN_META};
diff --git a/core/client/db/src/lib.rs b/core/client/db/src/lib.rs
index 99483b428882c5617746c8864944f6e8468bb4c8..93adb990240a629550ab73c4e0caa19a0185f38a 100644
--- a/core/client/db/src/lib.rs
+++ b/core/client/db/src/lib.rs
@@ -1,4 +1,4 @@
-// Copyright 2017-2018 Parity Technologies (UK) Ltd.
+// Copyright 2017-2019 Parity Technologies (UK) Ltd.
// This file is part of Substrate.
// Substrate is free software: you can redistribute it and/or modify
@@ -40,7 +40,7 @@ use client::ExecutionStrategies;
use parity_codec::{Decode, Encode};
use hash_db::Hasher;
use kvdb::{KeyValueDB, DBTransaction};
-use trie::MemoryDB;
+use trie::{MemoryDB, PrefixedMemoryDB, prefixed_key};
use parking_lot::RwLock;
use primitives::{H256, Blake2Hasher, ChangesTrieConfiguration, convert_hash};
use primitives::storage::well_known_keys;
@@ -51,7 +51,7 @@ use state_machine::backend::Backend as StateBackend;
use executor::RuntimeInfo;
use state_machine::{CodeExecutor, DBValue};
use crate::utils::{Meta, db_err, meta_keys, open_database, read_db, block_id_to_lookup_key, read_meta};
-use client::LeafSet;
+use client::leaves::{LeafSet, FinalizationDisplaced};
use client::children;
use state_db::StateDb;
use crate::storage_cache::{CachingState, SharedCache, new_shared_cache};
@@ -259,7 +259,7 @@ impl client::blockchain::Backend for BlockchainDb {
/// Database transaction
pub struct BlockImportOperation {
old_state: CachingState,
- db_updates: MemoryDB,
+ db_updates: PrefixedMemoryDB,
storage_updates: Vec<(Vec, Option>)>,
changes_trie_updates: MemoryDB,
pending_block: Option>,
@@ -310,7 +310,7 @@ where Block: BlockT,
// currently authorities are not cached on full nodes
}
- fn update_db_storage(&mut self, update: MemoryDB) -> Result<(), client::error::Error> {
+ fn update_db_storage(&mut self, update: PrefixedMemoryDB) -> Result<(), client::error::Error> {
self.db_updates = update;
Ok(())
}
@@ -321,7 +321,7 @@ where Block: BlockT,
return Err(client::error::ErrorKind::GenesisInvalid.into());
}
- let mut transaction: MemoryDB = Default::default();
+ let mut transaction: PrefixedMemoryDB = Default::default();
for (child_key, child_map) in children {
if !well_known_keys::is_child_storage_key(&child_key) {
@@ -374,22 +374,23 @@ where Block: BlockT,
struct StorageDb {
pub db: Arc,
- pub state_db: StateDb,
+ pub state_db: StateDb>,
}
impl state_machine::Storage for StorageDb {
- fn get(&self, key: &H256) -> Result, String> {
- self.state_db.get(key, self).map(|r| r.map(|v| DBValue::from_slice(&v)))
+ fn get(&self, key: &H256, prefix: &[u8]) -> Result, String> {
+ let key = prefixed_key::(key, prefix);
+ self.state_db.get(&key, self).map(|r| r.map(|v| DBValue::from_slice(&v)))
.map_err(|e| format!("Database backend error: {:?}", e))
}
}
-impl state_db::HashDb for StorageDb {
+impl state_db::NodeDb for StorageDb {
type Error = io::Error;
- type Hash = H256;
+ type Key = [u8];
- fn get(&self, key: &H256) -> Result>, Self::Error> {
- self.db.get(columns::STATE, key.as_bytes()).map(|r| r.map(|v| v.to_vec()))
+ fn get(&self, key: &[u8]) -> Result>, Self::Error> {
+ self.db.get(columns::STATE, key).map(|r| r.map(|v| v.to_vec()))
}
}
@@ -405,7 +406,7 @@ impl DbGenesisStorage {
}
impl state_machine::Storage for DbGenesisStorage {
- fn get(&self, _key: &H256) -> Result, String> {
+ fn get(&self, _key: &H256, _prefix: &[u8]) -> Result, String> {
Ok(None)
}
}
@@ -515,7 +516,7 @@ impl state_machine::ChangesTrieRootsStorage for DbC
}
impl state_machine::ChangesTrieStorage for DbChangesTrieStorage {
- fn get(&self, key: &H256) -> Result, String> {
+ fn get(&self, key: &H256, _prefix: &[u8]) -> Result, String> {
self.db.get(columns::CHANGES_TRIE, &key[..])
.map_err(|err| format!("{}", err))
}
@@ -559,7 +560,7 @@ impl> Backend {
let blockchain = BlockchainDb::new(db.clone())?;
let meta = blockchain.meta.clone();
let map_e = |e: state_db::Error| ::client::error::Error::from(format!("State database error: {:?}", e));
- let state_db: StateDb = StateDb::new(pruning, &StateMetaDb(&*db)).map_err(map_e)?;
+ let state_db: StateDb<_, _> = StateDb::new(pruning, &StateMetaDb(&*db)).map_err(map_e)?;
let storage_db = StorageDb {
db: db.clone(),
state_db,
@@ -714,11 +715,18 @@ impl> Backend {
header: &Block::Header,
last_finalized: Option,
justification: Option,
+ finalization_displaced: &mut Option>>,
) -> Result<(Block::Hash, ::Number, bool, bool), client::error::Error> {
// TODO: ensure best chain contains this block.
let number = *header.number();
self.ensure_sequential_finalization(header, last_finalized)?;
- self.note_finalized(transaction, header, *hash)?;
+ self.note_finalized(
+ transaction,
+ header,
+ *hash,
+ finalization_displaced,
+ )?;
+
if let Some(justification) = justification {
transaction.put(
columns::JUSTIFICATION,
@@ -767,10 +775,13 @@ impl> Backend {
-> Result<(), client::error::Error>
{
let mut transaction = DBTransaction::new();
+ let mut finalization_displaced_leaves = None;
+
operation.apply_aux(&mut transaction);
let mut meta_updates = Vec::new();
let mut last_finalized_hash = self.blockchain.meta.read().finalized_hash;
+
if !operation.finalized_blocks.is_empty() {
for (block, justification) in operation.finalized_blocks {
let block_hash = self.blockchain.expect_block_hash_from_id(&block)?;
@@ -782,6 +793,7 @@ impl> Backend {
&block_header,
Some(last_finalized_hash),
justification,
+ &mut finalization_displaced_leaves,
)?);
last_finalized_hash = block_hash;
}
@@ -821,7 +833,7 @@ impl> Backend {
transaction.put(columns::META, meta_keys::GENESIS_HASH, hash.as_ref());
}
- let mut changeset: state_db::ChangeSet = state_db::ChangeSet::default();
+ let mut changeset: state_db::ChangeSet> = state_db::ChangeSet::default();
for (key, (val, rc)) in operation.db_updates.drain() {
if rc > 0 {
changeset.inserted.push((key, val.to_vec()));
@@ -846,7 +858,12 @@ impl> Backend {
if finalized {
// TODO: ensure best chain contains this block.
self.ensure_sequential_finalization(header, Some(last_finalized_hash))?;
- self.note_finalized(&mut transaction, header, hash)?;
+ self.note_finalized(
+ &mut transaction,
+ header,
+ hash,
+ &mut finalization_displaced_leaves,
+ )?;
} else {
// canonicalize blocks which are old enough, regardless of finality.
self.force_delayed_canonicalize(&mut transaction, hash, *header.number())?
@@ -892,9 +909,16 @@ impl> Backend {
if let Some((number, hash, enacted, retracted, displaced_leaf, is_best)) = imported {
if let Err(e) = write_result {
+ let mut leaves = self.blockchain.leaves.write();
+ let mut undo = leaves.undo();
if let Some(displaced_leaf) = displaced_leaf {
- self.blockchain.leaves.write().undo(displaced_leaf);
+ undo.undo_import(displaced_leaf);
+ }
+
+ if let Some(finalization_displaced) = finalization_displaced_leaves {
+ undo.undo_finalization(finalization_displaced);
}
+
return Err(e)
}
@@ -924,6 +948,7 @@ impl> Backend {
transaction: &mut DBTransaction,
f_header: &Block::Header,
f_hash: Block::Hash,
+ displaced: &mut Option>>
) -> Result<(), client::error::Error> where
Block: BlockT,
{
@@ -947,11 +972,17 @@ impl> Backend {
self.changes_tries_storage.prune(changes_trie_config, transaction, f_hash, f_num);
}
+ let new_displaced = self.blockchain.leaves.write().finalize_height(f_num);
+ match displaced {
+ x @ &mut None => *x = Some(new_displaced),
+ &mut Some(ref mut displaced) => displaced.merge(new_displaced),
+ }
+
Ok(())
}
}
-fn apply_state_commit(transaction: &mut DBTransaction, commit: state_db::CommitSet) {
+fn apply_state_commit(transaction: &mut DBTransaction, commit: state_db::CommitSet>) {
for (key, val) in commit.data.inserted.into_iter() {
transaction.put(columns::STATE, &key[..], &val);
}
@@ -1001,7 +1032,7 @@ impl client::backend::Backend for Backend whe
Ok(BlockImportOperation {
pending_block: None,
old_state,
- db_updates: MemoryDB::default(),
+ db_updates: PrefixedMemoryDB::default(),
storage_updates: Default::default(),
changes_trie_updates: MemoryDB::default(),
aux_ops: Vec::new(),
@@ -1036,22 +1067,27 @@ impl client::backend::Backend for Backend whe
let mut transaction = DBTransaction::new();
let hash = self.blockchain.expect_block_hash_from_id(&block)?;
let header = self.blockchain.expect_header(block)?;
- let commit = || {
+ let mut displaced = None;
+ let commit = |displaced| {
let (hash, number, is_best, is_finalized) = self.finalize_block_with_transaction(
&mut transaction,
&hash,
&header,
None,
justification,
+ displaced,
)?;
self.storage.db.write(transaction).map_err(db_err)?;
self.blockchain.update_meta(hash, number, is_best, is_finalized);
Ok(())
};
- match commit() {
+ match commit(&mut displaced) {
Ok(()) => self.storage.state_db.apply_pending(),
e @ Err(_) => {
self.storage.state_db.revert_pending();
+ if let Some(displaced) = displaced {
+ self.blockchain.leaves.write().undo().undo_finalization(displaced);
+ }
return e;
}
}
@@ -1134,6 +1170,10 @@ impl client::backend::Backend for Backend whe
}
}
+ fn have_state_at(&self, hash: &Block::Hash, number: NumberFor) -> bool {
+ !self.storage.state_db.is_pruned(hash, number.as_())
+ }
+
fn destroy_state(&self, mut state: Self::State) -> Result<(), client::error::Error> {
if let Some(hash) = state.parent_hash.clone() {
let is_best = || self.blockchain.meta.read().best_hash == hash;
@@ -1152,6 +1192,7 @@ mod tests {
use super::*;
use crate::columns;
use client::backend::Backend as BTrait;
+ use client::blockchain::Backend as BLBTrait;
use client::backend::BlockImportOperation as Op;
use runtime_primitives::testing::{Header, Block as RawBlock, ExtrinsicWrapper};
use runtime_primitives::traits::{Hash, BlakeTwo256};
@@ -1374,7 +1415,7 @@ mod tests {
op.reset_storage(storage.iter().cloned().collect(), Default::default()).unwrap();
- key = op.db_updates.insert(b"hello");
+ key = op.db_updates.insert(&[], b"hello");
op.set_block_data(
header,
Some(vec![]),
@@ -1408,8 +1449,8 @@ mod tests {
).0.into();
let hash = header.hash();
- op.db_updates.insert(b"hello");
- op.db_updates.remove(&key);
+ op.db_updates.insert(&[], b"hello");
+ op.db_updates.remove(&key, &[]);
op.set_block_data(
header,
Some(vec![]),
@@ -1443,7 +1484,7 @@ mod tests {
).0.into();
let hash = header.hash();
- op.db_updates.remove(&key);
+ op.db_updates.remove(&key, &[]);
op.set_block_data(
header,
Some(vec![]),
@@ -1509,7 +1550,7 @@ mod tests {
assert_eq!(backend.changes_tries_storage.root(&anchor, block), Ok(Some(changes_root)));
for (key, (val, _)) in changes_trie_update.drain() {
- assert_eq!(backend.changes_trie_storage().unwrap().get(&key), Ok(Some(val)));
+ assert_eq!(backend.changes_trie_storage().unwrap().get(&key, &[]), Ok(Some(val)));
}
};
@@ -1635,23 +1676,23 @@ mod tests {
let mut tx = DBTransaction::new();
backend.changes_tries_storage.prune(Some(config.clone()), &mut tx, Default::default(), 12);
backend.storage.db.write(tx).unwrap();
- assert!(backend.changes_tries_storage.get(&root1).unwrap().is_none());
- assert!(backend.changes_tries_storage.get(&root2).unwrap().is_none());
- assert!(backend.changes_tries_storage.get(&root3).unwrap().is_none());
- assert!(backend.changes_tries_storage.get(&root4).unwrap().is_none());
- assert!(backend.changes_tries_storage.get(&root5).unwrap().is_some());
- assert!(backend.changes_tries_storage.get(&root6).unwrap().is_some());
- assert!(backend.changes_tries_storage.get(&root7).unwrap().is_some());
- assert!(backend.changes_tries_storage.get(&root8).unwrap().is_some());
+ assert!(backend.changes_tries_storage.get(&root1, &[]).unwrap().is_none());
+ assert!(backend.changes_tries_storage.get(&root2, &[]).unwrap().is_none());
+ assert!(backend.changes_tries_storage.get(&root3, &[]).unwrap().is_none());
+ assert!(backend.changes_tries_storage.get(&root4, &[]).unwrap().is_none());
+ assert!(backend.changes_tries_storage.get(&root5, &[]).unwrap().is_some());
+ assert!(backend.changes_tries_storage.get(&root6, &[]).unwrap().is_some());
+ assert!(backend.changes_tries_storage.get(&root7, &[]).unwrap().is_some());
+ assert!(backend.changes_tries_storage.get(&root8, &[]).unwrap().is_some());
// now simulate finalization of block#16, causing prune of tries at #5..#8
let mut tx = DBTransaction::new();
backend.changes_tries_storage.prune(Some(config.clone()), &mut tx, Default::default(), 16);
backend.storage.db.write(tx).unwrap();
- assert!(backend.changes_tries_storage.get(&root5).unwrap().is_none());
- assert!(backend.changes_tries_storage.get(&root6).unwrap().is_none());
- assert!(backend.changes_tries_storage.get(&root7).unwrap().is_none());
- assert!(backend.changes_tries_storage.get(&root8).unwrap().is_none());
+ assert!(backend.changes_tries_storage.get(&root5, &[]).unwrap().is_none());
+ assert!(backend.changes_tries_storage.get(&root6, &[]).unwrap().is_none());
+ assert!(backend.changes_tries_storage.get(&root7, &[]).unwrap().is_none());
+ assert!(backend.changes_tries_storage.get(&root8, &[]).unwrap().is_none());
// now "change" pruning mode to archive && simulate finalization of block#20
// => no changes tries are pruned, because we never prune in archive mode
@@ -1659,10 +1700,10 @@ mod tests {
let mut tx = DBTransaction::new();
backend.changes_tries_storage.prune(Some(config), &mut tx, Default::default(), 20);
backend.storage.db.write(tx).unwrap();
- assert!(backend.changes_tries_storage.get(&root9).unwrap().is_some());
- assert!(backend.changes_tries_storage.get(&root10).unwrap().is_some());
- assert!(backend.changes_tries_storage.get(&root11).unwrap().is_some());
- assert!(backend.changes_tries_storage.get(&root12).unwrap().is_some());
+ assert!(backend.changes_tries_storage.get(&root9, &[]).unwrap().is_some());
+ assert!(backend.changes_tries_storage.get(&root10, &[]).unwrap().is_some());
+ assert!(backend.changes_tries_storage.get(&root11, &[]).unwrap().is_some());
+ assert!(backend.changes_tries_storage.get(&root12, &[]).unwrap().is_some());
}
#[test]
@@ -1701,15 +1742,15 @@ mod tests {
let mut tx = DBTransaction::new();
backend.changes_tries_storage.prune(Some(config.clone()), &mut tx, block5, 5);
backend.storage.db.write(tx).unwrap();
- assert!(backend.changes_tries_storage.get(&root1).unwrap().is_none());
- assert!(backend.changes_tries_storage.get(&root2).unwrap().is_some());
+ assert!(backend.changes_tries_storage.get(&root1, &[]).unwrap().is_none());
+ assert!(backend.changes_tries_storage.get(&root2, &[]).unwrap().is_some());
// now simulate finalization of block#6, causing prune of tries at #2
let mut tx = DBTransaction::new();
backend.changes_tries_storage.prune(Some(config.clone()), &mut tx, block6, 6);
backend.storage.db.write(tx).unwrap();
- assert!(backend.changes_tries_storage.get(&root2).unwrap().is_none());
- assert!(backend.changes_tries_storage.get(&root3).unwrap().is_some());
+ assert!(backend.changes_tries_storage.get(&root2, &[]).unwrap().is_none());
+ assert!(backend.changes_tries_storage.get(&root3, &[]).unwrap().is_some());
}
#[test]
@@ -1789,8 +1830,6 @@ mod tests {
BlockId::Hash(block1),
).unwrap();
- println!("{:?}", tree_route);
-
assert_eq!(tree_route.common_block().hash, block0);
assert!(tree_route.retracted().is_empty());
assert_eq!(tree_route.enacted().iter().map(|r| r.hash).collect::>(), vec![block1]);
@@ -1815,6 +1854,30 @@ mod tests {
test_client::trait_tests::test_blockchain_query_by_number_gets_canonical(backend);
}
+ #[test]
+ fn test_leaves_pruned_on_finality() {
+ let backend: Backend = Backend::new_test(10, 10);
+ let block0 = insert_header(&backend, 0, Default::default(), Default::default(), Default::default());
+
+ let block1_a = insert_header(&backend, 1, block0, Default::default(), Default::default());
+ let block1_b = insert_header(&backend, 1, block0, Default::default(), [1; 32].into());
+ let block1_c = insert_header(&backend, 1, block0, Default::default(), [2; 32].into());
+
+ assert_eq!(backend.blockchain().leaves().unwrap(), vec![block1_a, block1_b, block1_c]);
+
+ let block2_a = insert_header(&backend, 2, block1_a, Default::default(), Default::default());
+ let block2_b = insert_header(&backend, 2, block1_b, Default::default(), Default::default());
+ let block2_c = insert_header(&backend, 2, block1_b, Default::default(), [1; 32].into());
+
+ assert_eq!(backend.blockchain().leaves().unwrap(), vec![block2_a, block2_b, block2_c, block1_c]);
+
+ backend.finalize_block(BlockId::hash(block1_a), None).unwrap();
+ backend.finalize_block(BlockId::hash(block2_a), None).unwrap();
+
+ // leaves at same height stay. Leaves at lower heights pruned.
+ assert_eq!(backend.blockchain().leaves().unwrap(), vec![block2_a, block2_b, block2_c]);
+ }
+
#[test]
fn test_aux() {
let backend: Backend = Backend::new_test(0, 0);
diff --git a/core/client/db/src/light.rs b/core/client/db/src/light.rs
index b86ebb93ef70de950548befa01a65421e94d12f7..d99ef503b2f81047d341140233b51d17160d0bdb 100644
--- a/core/client/db/src/light.rs
+++ b/core/client/db/src/light.rs
@@ -1,4 +1,4 @@
-// Copyright 2017-2018 Parity Technologies (UK) Ltd.
+// Copyright 2017-2019 Parity Technologies (UK) Ltd.
// This file is part of Substrate.
// Substrate is free software: you can redistribute it and/or modify
@@ -24,7 +24,8 @@ use kvdb::{KeyValueDB, DBTransaction};
use client::backend::{AuxStore, NewBlockState};
use client::blockchain::{BlockStatus, Cache as BlockchainCache,
HeaderBackend as BlockchainHeaderBackend, Info as BlockchainInfo};
-use client::{cht, LeafSet};
+use client::cht;
+use client::leaves::{LeafSet, FinalizationDisplaced};
use client::error::{ErrorKind as ClientErrorKind, Result as ClientResult};
use client::light::blockchain::Storage as LightBlockchainStorage;
use parity_codec::{Decode, Encode};
@@ -250,6 +251,7 @@ impl LightStorage {
transaction: &mut DBTransaction,
header: &Block::Header,
hash: Block::Hash,
+ displaced: &mut Option>>,
) -> ClientResult<()> {
let meta = self.meta.read();
if &meta.finalized_hash != header.parent_hash() {
@@ -311,6 +313,12 @@ impl LightStorage {
}
}
+ let new_displaced = self.leaves.write().finalize_height(header.number().clone());
+ match displaced {
+ x @ &mut None => *x = Some(new_displaced),
+ &mut Some(ref mut displaced) => displaced.merge(new_displaced),
+ }
+
Ok(())
}
@@ -366,6 +374,7 @@ impl LightBlockchainStorage for LightStorage
leaf_state: NewBlockState,
aux_ops: Vec<(Vec, Option>)>,
) -> ClientResult<()> {
+ let mut finalization_displaced_leaves = None;
let mut transaction = DBTransaction::new();
let hash = header.hash();
@@ -394,18 +403,24 @@ impl LightBlockchainStorage for LightStorage
);
transaction.put(columns::HEADER, &lookup_key, &header.encode());
- if number.is_zero() {
- transaction.put(columns::META, meta_keys::FINALIZED_BLOCK, &lookup_key);
+ let is_genesis = number.is_zero();
+ if is_genesis {
transaction.put(columns::META, meta_keys::GENESIS_HASH, hash.as_ref());
}
let finalized = match leaf_state {
+ _ if is_genesis => true,
NewBlockState::Final => true,
_ => false,
};
if finalized {
- self.note_finalized(&mut transaction, &header, hash)?;
+ self.note_finalized(
+ &mut transaction,
+ &header,
+ hash,
+ &mut finalization_displaced_leaves,
+ )?;
}
{
@@ -425,10 +440,18 @@ impl LightBlockchainStorage for LightStorage
debug!("Light DB Commit {:?} ({})", hash, number);
let write_result = self.db.write(transaction).map_err(db_err);
if let Err(e) = write_result {
+ let mut leaves = self.leaves.write();
+ let mut undo = leaves.undo();
+
// revert leaves set update if there was one.
if let Some(displaced_leaf) = displaced_leaf {
- leaves.undo(displaced_leaf);
+ undo.undo_import(displaced_leaf);
}
+
+ if let Some(finalization_displaced) = finalization_displaced_leaves {
+ undo.undo_finalization(finalization_displaced);
+ }
+
return Err(e);
}
@@ -464,10 +487,11 @@ impl LightBlockchainStorage for LightStorage
fn finalize_header(&self, id: BlockId) -> ClientResult<()> {
if let Some(header) = self.header(id)? {
+ let mut displaced = None;
let mut transaction = DBTransaction::new();
let hash = header.hash();
let number = *header.number();
- self.note_finalized(&mut transaction, &header, hash.clone())?;
+ self.note_finalized(&mut transaction, &header, hash.clone(), &mut displaced)?;
{
let mut cache = self.cache.0.write();
let cache_ops = cache.transaction(&mut transaction)
@@ -477,7 +501,12 @@ impl LightBlockchainStorage for LightStorage
)?
.into_ops();
- self.db.write(transaction).map_err(db_err)?;
+ if let Err(e) = self.db.write(transaction).map_err(db_err) {
+ if let Some(displaced) = displaced {
+ self.leaves.write().undo().undo_finalization(displaced);
+ }
+ return Err(e);
+ }
cache.commit(cache_ops);
}
self.update_meta(hash, header.number().clone(), false, true);
@@ -512,6 +541,7 @@ pub(crate) mod tests {
use super::*;
type Block = RawBlock>;
+ type AuthorityId = AuthorityIdFor;
pub fn default_header(parent: &Hash, number: u64) -> Header {
Header {
@@ -802,10 +832,10 @@ pub(crate) mod tests {
let checks = vec![
(0, None),
(1, None),
- (2, Some(vec![[1u8; 32].into()])),
- (3, Some(vec![[1u8; 32].into()])),
- (4, Some(vec![[1u8; 32].into(), [2u8; 32].into()])),
- (5, Some(vec![[1u8; 32].into(), [2u8; 32].into()])),
+ (2, Some(vec![AuthorityId::from_raw([1u8; 32])])),
+ (3, Some(vec![AuthorityId::from_raw([1u8; 32])])),
+ (4, Some(vec![AuthorityId::from_raw([1u8; 32]), AuthorityId::from_raw([2u8; 32])])),
+ (5, Some(vec![AuthorityId::from_raw([1u8; 32]), AuthorityId::from_raw([2u8; 32])])),
(6, None),
(7, None), // block will work for 'future' block too
];
@@ -814,13 +844,13 @@ pub(crate) mod tests {
run_checks(&db, 0, &checks);
let hash1 = insert_final_block(&db, None, || default_header(&hash0, 1));
run_checks(&db, 1, &checks);
- let hash2 = insert_final_block(&db, Some(vec![[1u8; 32].into()]), || default_header(&hash1, 2));
+ let hash2 = insert_final_block(&db, Some(vec![AuthorityId::from_raw([1u8; 32])]), || default_header(&hash1, 2));
run_checks(&db, 2, &checks);
- let hash3 = insert_final_block(&db, Some(vec![[1u8; 32].into()]), || default_header(&hash2, 3));
+ let hash3 = insert_final_block(&db, Some(vec![AuthorityId::from_raw([1u8; 32])]), || default_header(&hash2, 3));
run_checks(&db, 3, &checks);
- let hash4 = insert_final_block(&db, Some(vec![[1u8; 32].into(), [2u8; 32].into()]), || default_header(&hash3, 4));
+ let hash4 = insert_final_block(&db, Some(vec![AuthorityId::from_raw([1u8; 32]), AuthorityId::from_raw([2u8; 32])]), || default_header(&hash3, 4));
run_checks(&db, 4, &checks);
- let hash5 = insert_final_block(&db, Some(vec![[1u8; 32].into(), [2u8; 32].into()]), || default_header(&hash4, 5));
+ let hash5 = insert_final_block(&db, Some(vec![AuthorityId::from_raw([1u8; 32]), AuthorityId::from_raw([2u8; 32])]), || default_header(&hash4, 5));
run_checks(&db, 5, &checks);
let hash6 = insert_final_block(&db, None, || default_header(&hash5, 6));
run_checks(&db, 7, &checks);
@@ -832,9 +862,9 @@ pub(crate) mod tests {
// some older non-best blocks are inserted
// ... -> B2(1) -> B2_1(1) -> B2_2(2)
// => the cache ignores all writes before best finalized block
- let hash2_1 = insert_non_best_block(&db, Some(vec![[1u8; 32].into()]), || default_header(&hash2, 3));
+ let hash2_1 = insert_non_best_block(&db, Some(vec![AuthorityId::from_raw([1u8; 32])]), || default_header(&hash2, 3));
assert_eq!(None, db.cache().authorities_at(BlockId::Hash(hash2_1)));
- let hash2_2 = insert_non_best_block(&db, Some(vec![[1u8; 32].into(), [2u8; 32].into()]), || default_header(&hash2_1, 4));
+ let hash2_2 = insert_non_best_block(&db, Some(vec![AuthorityId::from_raw([1u8; 32]), AuthorityId::from_raw([2u8; 32])]), || default_header(&hash2_1, 4));
assert_eq!(None, db.cache().authorities_at(BlockId::Hash(hash2_2)));
}
@@ -845,39 +875,39 @@ pub(crate) mod tests {
// \> B6_1_1(5)
// \> B6_1_2(6) -> B6_1_3(7)
- let hash7 = insert_block(&db, Some(vec![[3u8; 32].into()]), || default_header(&hash6, 7));
+ let hash7 = insert_block(&db, Some(vec![AuthorityId::from_raw([3u8; 32])]), || default_header(&hash6, 7));
assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6)), None);
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash7)), Some(vec![[3u8; 32].into()]));
- let hash8 = insert_block(&db, Some(vec![[3u8; 32].into()]), || default_header(&hash7, 8));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash7)), Some(vec![AuthorityId::from_raw([3u8; 32])]));
+ let hash8 = insert_block(&db, Some(vec![AuthorityId::from_raw([3u8; 32])]), || default_header(&hash7, 8));
assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6)), None);
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash7)), Some(vec![[3u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash8)), Some(vec![[3u8; 32].into()]));
- let hash6_1 = insert_block(&db, Some(vec![[4u8; 32].into()]), || default_header(&hash6, 7));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash7)), Some(vec![AuthorityId::from_raw([3u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash8)), Some(vec![AuthorityId::from_raw([3u8; 32])]));
+ let hash6_1 = insert_block(&db, Some(vec![AuthorityId::from_raw([4u8; 32])]), || default_header(&hash6, 7));
assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6)), None);
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash7)), Some(vec![[3u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash8)), Some(vec![[3u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1)), Some(vec![[4u8; 32].into()]));
- let hash6_1_1 = insert_non_best_block(&db, Some(vec![[5u8; 32].into()]), || default_header(&hash6_1, 8));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash7)), Some(vec![AuthorityId::from_raw([3u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash8)), Some(vec![AuthorityId::from_raw([3u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1)), Some(vec![AuthorityId::from_raw([4u8; 32])]));
+ let hash6_1_1 = insert_non_best_block(&db, Some(vec![AuthorityId::from_raw([5u8; 32])]), || default_header(&hash6_1, 8));
assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6)), None);
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash7)), Some(vec![[3u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash8)), Some(vec![[3u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1)), Some(vec![[4u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1_1)), Some(vec![[5u8; 32].into()]));
- let hash6_1_2 = insert_non_best_block(&db, Some(vec![[6u8; 32].into()]), || default_header(&hash6_1, 8));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash7)), Some(vec![AuthorityId::from_raw([3u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash8)), Some(vec![AuthorityId::from_raw([3u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1)), Some(vec![AuthorityId::from_raw([4u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1_1)), Some(vec![AuthorityId::from_raw([5u8; 32])]));
+ let hash6_1_2 = insert_non_best_block(&db, Some(vec![AuthorityId::from_raw([6u8; 32])]), || default_header(&hash6_1, 8));
assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6)), None);
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash7)), Some(vec![[3u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash8)), Some(vec![[3u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1)), Some(vec![[4u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1_1)), Some(vec![[5u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1_2)), Some(vec![[6u8; 32].into()]));
- let hash6_2 = insert_block(&db, Some(vec![[4u8; 32].into()]), || default_header(&hash6_1, 8));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash7)), Some(vec![AuthorityId::from_raw([3u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash8)), Some(vec![AuthorityId::from_raw([3u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1)), Some(vec![AuthorityId::from_raw([4u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1_1)), Some(vec![AuthorityId::from_raw([5u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1_2)), Some(vec![AuthorityId::from_raw([6u8; 32])]));
+ let hash6_2 = insert_block(&db, Some(vec![AuthorityId::from_raw([4u8; 32])]), || default_header(&hash6_1, 8));
assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6)), None);
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash7)), Some(vec![[3u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash8)), Some(vec![[3u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1)), Some(vec![[4u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1_1)), Some(vec![[5u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1_2)), Some(vec![[6u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_2)), Some(vec![[4u8; 32].into()]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash7)), Some(vec![AuthorityId::from_raw([3u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash8)), Some(vec![AuthorityId::from_raw([3u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1)), Some(vec![AuthorityId::from_raw([4u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1_1)), Some(vec![AuthorityId::from_raw([5u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1_2)), Some(vec![AuthorityId::from_raw([6u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_2)), Some(vec![AuthorityId::from_raw([4u8; 32])]));
(hash7, hash8, hash6_1, hash6_2, hash6_1_1, hash6_1_2)
};
@@ -888,19 +918,19 @@ pub(crate) mod tests {
assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6)), None);
assert_eq!(db.cache().authorities_at(BlockId::Hash(hash7)), None);
assert_eq!(db.cache().authorities_at(BlockId::Hash(hash8)), None);
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1)), Some(vec![[4u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1_1)), Some(vec![[5u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1_2)), Some(vec![[6u8; 32].into()]));
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_2)), Some(vec![[4u8; 32].into()]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1)), Some(vec![AuthorityId::from_raw([4u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1_1)), Some(vec![AuthorityId::from_raw([5u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1_2)), Some(vec![AuthorityId::from_raw([6u8; 32])]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_2)), Some(vec![AuthorityId::from_raw([4u8; 32])]));
// finalize block hash6_2
db.finalize_header(BlockId::Hash(hash6_2)).unwrap();
assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6)), None);
assert_eq!(db.cache().authorities_at(BlockId::Hash(hash7)), None);
assert_eq!(db.cache().authorities_at(BlockId::Hash(hash8)), None);
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1)), Some(vec![[4u8; 32].into()]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1)), Some(vec![AuthorityId::from_raw([4u8; 32])]));
assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1_1)), None);
assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_1_2)), None);
- assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_2)), Some(vec![[4u8; 32].into()]));
+ assert_eq!(db.cache().authorities_at(BlockId::Hash(hash6_2)), Some(vec![AuthorityId::from_raw([4u8; 32])]));
}
}
@@ -940,4 +970,28 @@ pub(crate) mod tests {
assert_eq!(db.get_aux(&[2]).unwrap(), Some(vec![102]));
assert_eq!(db.get_aux(&[3]).unwrap(), Some(vec![103]));
}
+
+ #[test]
+ fn test_leaves_pruned_on_finality() {
+ let db = LightStorage::::new_test();
+ let block0 = insert_block(&db, None, || default_header(&Default::default(), 0));
+
+ let block1_a = insert_block(&db, None, || default_header(&block0, 1));
+ let block1_b = insert_block(&db, None, || header_with_extrinsics_root(&block0, 1, [1; 32].into()));
+ let block1_c = insert_block(&db, None, || header_with_extrinsics_root(&block0, 1, [2; 32].into()));
+
+ assert_eq!(db.leaves.read().hashes(), vec![block1_a, block1_b, block1_c]);
+
+ let block2_a = insert_block(&db, None, || default_header(&block1_a, 2));
+ let block2_b = insert_block(&db, None, || header_with_extrinsics_root(&block1_b, 2, [1; 32].into()));
+ let block2_c = insert_block(&db, None, || header_with_extrinsics_root(&block1_b, 2, [2; 32].into()));
+
+ assert_eq!(db.leaves.read().hashes(), vec![block2_a, block2_b, block2_c, block1_c]);
+
+ db.finalize_header(BlockId::hash(block1_a)).unwrap();
+ db.finalize_header(BlockId::hash(block2_a)).unwrap();
+
+ // leaves at same height stay. Leaves at lower heights pruned.
+ assert_eq!(db.leaves.read().hashes(), vec![block2_a, block2_b, block2_c]);
+ }
}
diff --git a/core/client/db/src/storage_cache.rs b/core/client/db/src/storage_cache.rs
index da07aa4d5a923ebffd5c745438f75e1e399862e8..6cfdbdd09b53db4ea986965550d076831cd07eae 100644
--- a/core/client/db/src/storage_cache.rs
+++ b/core/client/db/src/storage_cache.rs
@@ -109,7 +109,7 @@ impl, B: Block> CachingState {
}
}
- /// Propagate local cache into the shared cache and synchonize
+ /// Propagate local cache into the shared cache and synchronize
/// the shared cache with the best block state.
/// This function updates the shared cache by removing entries
/// that are invalidated by chain reorganization. `sync_cache`
diff --git a/core/client/db/src/utils.rs b/core/client/db/src/utils.rs
index 150c1fdd98ccdef5b596735f2e523bd179a3a35f..ce843a93a2fa4531761d1f94925bb14a23d9f72a 100644
--- a/core/client/db/src/utils.rs
+++ b/core/client/db/src/utils.rs
@@ -1,4 +1,4 @@
-// Copyright 2017-2018 Parity Technologies (UK) Ltd.
+// Copyright 2017-2019 Parity Technologies (UK) Ltd.
// This file is part of Substrate.
// Substrate is free software: you can redistribute it and/or modify
diff --git a/core/client/src/backend.rs b/core/client/src/backend.rs
index 7b1136c92951bec62dffa9ada5047db2653d703b..9b063177ff14bd4b66f0fcb55c8ae562a2a18b23 100644
--- a/core/client/src/backend.rs
+++ b/core/client/src/backend.rs
@@ -1,4 +1,4 @@
-// Copyright 2017-2018 Parity Technologies (UK) Ltd.
+// Copyright 2017-2019 Parity Technologies (UK) Ltd.
// This file is part of Substrate.
// Substrate is free software: you can redistribute it and/or modify
@@ -142,6 +142,10 @@ pub trait Backend: AuxStore + Send + Sync where
fn blockchain(&self) -> &Self::Blockchain;
/// Returns reference to changes trie storage.
fn changes_trie_storage(&self) -> Option<&Self::ChangesTrieStorage>;
+ /// Returns true if state for given block is available.
+ fn have_state_at(&self, hash: &Block::Hash, _number: NumberFor) -> bool {
+ self.state_at(BlockId::Hash(hash.clone())).is_ok()
+ }
/// Returns state backend with post-state of given block.
fn state_at(&self, block: BlockId) -> error::Result;
/// Destroy state and save any useful data, such as cache.
diff --git a/core/client/src/block_builder/api.rs b/core/client/src/block_builder/api.rs
index f0f9a231229b04b831ad26e62e937aee8090d111..8aad26277738152d940810518d3523de71de77cc 100644
--- a/core/client/src/block_builder/api.rs
+++ b/core/client/src/block_builder/api.rs
@@ -1,4 +1,4 @@
-// Copyright 2018 Parity Technologies (UK) Ltd.
+// Copyright 2018-2019 Parity Technologies (UK) Ltd.
// This file is part of Substrate.
// Substrate is free software: you can redistribute it and/or modify
@@ -16,46 +16,10 @@
//! The runtime api for building blocks.
-use runtime_primitives::{traits::Block as BlockT, ApplyResult, RuntimeString};
+use runtime_primitives::{traits::Block as BlockT, ApplyResult};
use rstd::vec::Vec;
use sr_api_macros::decl_runtime_apis;
pub use inherents::{InherentData, CheckInherentsResult};
-use parity_codec_derive::{Encode, Decode};
-
-/// The old representation of the inherent data.
-#[doc(hide)]
-#[derive(Encode, Decode)]
-pub struct OldInherentData {
- /// Current timestamp.
- pub timestamp: u64,
- /// Blank report.
- pub consensus: (),
- /// Aura expected slot. Can take any value during block construction.
- pub aura_expected_slot: u64,
-}
-
-impl OldInherentData {
- /// Create a new `BasicInherentData` instance.
- pub fn new(timestamp: u64, expected_slot: u64) -> Self {
- Self {
- timestamp,
- consensus: (),
- aura_expected_slot: expected_slot,
- }
- }
-}
-
-/// Error type used while checking inherents.
-#[doc(hide)]
-#[derive(Encode, PartialEq)]
-#[cfg_attr(feature = "std", derive(Decode))]
-pub enum OldCheckInherentError {
- /// The inherents are generally valid but a delay until the given timestamp
- /// is required.
- ValidAtTimestamp(u64),
- /// Some other error has occurred.
- Other(RuntimeString),
-}
decl_runtime_apis! {
/// The `BlockBuilder` api trait that provides required functions for building a block for a runtime.
@@ -69,11 +33,6 @@ decl_runtime_apis! {
fn inherent_extrinsics(inherent: InherentData) -> Vec<::Extrinsic>;
/// Check that the inherents are valid. The inherent data will vary from chain to chain.
fn check_inherents(block: Block, data: InherentData) -> CheckInherentsResult;
- /// Check that the inherents are valid. The inherent data will vary from chain to chain.
- ///
- /// Old version that is used by the CC network.
- #[changed_in(2)]
- fn check_inherents(block: Block, data: OldInherentData) -> ::std::result::Result<(), OldCheckInherentError>;
/// Generate a random seed.
fn random_seed() -> ::Hash;
}
diff --git a/core/client/src/block_builder/block_builder.rs b/core/client/src/block_builder/block_builder.rs
index 1cc3e4c1a9ee171848328d702ccba9eb403d2de0..63e18e827984e2e07adc2273770cea7d227a7c44 100644
--- a/core/client/src/block_builder/block_builder.rs
+++ b/core/client/src/block_builder/block_builder.rs
@@ -1,4 +1,4 @@
-// Copyright 2017-2018 Parity Technologies (UK) Ltd.
+// Copyright 2017-2019 Parity Technologies (UK) Ltd.
// This file is part of Substrate.
// Substrate is free software: you can redistribute it and/or modify
@@ -17,15 +17,15 @@
use super::api::BlockBuilder as BlockBuilderApi;
use std::vec::Vec;
use parity_codec::Encode;
-use crate::blockchain::HeaderBackend;
+use runtime_primitives::ApplyOutcome;
+use runtime_primitives::generic::BlockId;
use runtime_primitives::traits::{
Header as HeaderT, Hash, Block as BlockT, One, HashFor, ProvideRuntimeApi, ApiRef
};
-use primitives::H256;
-use runtime_primitives::generic::BlockId;
+use primitives::{H256, ExecutionContext};
+use crate::blockchain::HeaderBackend;
use crate::runtime_api::Core;
use crate::error;
-use runtime_primitives::{ApplyOutcome, ExecutionContext};
/// Utility for building new (valid) blocks from a stream of extrinsics.
diff --git a/core/client/src/block_builder/mod.rs b/core/client/src/block_builder/mod.rs
index f22f599ffdd9a2ae356bef3006aff19a4225bd2d..7f617044a42cf7cbb734f516a702591f60742c10 100644
--- a/core/client/src/block_builder/mod.rs
+++ b/core/client/src/block_builder/mod.rs
@@ -1,4 +1,4 @@
-// Copyright 2018 Parity Technologies (UK) Ltd.
+// Copyright 2018-2019 Parity Technologies (UK) Ltd.
// This file is part of Substrate.
// Substrate is free software: you can redistribute it and/or modify
diff --git a/core/client/src/blockchain.rs b/core/client/src/blockchain.rs
index eb9ce1342eade2c58ef154d583a302f4ddb54987..a18c6e5d577a8bef1dbbacf53614869373f148e4 100644
--- a/core/client/src/blockchain.rs
+++ b/core/client/src/blockchain.rs
@@ -1,4 +1,4 @@
-// Copyright 2017-2018 Parity Technologies (UK) Ltd.
+// Copyright 2017-2019 Parity Technologies (UK) Ltd.
// This file is part of Substrate.
// Substrate is free software: you can redistribute it and/or modify
diff --git a/core/client/src/call_executor.rs b/core/client/src/call_executor.rs
index 13ff478f3becb1ef271596256eb6659e1e47e1fd..0dad56be0740371ad01e74d6253adec89127346a 100644
--- a/core/client/src/call_executor.rs
+++ b/core/client/src/call_executor.rs
@@ -1,4 +1,4 @@
-// Copyright 2017-2018 Parity Technologies (UK) Ltd.
+// Copyright 2017-2019 Parity Technologies (UK) Ltd.
// This file is part of Substrate.
// Substrate is free software: you can redistribute it and/or modify
@@ -19,12 +19,12 @@ use parity_codec::{Encode, Decode};
use runtime_primitives::generic::BlockId;
use runtime_primitives::traits::Block as BlockT;
use state_machine::{
- self, OverlayedChanges, Ext, CodeExecutor, ExecutionManager, ExecutionStrategy
+ self, OverlayedChanges, Ext, CodeExecutor, ExecutionManager, ExecutionStrategy, NeverOffchainExt,
};
use executor::{RuntimeVersion, RuntimeInfo, NativeVersion};
use hash_db::Hasher;
use trie::MemoryDB;
-use primitives::{H256, Blake2Hasher, NativeOrEncoded, NeverNativeValue};
+use primitives::{H256, Blake2Hasher, NativeOrEncoded, NeverNativeValue, OffchainExt};
use crate::backend;
use crate::error;
@@ -42,12 +42,15 @@ where
/// Execute a call to a contract on top of state in a block of given hash.
///
/// No changes are made.
- fn call(
+ fn call<
+ O: OffchainExt,
+ >(
&self,
id: &BlockId,
method: &str,
call_data: &[u8],
strategy: ExecutionStrategy,
+ side_effects_handler: Option<&mut O>,
) -> Result, error::Error>;
/// Execute a contextual call on top of state in a block of a given hash.
@@ -56,6 +59,7 @@ where
/// Before executing the method, passed header is installed as the current header
/// of the execution context.
fn contextual_call<
+ O: OffchainExt,
PB: Fn() -> error::Result,
EM: Fn(
Result, Self::Error>,
@@ -73,6 +77,7 @@ where
prepare_environment_block: PB,
execution_manager: ExecutionManager,
native_call: Option,
+ side_effects_handler: Option<&mut O>,
) -> error::Result> where ExecutionManager: Clone;
/// Extract RuntimeVersion of given block
@@ -84,6 +89,7 @@ where
///
/// No changes are made.
fn call_at_state<
+ O: OffchainExt,
S: state_machine::Backend,
F: FnOnce(
Result, Self::Error>,
@@ -98,6 +104,7 @@ where
call_data: &[u8],
manager: ExecutionManager,
native_call: Option,
+ side_effects_handler: Option<&mut O>,
) -> Result<(NativeOrEncoded, S::Transaction, Option>), error::Error>;
/// Execute a call to a contract on top of given state, gathering execution proof.
@@ -140,7 +147,10 @@ pub struct LocalCallExecutor {
impl LocalCallExecutor {
/// Creates new instance of local call executor.
pub fn new(backend: Arc, executor: E) -> Self {
- LocalCallExecutor { backend, executor }
+ LocalCallExecutor {
+ backend,
+ executor,
+ }
}
}
@@ -161,17 +171,19 @@ where
{
type Error = E::Error;
- fn call(&self,
+ fn call(&self,
id: &BlockId,
method: &str,
call_data: &[u8],
- strategy: ExecutionStrategy
+ strategy: ExecutionStrategy,
+ side_effects_handler: Option<&mut O>,
) -> error::Result> {
let mut changes = OverlayedChanges::default();
let state = self.backend.state_at(*id)?;
let return_data = state_machine::new(
&state,
self.backend.changes_trie_storage(),
+ side_effects_handler,
&mut changes,
&self.executor,
method,
@@ -187,6 +199,7 @@ where
}
fn contextual_call<
+ O: OffchainExt,
PB: Fn() -> error::Result,
EM: Fn(
Result, Self::Error>,
@@ -204,6 +217,7 @@ where
prepare_environment_block: PB,
execution_manager: ExecutionManager,
native_call: Option,
+ mut side_effects_handler: Option<&mut O>,
) -> Result, error::Error> where ExecutionManager