(params, spec_factory, version).map(|_| None)
+ }
+ params::CoreParams::Custom(params) => Ok(Some(params)),
+ }
}
/// 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
+fn node_key_config(
+ params: NodeKeyParams,
+ net_config_dir: &Option
,
+) -> error::Result
where
- P: AsRef
+ 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)
- }
+ 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
+ P: AsRef,
{
- net_config_dir.as_ref().map(|d| d.as_ref().join(name))
+ 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))
+ 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))
+ 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))
+ 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,
- params: TransactionPoolParams,
+ options: &mut FactoryFullConfiguration,
+ params: TransactionPoolParams,
) -> error::Result<()> {
- // ready queue
- options.transaction_pool.ready.count = params.pool_limit;
- options.transaction_pool.ready.total_bytes = params.pool_kbytes * 1024;
+ // ready queue
+ options.transaction_pool.ready.count = params.pool_limit;
+ options.transaction_pool.ready.total_bytes = params.pool_kbytes * 1024;
- // future queue
- let factor = 10;
- options.transaction_pool.future.count = params.pool_limit / factor;
- options.transaction_pool.future.total_bytes = params.pool_kbytes * 1024 / factor;
+ // future queue
+ let factor = 10;
+ options.transaction_pool.future.count = params.pool_limit / factor;
+ options.transaction_pool.future.total_bytes = params.pool_kbytes * 1024 / factor;
- Ok(())
+ Ok(())
}
/// Fill the given `NetworkConfiguration` by looking at the cli parameters.
fn fill_network_configuration(
- cli: NetworkConfigurationParams,
- base_path: &Path,
- chain_spec_id: &str,
- config: &mut NetworkConfiguration,
- client_id: String,
+ cli: NetworkConfigurationParams,
+ base_path: &Path,
+ chain_spec_id: &str,
+ config: &mut NetworkConfiguration,
+ client_id: String,
) -> error::Result<()> {
- config.boot_nodes.extend(cli.bootnodes.into_iter());
- config.config_path = Some(
- network_path(&base_path, chain_spec_id).to_string_lossy().into()
- );
- config.net_config_path = config.config_path.clone();
- config.reserved_nodes.extend(cli.reserved_nodes.into_iter());
- if !config.reserved_nodes.is_empty() {
- config.non_reserved_mode = NonReservedPeerMode::Deny;
- }
+ config.boot_nodes.extend(cli.bootnodes.into_iter());
+ config.config_path = Some(
+ network_path(&base_path, chain_spec_id)
+ .to_string_lossy()
+ .into(),
+ );
+ config.net_config_path = config.config_path.clone();
+ config.reserved_nodes.extend(cli.reserved_nodes.into_iter());
+ if !config.reserved_nodes.is_empty() {
+ config.non_reserved_mode = NonReservedPeerMode::Deny;
+ }
- for addr in cli.listen_addr.iter() {
- let addr = addr.parse().map_err(|_| "Invalid listen multiaddress")?;
- config.listen_addresses.push(addr);
- }
+ for addr in cli.listen_addr.iter() {
+ let addr = addr.parse().map_err(|_| "Invalid listen multiaddress")?;
+ config.listen_addresses.push(addr);
+ }
- if config.listen_addresses.is_empty() {
- let port = match cli.port {
- Some(port) => port,
- None => 30333,
- };
+ if config.listen_addresses.is_empty() {
+ let port = match cli.port {
+ Some(port) => port,
+ None => 30333,
+ };
- config.listen_addresses = vec![
- iter::once(Protocol::Ip4(Ipv4Addr::new(0, 0, 0, 0)))
- .chain(iter::once(Protocol::Tcp(port)))
- .collect()
- ];
- }
+ config.listen_addresses = vec![iter::once(Protocol::Ip4(Ipv4Addr::new(0, 0, 0, 0)))
+ .chain(iter::once(Protocol::Tcp(port)))
+ .collect()];
+ }
- config.public_addresses = Vec::new();
+ config.public_addresses = Vec::new();
- config.client_version = client_id;
- config.node_key = node_key_config(cli.node_key_params, &config.net_config_path)?;
+ config.client_version = client_id;
+ 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;
+ config.in_peers = cli.in_peers;
+ config.out_peers = cli.out_peers;
- config.enable_mdns = !cli.no_mdns;
+ config.enable_mdns = !cli.no_mdns;
- Ok(())
+ Ok(())
}
fn create_run_node_config(
- cli: RunCmd, spec_factory: S, impl_name: &'static str, version: &VersionInfo
+ cli: RunCmd,
+ spec_factory: S,
+ impl_name: &'static str,
+ version: &VersionInfo,
) -> error::Result>
where
- F: ServiceFactory,
- S: FnOnce(&str) -> Result>>, String>,
+ F: ServiceFactory,
+ S: FnOnce(&str) -> Result>>, String>,
{
- let spec = load_spec(&cli.shared_params, spec_factory)?;
- let mut config = service::Configuration::default_with_spec(spec.clone());
-
- config.impl_name = impl_name;
- config.impl_commit = version.commit;
- config.impl_version = version.version;
-
- 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!(
- input_err(
- format!("Invalid node name '{}'. Reason: {}. If unsure, use none.",
- config.name,
- msg
- )
- )
- )
- }
-
- let base_path = base_path(&cli.shared_params, version);
-
- config.keystore_path = cli.keystore_path
- .unwrap_or_else(|| keystore_path(&base_path, config.chain_spec.id()))
- .to_string_lossy()
- .into();
-
- config.database_path =
- db_path(&base_path, config.chain_spec.id()).to_string_lossy().into();
- config.database_cache_size = cli.database_cache_size;
- config.pruning = match cli.pruning {
- Some(ref s) if s == "archive" => PruningMode::ArchiveAll,
- None => PruningMode::default(),
- Some(s) => PruningMode::keep_blocks(
- s.parse().map_err(|_| input_err("Invalid pruning mode specified"))?
- ),
- };
-
- let role =
- if cli.light {
- service::Roles::LIGHT
- } else if cli.validator || cli.shared_params.dev {
- service::Roles::AUTHORITY
- } else {
- service::Roles::FULL
- };
-
- let exec = cli.execution_strategies;
- config.execution_strategies = ExecutionStrategies {
- 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,
- &base_path,
- spec.id(),
- &mut config.network,
- client_id,
- )?;
-
- fill_transaction_pool_configuration::(
- &mut config,
- cli.pool_config,
- )?;
-
- if let Some(key) = cli.key {
- config.keys.push(key);
- }
-
- if cli.shared_params.dev {
- 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" };
- let ws_interface: &str = if cli.ws_external { "0.0.0.0" } else { "127.0.0.1" };
-
- config.rpc_http = Some(
- parse_address(&format!("{}:{}", rpc_interface, 9933), cli.rpc_port)?
- );
- config.rpc_ws = Some(
- parse_address(&format!("{}:{}", ws_interface, 9944), cli.ws_port)?
- );
-
- // Override telemetry
- if cli.no_telemetry {
- 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)
+ let spec = load_spec(&cli.shared_params, spec_factory)?;
+ let mut config = service::Configuration::default_with_spec(spec.clone());
+
+ config.impl_name = impl_name;
+ config.impl_commit = version.commit;
+ config.impl_version = version.version;
+
+ 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!(input_err(format!(
+ "Invalid node name '{}'. Reason: {}. If unsure, use none.",
+ config.name, msg
+ ))),
+ }
+
+ let base_path = base_path(&cli.shared_params, version);
+
+ config.keystore_path = cli
+ .keystore_path
+ .unwrap_or_else(|| keystore_path(&base_path, config.chain_spec.id()))
+ .to_string_lossy()
+ .into();
+
+ config.database_path = db_path(&base_path, config.chain_spec.id())
+ .to_string_lossy()
+ .into();
+ config.database_cache_size = cli.database_cache_size;
+ config.pruning = match cli.pruning {
+ Some(ref s) if s == "archive" => PruningMode::ArchiveAll,
+ None => PruningMode::default(),
+ Some(s) => PruningMode::keep_blocks(
+ s.parse()
+ .map_err(|_| input_err("Invalid pruning mode specified"))?,
+ ),
+ };
+
+ let role = if cli.light {
+ service::Roles::LIGHT
+ } else if cli.validator || cli.shared_params.dev {
+ service::Roles::AUTHORITY
+ } else {
+ service::Roles::FULL
+ };
+
+ let exec = cli.execution_strategies;
+ config.execution_strategies = ExecutionStrategies {
+ 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,
+ &base_path,
+ spec.id(),
+ &mut config.network,
+ client_id,
+ )?;
+
+ fill_transaction_pool_configuration::(&mut config, cli.pool_config)?;
+
+ if let Some(key) = cli.key {
+ config.keys.push(key);
+ }
+
+ if cli.shared_params.dev {
+ 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"
+ };
+ let ws_interface: &str = if cli.ws_external {
+ "0.0.0.0"
+ } else {
+ "127.0.0.1"
+ };
+
+ config.rpc_http = Some(parse_address(
+ &format!("{}:{}", rpc_interface, 9933),
+ cli.rpc_port,
+ )?);
+ config.rpc_ws = Some(parse_address(
+ &format!("{}:{}", ws_interface, 9944),
+ cli.ws_port,
+ )?);
+
+ // Override telemetry
+ if cli.no_telemetry {
+ 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)
}
fn run_node(
- cli: MergeParameters,
- spec_factory: S,
- exit: E,
- run_service: RS,
- impl_name: &'static str,
- version: &VersionInfo,
+ cli: MergeParameters,
+ spec_factory: S,
+ exit: E,
+ run_service: RS,
+ impl_name: &'static str,
+ version: &VersionInfo,
) -> error::Result<()>
where
- RP: StructOpt + Clone,
- F: ServiceFactory,
- E: IntoExit,
- S: FnOnce(&str) -> Result>>, String>,
- RS: FnOnce(E, RP, FactoryFullConfiguration) -> Result<(), String>,
- {
- let config = create_run_node_config::(cli.left, spec_factory, impl_name, version)?;
+ RP: StructOpt + Clone,
+ F: ServiceFactory,
+ E: IntoExit,
+ S: FnOnce(&str) -> Result>>, String>,
+ RS: FnOnce(E, RP, FactoryFullConfiguration) -> Result<(), String>,
+{
+ let config = create_run_node_config::(cli.left, spec_factory, impl_name, version)?;
- run_service(exit, cli.right, config).map_err(Into::into)
+ run_service(exit, cli.right, config).map_err(Into::into)
}
//
@@ -517,389 +564,407 @@ where
// 9926-9949 Unassigned
fn with_default_boot_node(
- spec: &mut ChainSpec>,
- cli: BuildSpecCmd,
- version: &VersionInfo,
+ spec: &mut ChainSpec>,
+ cli: BuildSpecCmd,
+ version: &VersionInfo,
) -> error::Result<()>
where
- F: ServiceFactory
+ F: ServiceFactory,
{
- if spec.boot_nodes().is_empty() {
- 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),
- P2p(peer_id)
- ];
- spec.add_boot_node(addr)
- }
- Ok(())
-}
-
-fn build_spec(
- cli: BuildSpecCmd,
- spec_factory: S,
- version: &VersionInfo,
-) -> error::Result<()>
+ if spec.boot_nodes().is_empty() {
+ 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), P2p(peer_id)];
+ spec.add_boot_node(addr)
+ }
+ Ok(())
+}
+
+fn build_spec(cli: BuildSpecCmd, spec_factory: S, version: &VersionInfo) -> error::Result<()>
where
- F: ServiceFactory,
- S: FnOnce(&str) -> Result>>, String>,
+ F: ServiceFactory,
+ S: FnOnce(&str) -> Result>>, String>,
{
- info!("Building chain spec");
- 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)?;
+ info!("Building chain spec");
+ 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);
+ print!("{}", json);
- Ok(())
+ Ok(())
}
fn create_config_with_db_path(
- spec_factory: S, cli: &SharedParams, version: &VersionInfo,
+ spec_factory: S,
+ cli: &SharedParams,
+ version: &VersionInfo,
) -> error::Result>
where
- F: ServiceFactory,
- S: FnOnce(&str) -> Result>>, String>,
+ F: ServiceFactory,
+ S: FnOnce(&str) -> Result>>, String>,
{
- let spec = load_spec(cli, spec_factory)?;
- let base_path = base_path(cli, version);
+ let spec = load_spec(cli, spec_factory)?;
+ let base_path = base_path(cli, version);
- let mut config = service::Configuration::default_with_spec(spec.clone());
- config.database_path = db_path(&base_path, spec.id()).to_string_lossy().into();
+ let mut config = service::Configuration::default_with_spec(spec.clone());
+ config.database_path = db_path(&base_path, spec.id()).to_string_lossy().into();
- Ok(config)
+ Ok(config)
}
fn export_blocks(
- cli: ExportBlocksCmd,
- spec_factory: S,
- exit: E,
- version: &VersionInfo,
+ cli: ExportBlocksCmd,
+ spec_factory: S,
+ exit: E,
+ version: &VersionInfo,
) -> error::Result<()>
where
- F: ServiceFactory,
- E: IntoExit,
- S: FnOnce(&str) -> Result>>, String>,
+ F: ServiceFactory,
+ E: IntoExit,
+ S: FnOnce(&str) -> Result>>, String>,
{
- let config = create_config_with_db_path::(spec_factory, &cli.shared_params, version)?;
+ let config = create_config_with_db_path::(spec_factory, &cli.shared_params, version)?;
- info!("DB path: {}", config.database_path);
- let from = cli.from.unwrap_or(1);
- let to = cli.to;
- let json = cli.json;
+ info!("DB path: {}", config.database_path);
+ let from = cli.from.unwrap_or(1);
+ let to = cli.to;
+ let json = cli.json;
- let file: Box = match cli.output {
- Some(filename) => Box::new(File::create(filename)?),
- None => Box::new(stdout()),
- };
+ let file: Box = match cli.output {
+ Some(filename) => Box::new(File::create(filename)?),
+ None => Box::new(stdout()),
+ };
- service::chain_ops::export_blocks::(
- config, exit.into_exit(), file, As::sa(from), to.map(As::sa), json
- ).map_err(Into::into)
+ service::chain_ops::export_blocks::(
+ config,
+ exit.into_exit(),
+ file,
+ As::sa(from),
+ to.map(As::sa),
+ json,
+ )
+ .map_err(Into::into)
}
fn import_blocks(
- cli: ImportBlocksCmd,
- spec_factory: S,
- exit: E,
- version: &VersionInfo,
+ cli: ImportBlocksCmd,
+ spec_factory: S,
+ exit: E,
+ version: &VersionInfo,
) -> error::Result<()>
where
- F: ServiceFactory,
- E: IntoExit,
- S: FnOnce(&str) -> Result>>, String>,
+ F: ServiceFactory,
+ E: IntoExit,
+ S: FnOnce(&str) -> Result>>, String>,
{
- let config = create_config_with_db_path::(spec_factory, &cli.shared_params, version)?;
+ let config = create_config_with_db_path::(spec_factory, &cli.shared_params, version)?;
- let file: Box = match cli.input {
- Some(filename) => Box::new(File::open(filename)?),
- None => Box::new(stdin()),
- };
+ let file: Box = match cli.input {
+ Some(filename) => Box::new(File::open(filename)?),
+ None => Box::new(stdin()),
+ };
- service::chain_ops::import_blocks::(config, exit.into_exit(), file).map_err(Into::into)
+ service::chain_ops::import_blocks::(config, exit.into_exit(), file).map_err(Into::into)
}
-fn revert_chain(
- cli: RevertCmd,
- spec_factory: S,
- version: &VersionInfo,
-) -> error::Result<()>
+fn revert_chain(cli: RevertCmd, spec_factory: S, version: &VersionInfo) -> error::Result<()>
where
- F: ServiceFactory,
- S: FnOnce(&str) -> Result>>, String>,
+ F: ServiceFactory,
+ S: FnOnce(&str) -> Result>>, String>,
{
- let config = create_config_with_db_path::(spec_factory, &cli.shared_params, version)?;
- let blocks = cli.num;
- Ok(service::chain_ops::revert_chain::(config, As::sa(blocks))?)
+ let config = create_config_with_db_path::(spec_factory, &cli.shared_params, version)?;
+ let blocks = cli.num;
+ Ok(service::chain_ops::revert_chain::(
+ config,
+ As::sa(blocks),
+ )?)
}
fn purge_chain(
- cli: PurgeChainCmd,
- spec_factory: S,
- version: &VersionInfo,
+ cli: PurgeChainCmd,
+ spec_factory: S,
+ version: &VersionInfo,
) -> error::Result<()>
where
- F: ServiceFactory,
- S: FnOnce(&str) -> Result