Add tests & Service's Configuration has optional fields that shouldn't be optional (#4842)

Related to #4776 
Related to https://github.com/paritytech/polkadot/pull/832

To summarize the changes:
1. I did not manage to validate with types the service's Configuration. But I did reduce the possibility of errors by moving all the "fill" functions to their respective structopts
2. I split params.rs to multiple modules: one module params for just CLI parameters and one module commands for CLI subcommands (and RunCmd). Every command and params are in their own file so things are grouped better together and easier to remove
3. I removed the run and run_subcommand helpers as they are not helping much anymore. Running a command is always a set of 3 commands: 1. init 2. update config 3. run. This still allow the user to change the config before arguments get parsed or right after.
4. I added tests for all subcommands.
5. [deleted]

Overall the aim is to improve the situation with the Configuration and the optional parameters, add tests, make the API more consistent and simpler.

substrate/client/cli/src/commands/build_spec_cmd.rs

@@ -0,0 +1,104 @@
+// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+use structopt::StructOpt;
+use log::info;
+use sc_network::config::build_multiaddr;
+use sc_service::{Configuration, ChainSpecExtension, RuntimeGenesis, ChainSpec};
+
+use crate::error;
+use crate::VersionInfo;
+use crate::params::SharedParams;
+use crate::params::NodeKeyParams;
+
+/// The `build-spec` command used to build a specification.
+#[derive(Debug, StructOpt, Clone)]
+pub struct BuildSpecCmd {
+	/// Force raw genesis storage output.
+	#[structopt(long = "raw")]
+	pub raw: bool,
+
+	/// Disable adding the default bootnode to the specification.
+	///
+	/// By default the `/ip4/127.0.0.1/tcp/30333/p2p/NODE_PEER_ID` bootnode is added to the
+	/// specification when no bootnode exists.
+	#[structopt(long = "disable-default-bootnode")]
+	pub disable_default_bootnode: bool,
+
+	#[allow(missing_docs)]
+	#[structopt(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[structopt(flatten)]
+	pub node_key_params: NodeKeyParams,
+}
+
+impl BuildSpecCmd {
+	/// Run the build-spec command
+	pub fn run<G, E>(
+		self,
+		config: Configuration<G, E>,
+	) -> error::Result<()>
+	where
+		G: RuntimeGenesis,
+		E: ChainSpecExtension,
+	{
+		info!("Building chain spec");
+		let mut spec = config.expect_chain_spec().clone();
+		let raw_output = self.raw;
+
+		if spec.boot_nodes().is_empty() && !self.disable_default_bootnode {
+			let keys = config.network.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)
+		}
+
+		let json = sc_service::chain_ops::build_spec(spec, raw_output)?;
+
+		print!("{}", json);
+
+		Ok(())
+	}
+
+	/// Update and prepare a `Configuration` with command line parameters
+	pub fn update_config<G, E, F>(
+		&self,
+		mut config: &mut Configuration<G, E>,
+		spec_factory: F,
+		version: &VersionInfo,
+	) -> error::Result<()> where
+		G: RuntimeGenesis,
+		E: ChainSpecExtension,
+		F: FnOnce(&str) -> Result<Option<ChainSpec<G, E>>, String>,
+	{
+		self.shared_params.update_config(&mut config, spec_factory, version)?;
+
+		let net_config_path = config
+			.in_chain_config_dir(crate::commands::DEFAULT_NETWORK_CONFIG_PATH)
+			.expect("We provided a base_path");
+
+		self.node_key_params.update_config(&mut config, Some(&net_config_path))?;
+
+		Ok(())
+	}
+}
+

substrate/client/cli/src/commands/check_block_cmd.rs

@@ -0,0 +1,105 @@
+// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::fmt::Debug;
+use std::str::FromStr;
+use structopt::StructOpt;
+use sc_service::{
+	Configuration, ChainSpecExtension, RuntimeGenesis, ServiceBuilderCommand, Roles, ChainSpec,
+};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
+use sp_runtime::generic::BlockId;
+
+use crate::error;
+use crate::VersionInfo;
+use crate::runtime::run_until_exit;
+use crate::params::SharedParams;
+use crate::params::ImportParams;
+
+/// The `check-block` command used to validate blocks.
+#[derive(Debug, StructOpt, Clone)]
+pub struct CheckBlockCmd {
+	/// Block hash or number
+	#[structopt(value_name = "HASH or NUMBER")]
+	pub input: String,
+
+	/// The default number of 64KB pages to ever allocate for Wasm execution.
+	///
+	/// Don't alter this unless you know what you're doing.
+	#[structopt(long = "default-heap-pages", value_name = "COUNT")]
+	pub default_heap_pages: Option<u32>,
+
+	#[allow(missing_docs)]
+	#[structopt(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[structopt(flatten)]
+	pub import_params: ImportParams,
+}
+
+impl CheckBlockCmd {
+	/// Run the check-block command
+	pub fn run<G, E, B, BC, BB>(
+		self,
+		config: Configuration<G, E>,
+		builder: B,
+	) -> error::Result<()>
+	where
+		B: FnOnce(Configuration<G, E>) -> Result<BC, sc_service::error::Error>,
+		G: RuntimeGenesis,
+		E: ChainSpecExtension,
+		BC: ServiceBuilderCommand<Block = BB> + Unpin,
+		BB: sp_runtime::traits::Block + Debug,
+		<<<BB as BlockT>::Header as HeaderT>::Number as std::str::FromStr>::Err: std::fmt::Debug,
+		<BB as BlockT>::Hash: std::str::FromStr,
+	{
+		let input = if self.input.starts_with("0x") { &self.input[2..] } else { &self.input[..] };
+		let block_id = match FromStr::from_str(input) {
+			Ok(hash) => BlockId::hash(hash),
+			Err(_) => match self.input.parse::<u32>() {
+				Ok(n) => BlockId::number((n as u32).into()),
+				Err(_) => return Err(error::Error::Input("Invalid hash or number specified".into())),
+			}
+		};
+
+		let start = std::time::Instant::now();
+		run_until_exit(config, |config| {
+			Ok(builder(config)?.check_block(block_id))
+		})?;
+		println!("Completed in {} ms.", start.elapsed().as_millis());
+
+		Ok(())
+	}
+
+	/// Update and prepare a `Configuration` with command line parameters
+	pub fn update_config<G, E, F>(
+		&self,
+		mut config: &mut Configuration<G, E>,
+		spec_factory: F,
+		version: &VersionInfo,
+	) -> error::Result<()> where
+		G: RuntimeGenesis,
+		E: ChainSpecExtension,
+		F: FnOnce(&str) -> Result<Option<ChainSpec<G, E>>, String>,
+	{
+		self.shared_params.update_config(&mut config, spec_factory, version)?;
+		self.import_params.update_config(&mut config, Roles::FULL, self.shared_params.dev)?;
+		config.use_in_memory_keystore()?;
+
+		Ok(())
+	}
+}

substrate/client/cli/src/commands/export_blocks_cmd.rs

@@ -0,0 +1,113 @@
+// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::io;
+use std::fs;
+use std::path::PathBuf;
+use std::fmt::Debug;
+use log::info;
+use structopt::StructOpt;
+use sc_service::{
+	Configuration, ChainSpecExtension, RuntimeGenesis, ServiceBuilderCommand, ChainSpec,
+	config::DatabaseConfig,
+};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
+
+use crate::error;
+use crate::VersionInfo;
+use crate::runtime::run_until_exit;
+use crate::params::SharedParams;
+use crate::params::BlockNumber;
+
+/// The `export-blocks` command used to export blocks.
+#[derive(Debug, StructOpt, Clone)]
+pub struct ExportBlocksCmd {
+	/// Output file name or stdout if unspecified.
+	#[structopt(parse(from_os_str))]
+	pub output: Option<PathBuf>,
+
+	/// Specify starting block number.
+	///
+	/// Default is 1.
+	#[structopt(long = "from", value_name = "BLOCK")]
+	pub from: Option<BlockNumber>,
+
+	/// Specify last block number.
+	///
+	/// Default is best block.
+	#[structopt(long = "to", value_name = "BLOCK")]
+	pub to: Option<BlockNumber>,
+
+	/// Use JSON output rather than binary.
+	#[structopt(long = "json")]
+	pub json: bool,
+
+	#[allow(missing_docs)]
+	#[structopt(flatten)]
+	pub shared_params: SharedParams,
+}
+
+impl ExportBlocksCmd {
+	/// Run the export-blocks command
+	pub fn run<G, E, B, BC, BB>(
+		self,
+		config: Configuration<G, E>,
+		builder: B,
+	) -> error::Result<()>
+	where
+		B: FnOnce(Configuration<G, E>) -> Result<BC, sc_service::error::Error>,
+		G: RuntimeGenesis,
+		E: ChainSpecExtension,
+		BC: ServiceBuilderCommand<Block = BB> + Unpin,
+		BB: sp_runtime::traits::Block + Debug,
+		<<<BB as BlockT>::Header as HeaderT>::Number as std::str::FromStr>::Err: std::fmt::Debug,
+		<BB as BlockT>::Hash: std::str::FromStr,
+	{
+		if let DatabaseConfig::Path { ref path, .. } = config.expect_database() {
+			info!("DB path: {}", path.display());
+		}
+		let from = self.from.as_ref().and_then(|f| f.parse().ok()).unwrap_or(1);
+		let to = self.to.as_ref().and_then(|t| t.parse().ok());
+
+		let json = self.json;
+
+		let file: Box<dyn io::Write> = match &self.output {
+			Some(filename) => Box::new(fs::File::create(filename)?),
+			None => Box::new(io::stdout()),
+		};
+
+		run_until_exit(config, |config| {
+			Ok(builder(config)?.export_blocks(file, from.into(), to, json))
+		})
+	}
+
+	/// Update and prepare a `Configuration` with command line parameters
+	pub fn update_config<G, E, F>(
+		&self,
+		mut config: &mut Configuration<G, E>,
+		spec_factory: F,
+		version: &VersionInfo,
+	) -> error::Result<()> where
+		G: RuntimeGenesis,
+		E: ChainSpecExtension,
+		F: FnOnce(&str) -> Result<Option<ChainSpec<G, E>>, String>,
+	{
+		self.shared_params.update_config(&mut config, spec_factory, version)?;
+		config.use_in_memory_keystore()?;
+
+		Ok(())
+	}
+}

substrate/client/cli/src/commands/import_blocks_cmd.rs

@@ -0,0 +1,107 @@
+// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::fmt::Debug;
+use std::io::{Read, Seek, self};
+use std::fs;
+use std::path::PathBuf;
+use structopt::StructOpt;
+use sc_service::{
+	Configuration, ChainSpecExtension, RuntimeGenesis, ServiceBuilderCommand, ChainSpec, Roles,
+};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
+
+use crate::error;
+use crate::VersionInfo;
+use crate::runtime::run_until_exit;
+use crate::params::SharedParams;
+use crate::params::ImportParams;
+
+/// The `import-blocks` command used to import blocks.
+#[derive(Debug, StructOpt, Clone)]
+pub struct ImportBlocksCmd {
+	/// Input file or stdin if unspecified.
+	#[structopt(parse(from_os_str))]
+	pub input: Option<PathBuf>,
+
+	/// The default number of 64KB pages to ever allocate for Wasm execution.
+	///
+	/// Don't alter this unless you know what you're doing.
+	#[structopt(long = "default-heap-pages", value_name = "COUNT")]
+	pub default_heap_pages: Option<u32>,
+
+	#[allow(missing_docs)]
+	#[structopt(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[structopt(flatten)]
+	pub import_params: ImportParams,
+}
+
+/// Internal trait used to cast to a dynamic type that implements Read and Seek.
+trait ReadPlusSeek: Read + Seek {}
+
+impl<T: Read + Seek> ReadPlusSeek for T {}
+
+impl ImportBlocksCmd {
+	/// Run the import-blocks command
+	pub fn run<G, E, B, BC, BB>(
+		self,
+		config: Configuration<G, E>,
+		builder: B,
+	) -> error::Result<()>
+	where
+		B: FnOnce(Configuration<G, E>) -> Result<BC, sc_service::error::Error>,
+		G: RuntimeGenesis,
+		E: ChainSpecExtension,
+		BC: ServiceBuilderCommand<Block = BB> + Unpin,
+		BB: sp_runtime::traits::Block + Debug,
+		<<<BB as BlockT>::Header as HeaderT>::Number as std::str::FromStr>::Err: std::fmt::Debug,
+		<BB as BlockT>::Hash: std::str::FromStr,
+	{
+		let file: Box<dyn ReadPlusSeek + Send> = match &self.input {
+			Some(filename) => Box::new(fs::File::open(filename)?),
+			None => {
+				let mut buffer = Vec::new();
+				io::stdin().read_to_end(&mut buffer)?;
+				Box::new(io::Cursor::new(buffer))
+			},
+		};
+
+		run_until_exit(config, |config| {
+			Ok(builder(config)?.import_blocks(file, false))
+		})
+	}
+
+	/// Update and prepare a `Configuration` with command line parameters
+	pub fn update_config<G, E, F>(
+		&self,
+		mut config: &mut Configuration<G, E>,
+		spec_factory: F,
+		version: &VersionInfo,
+	) -> error::Result<()> where
+		G: RuntimeGenesis,
+		E: ChainSpecExtension,
+		F: FnOnce(&str) -> Result<Option<ChainSpec<G, E>>, String>,
+	{
+		self.shared_params.update_config(&mut config, spec_factory, version)?;
+		self.import_params.update_config(&mut config, Roles::FULL, self.shared_params.dev)?;
+		config.use_in_memory_keystore()?;
+
+		Ok(())
+	}
+}

substrate/client/cli/src/commands/mod.rs

@@ -0,0 +1,145 @@
+// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+mod runcmd;
+mod export_blocks_cmd;
+mod build_spec_cmd;
+mod import_blocks_cmd;
+mod check_block_cmd;
+mod revert_cmd;
+mod purge_chain_cmd;
+
+use std::fmt::Debug;
+use structopt::StructOpt;
+
+use sc_service::{
+	Configuration, ChainSpecExtension, RuntimeGenesis, ServiceBuilderCommand, ChainSpec,
+};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
+
+use crate::error;
+use crate::VersionInfo;
+use crate::params::SharedParams;
+
+pub use crate::commands::runcmd::RunCmd;
+pub use crate::commands::export_blocks_cmd::ExportBlocksCmd;
+pub use crate::commands::build_spec_cmd::BuildSpecCmd;
+pub use crate::commands::import_blocks_cmd::ImportBlocksCmd;
+pub use crate::commands::check_block_cmd::CheckBlockCmd;
+pub use crate::commands::revert_cmd::RevertCmd;
+pub use crate::commands::purge_chain_cmd::PurgeChainCmd;
+
+/// default sub directory to store network config
+const DEFAULT_NETWORK_CONFIG_PATH : &'static str = "network";
+
+/// All core commands that are provided by default.
+///
+/// The core commands are split into multiple subcommands and `Run` is the default subcommand. From
+/// the CLI user perspective, it is not visible that `Run` is a subcommand. So, all parameters of
+/// `Run` are exported as main executable parameters.
+#[derive(Debug, Clone, StructOpt)]
+pub enum Subcommand {
+	/// Build a spec.json file, outputing to stdout.
+	BuildSpec(build_spec_cmd::BuildSpecCmd),
+
+	/// Export blocks to a file.
+	ExportBlocks(export_blocks_cmd::ExportBlocksCmd),
+
+	/// Import blocks from file.
+	ImportBlocks(import_blocks_cmd::ImportBlocksCmd),
+
+	/// Validate a single block.
+	CheckBlock(check_block_cmd::CheckBlockCmd),
+
+	/// Revert chain to the previous state.
+	Revert(revert_cmd::RevertCmd),
+
+	/// Remove the whole chain data.
+	PurgeChain(purge_chain_cmd::PurgeChainCmd),
+}
+
+impl Subcommand {
+	/// Get the shared parameters of a `CoreParams` command
+	pub fn get_shared_params(&self) -> &SharedParams {
+		use Subcommand::*;
+
+		match self {
+			BuildSpec(params) => &params.shared_params,
+			ExportBlocks(params) => &params.shared_params,
+			ImportBlocks(params) => &params.shared_params,
+			CheckBlock(params) => &params.shared_params,
+			Revert(params) => &params.shared_params,
+			PurgeChain(params) => &params.shared_params,
+		}
+	}
+
+	/// Run any `CoreParams` command
+	pub fn run<G, E, B, BC, BB>(
+		self,
+		config: Configuration<G, E>,
+		builder: B,
+	) -> error::Result<()>
+	where
+		B: FnOnce(Configuration<G, E>) -> Result<BC, sc_service::error::Error>,
+		G: RuntimeGenesis,
+		E: ChainSpecExtension,
+		BC: ServiceBuilderCommand<Block = BB> + Unpin,
+		BB: sp_runtime::traits::Block + Debug,
+		<<<BB as BlockT>::Header as HeaderT>::Number as std::str::FromStr>::Err: std::fmt::Debug,
+		<BB as BlockT>::Hash: std::str::FromStr,
+	{
+		match self {
+			Subcommand::BuildSpec(cmd) => cmd.run(config),
+			Subcommand::ExportBlocks(cmd) => cmd.run(config, builder),
+			Subcommand::ImportBlocks(cmd) => cmd.run(config, builder),
+			Subcommand::CheckBlock(cmd) => cmd.run(config, builder),
+			Subcommand::PurgeChain(cmd) => cmd.run(config),
+			Subcommand::Revert(cmd) => cmd.run(config, builder),
+		}
+	}
+
+	/// Update and prepare a `Configuration` with command line parameters
+	pub fn update_config<G, E, F>(
+		&self,
+		mut config: &mut Configuration<G, E>,
+		spec_factory: F,
+		version: &VersionInfo,
+	) -> error::Result<()> where
+		G: RuntimeGenesis,
+		E: ChainSpecExtension,
+		F: FnOnce(&str) -> Result<Option<ChainSpec<G, E>>, String>,
+	{
+		match self {
+			Subcommand::BuildSpec(cmd) => cmd.update_config(&mut config, spec_factory, version),
+			Subcommand::ExportBlocks(cmd) => cmd.update_config(&mut config, spec_factory, version),
+			Subcommand::ImportBlocks(cmd) => cmd.update_config(&mut config, spec_factory, version),
+			Subcommand::CheckBlock(cmd) => cmd.update_config(&mut config, spec_factory, version),
+			Subcommand::PurgeChain(cmd) => cmd.update_config(&mut config, spec_factory, version),
+			Subcommand::Revert(cmd) => cmd.update_config(&mut config, spec_factory, version),
+		}
+	}
+
+	/// Initialize substrate. This must be done only once.
+	///
+	/// This method:
+	///
+	/// 1. Set the panic handler
+	/// 2. Raise the FD limit
+	/// 3. Initialize the logger
+	pub fn init(&self, version: &VersionInfo) -> error::Result<()> {
+		self.get_shared_params().init(version)
+	}
+}

substrate/client/cli/src/commands/purge_chain_cmd.rs

@@ -0,0 +1,106 @@
+// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::fmt::Debug;
+use std::io::{Write, self};
+use std::fs;
+use structopt::StructOpt;
+use sc_service::{
+	Configuration, ChainSpecExtension, RuntimeGenesis, ChainSpec,
+	config::{DatabaseConfig},
+};
+
+use crate::error;
+use crate::VersionInfo;
+use crate::params::SharedParams;
+
+/// 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,
+}
+
+impl PurgeChainCmd {
+	/// Run the purge command
+	pub fn run<G, E>(
+		self,
+		config: Configuration<G, E>,
+	) -> error::Result<()>
+	where
+		G: RuntimeGenesis,
+		E: ChainSpecExtension,
+	{
+		let db_path = match config.expect_database() {
+			DatabaseConfig::Path { path, .. } => path,
+			_ => {
+				eprintln!("Cannot purge custom database implementation");
+				return Ok(());
+			}
+		};
+
+		if !self.yes {
+			print!("Are you sure to remove {:?}? [y/N]: ", &db_path);
+			io::stdout().flush().expect("failed to flush stdout");
+
+			let mut input = String::new();
+			io::stdin().read_line(&mut input)?;
+			let input = input.trim();
+
+			match input.chars().nth(0) {
+				Some('y') | Some('Y') => {},
+				_ => {
+					println!("Aborted");
+					return Ok(());
+				},
+			}
+		}
+
+		match fs::remove_dir_all(&db_path) {
+			Ok(_) => {
+				println!("{:?} removed.", &db_path);
+				Ok(())
+			},
+			Err(ref err) if err.kind() == io::ErrorKind::NotFound => {
+				eprintln!("{:?} did not exist.", &db_path);
+				Ok(())
+			},
+			Err(err) => Result::Err(err.into())
+		}
+	}
+
+	/// Update and prepare a `Configuration` with command line parameters
+	pub fn update_config<G, E, F>(
+		&self,
+		mut config: &mut Configuration<G, E>,
+		spec_factory: F,
+		version: &VersionInfo,
+	) -> error::Result<()> where
+		G: RuntimeGenesis,
+		E: ChainSpecExtension,
+		F: FnOnce(&str) -> Result<Option<ChainSpec<G, E>>, String>,
+	{
+		self.shared_params.update_config(&mut config, spec_factory, version)?;
+		config.use_in_memory_keystore()?;
+
+		Ok(())
+	}
+}

substrate/client/cli/src/commands/revert_cmd.rs

@@ -0,0 +1,79 @@
+// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::fmt::Debug;
+use structopt::StructOpt;
+use sc_service::{
+	Configuration, ChainSpecExtension, RuntimeGenesis, ServiceBuilderCommand, ChainSpec,
+};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
+
+use crate::error;
+use crate::VersionInfo;
+use crate::params::BlockNumber;
+use crate::params::SharedParams;
+
+/// The `revert` command used revert the chain to a previous state.
+#[derive(Debug, StructOpt, Clone)]
+pub struct RevertCmd {
+	/// Number of blocks to revert.
+	#[structopt(default_value = "256")]
+	pub num: BlockNumber,
+
+	#[allow(missing_docs)]
+	#[structopt(flatten)]
+	pub shared_params: SharedParams,
+}
+
+impl RevertCmd {
+	/// Run the revert command
+	pub fn run<G, E, B, BC, BB>(
+		self,
+		config: Configuration<G, E>,
+		builder: B,
+	) -> error::Result<()>
+	where
+		B: FnOnce(Configuration<G, E>) -> Result<BC, sc_service::error::Error>,
+		G: RuntimeGenesis,
+		E: ChainSpecExtension,
+		BC: ServiceBuilderCommand<Block = BB> + Unpin,
+		BB: sp_runtime::traits::Block + Debug,
+		<<<BB as BlockT>::Header as HeaderT>::Number as std::str::FromStr>::Err: std::fmt::Debug,
+		<BB as BlockT>::Hash: std::str::FromStr,
+	{
+		let blocks = self.num.parse()?;
+		builder(config)?.revert_chain(blocks)?;
+
+		Ok(())
+	}
+
+	/// Update and prepare a `Configuration` with command line parameters
+	pub fn update_config<G, E, F>(
+		&self,
+		mut config: &mut Configuration<G, E>,
+		spec_factory: F,
+		version: &VersionInfo,
+	) -> error::Result<()> where
+		G: RuntimeGenesis,
+		E: ChainSpecExtension,
+		F: FnOnce(&str) -> Result<Option<ChainSpec<G, E>>, String>,
+	{
+		self.shared_params.update_config(&mut config, spec_factory, version)?;
+		config.use_in_memory_keystore()?;
+
+		Ok(())
+	}
+}

substrate/client/cli/src/commands/runcmd.rs

@@ -0,0 +1,737 @@
+// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::path::PathBuf;
+use std::net::SocketAddr;
+use std::fs;
+use log::info;
+use structopt::{StructOpt, clap::arg_enum};
+use names::{Generator, Name};
+use regex::Regex;
+use chrono::prelude::*;
+use sc_service::{
+	AbstractService, Configuration, ChainSpecExtension, RuntimeGenesis, ChainSpec, Roles,
+	config::KeystoreConfig,
+};
+use sc_telemetry::TelemetryEndpoints;
+
+use crate::VersionInfo;
+use crate::error;
+use crate::params::ImportParams;
+use crate::params::SharedParams;
+use crate::params::NetworkConfigurationParams;
+use crate::params::TransactionPoolParams;
+use crate::runtime::run_service_until_exit;
+
+/// The maximum number of characters for a node name.
+const NODE_NAME_MAX_LENGTH: usize = 32;
+
+/// default sub directory for the key store
+const DEFAULT_KEYSTORE_CONFIG_PATH : &'static str = "keystore";
+
+arg_enum! {
+	/// Whether off-chain workers are enabled.
+	#[allow(missing_docs)]
+	#[derive(Debug, Clone)]
+	pub enum OffchainWorkerEnabled {
+		Always,
+		Never,
+		WhenValidating,
+	}
+}
+
+/// The `run` command used to run a node.
+#[derive(Debug, StructOpt, Clone)]
+pub struct RunCmd {
+	/// Enable validator mode.
+	///
+	/// The node will be started with the authority role and actively
+	/// participate in any consensus task that it can (e.g. depending on
+	/// availability of local keys).
+	#[structopt(
+		long = "validator",
+		conflicts_with_all = &[ "sentry" ]
+	)]
+	pub validator: bool,
+
+	/// Enable sentry mode.
+	///
+	/// The node will be started with the authority role and participate in
+	/// consensus tasks as an "observer", it will never actively participate
+	/// regardless of whether it could (e.g. keys are available locally). This
+	/// mode is useful as a secure proxy for validators (which would run
+	/// detached from the network), since we want this node to participate in
+	/// the full consensus protocols in order to have all needed consensus data
+	/// available to relay to private nodes.
+	#[structopt(
+		long = "sentry",
+		conflicts_with_all = &[ "validator", "light" ]
+	)]
+	pub sentry: bool,
+
+	/// Disable GRANDPA voter when running in validator mode, otherwise disables the GRANDPA observer.
+	#[structopt(long = "no-grandpa")]
+	pub no_grandpa: bool,
+
+	/// Experimental: Run in light client mode.
+	#[structopt(long = "light", conflicts_with = "sentry")]
+	pub light: bool,
+
+	/// Listen to all RPC interfaces.
+	///
+	/// Default is local. Note: not all RPC methods are safe to be exposed publicly. Use a RPC proxy
+	/// server to filter out dangerous methods. More details: https://github.com/paritytech/substrate/wiki/Public-RPC.
+	/// Use `--unsafe-rpc-external` to suppress the warning if you understand the risks.
+	#[structopt(long = "rpc-external")]
+	pub rpc_external: bool,
+
+	/// Listen to all RPC interfaces.
+	///
+	/// Same as `--rpc-external`.
+	#[structopt(long = "unsafe-rpc-external")]
+	pub unsafe_rpc_external: bool,
+
+	/// Listen to all Websocket interfaces.
+	///
+	/// Default is local. Note: not all RPC methods are safe to be exposed publicly. Use a RPC proxy
+	/// server to filter out dangerous methods. More details: https://github.com/paritytech/substrate/wiki/Public-RPC.
+	/// Use `--unsafe-ws-external` to suppress the warning if you understand the risks.
+	#[structopt(long = "ws-external")]
+	pub ws_external: bool,
+
+	/// Listen to all Websocket interfaces.
+	///
+	/// Same as `--ws-external` but doesn't warn you about it.
+	#[structopt(long = "unsafe-ws-external")]
+	pub unsafe_ws_external: bool,
+
+	/// Listen to all Prometheus data source interfaces.
+	///
+	/// Default is local.
+	#[structopt(long = "prometheus-external")]
+	pub prometheus_external: bool,
+
+	/// Specify HTTP RPC server TCP port.
+	#[structopt(long = "rpc-port", value_name = "PORT")]
+	pub rpc_port: Option<u16>,
+
+	/// Specify WebSockets RPC server TCP port.
+	#[structopt(long = "ws-port", value_name = "PORT")]
+	pub ws_port: Option<u16>,
+
+	/// Maximum number of WS RPC server connections.
+	#[structopt(long = "ws-max-connections", value_name = "COUNT")]
+	pub ws_max_connections: Option<usize>,
+
+	/// Specify browser Origins allowed to access the HTTP & WS RPC servers.
+	///
+	/// A comma-separated list of origins (protocol://domain or special `null`
+	/// value). Value of `all` will disable origin validation. Default is to
+	/// allow localhost, https://polkadot.js.org and
+	/// https://substrate-ui.parity.io origins. When running in --dev mode the
+	/// default is to allow all origins.
+	#[structopt(long = "rpc-cors", value_name = "ORIGINS", parse(try_from_str = parse_cors))]
+	pub rpc_cors: Option<Cors>,
+
+	/// Specify Prometheus data source server TCP Port.
+	#[structopt(long = "prometheus-port", value_name = "PORT")]
+	pub prometheus_port: Option<u16>,
+
+	/// Do not expose a Prometheus metric endpoint.
+	///
+	/// Prometheus metric endpoint is enabled by default.
+	#[structopt(long = "no-prometheus")]
+	pub no_prometheus: bool,
+
+	/// The human-readable name for this node.
+	///
+	/// The node name will be reported to the telemetry server, if enabled.
+	#[structopt(long = "name", value_name = "NAME")]
+	pub name: Option<String>,
+
+	/// 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.
+	///
+	/// 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)>,
+
+	/// Should execute offchain workers on every block.
+	///
+	/// By default it's only enabled for nodes that are authoring new blocks.
+	#[structopt(
+		long = "offchain-worker",
+		value_name = "ENABLED",
+		possible_values = &OffchainWorkerEnabled::variants(),
+		case_insensitive = true,
+		default_value = "WhenValidating"
+	)]
+	pub offchain_worker: OffchainWorkerEnabled,
+
+	#[allow(missing_docs)]
+	#[structopt(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[structopt(flatten)]
+	pub import_params: ImportParams,
+
+	#[allow(missing_docs)]
+	#[structopt(flatten)]
+	pub network_config: NetworkConfigurationParams,
+
+	#[allow(missing_docs)]
+	#[structopt(flatten)]
+	pub pool_config: TransactionPoolParams,
+
+	/// Shortcut for `--name Alice --validator` with session keys for `Alice` added to keystore.
+	#[structopt(long, conflicts_with_all = &["bob", "charlie", "dave", "eve", "ferdie", "one", "two"])]
+	pub alice: bool,
+
+	/// Shortcut for `--name Bob --validator` with session keys for `Bob` added to keystore.
+	#[structopt(long, conflicts_with_all = &["alice", "charlie", "dave", "eve", "ferdie", "one", "two"])]
+	pub bob: bool,
+
+	/// Shortcut for `--name Charlie --validator` with session keys for `Charlie` added to keystore.
+	#[structopt(long, conflicts_with_all = &["alice", "bob", "dave", "eve", "ferdie", "one", "two"])]
+	pub charlie: bool,
+
+	/// Shortcut for `--name Dave --validator` with session keys for `Dave` added to keystore.
+	#[structopt(long, conflicts_with_all = &["alice", "bob", "charlie", "eve", "ferdie", "one", "two"])]
+	pub dave: bool,
+
+	/// Shortcut for `--name Eve --validator` with session keys for `Eve` added to keystore.
+	#[structopt(long, conflicts_with_all = &["alice", "bob", "charlie", "dave", "ferdie", "one", "two"])]
+	pub eve: bool,
+
+	/// Shortcut for `--name Ferdie --validator` with session keys for `Ferdie` added to keystore.
+	#[structopt(long, conflicts_with_all = &["alice", "bob", "charlie", "dave", "eve", "one", "two"])]
+	pub ferdie: bool,
+
+	/// Shortcut for `--name One --validator` with session keys for `One` added to keystore.
+	#[structopt(long, conflicts_with_all = &["alice", "bob", "charlie", "dave", "eve", "ferdie", "two"])]
+	pub one: bool,
+
+	/// Shortcut for `--name Two --validator` with session keys for `Two` added to keystore.
+	#[structopt(long, conflicts_with_all = &["alice", "bob", "charlie", "dave", "eve", "ferdie", "one"])]
+	pub two: bool,
+
+	/// Enable authoring even when offline.
+	#[structopt(long = "force-authoring")]
+	pub force_authoring: bool,
+
+	/// Specify custom keystore path.
+	#[structopt(long = "keystore-path", value_name = "PATH", parse(from_os_str))]
+	pub keystore_path: Option<PathBuf>,
+
+	/// Use interactive shell for entering the password used by the keystore.
+	#[structopt(
+		long = "password-interactive",
+		conflicts_with_all = &[ "password", "password-filename" ]
+	)]
+	pub password_interactive: bool,
+
+	/// Password used by the keystore.
+	#[structopt(
+		long = "password",
+		conflicts_with_all = &[ "password-interactive", "password-filename" ]
+	)]
+	pub password: Option<String>,
+
+	/// File that contains the password used by the keystore.
+	#[structopt(
+		long = "password-filename",
+		value_name = "PATH",
+		parse(from_os_str),
+		conflicts_with_all = &[ "password-interactive", "password" ]
+	)]
+	pub password_filename: Option<PathBuf>
+}
+
+impl RunCmd {
+	/// Get the `Sr25519Keyring` matching one of the flag
+	pub fn get_keyring(&self) -> Option<sp_keyring::Sr25519Keyring> {
+		use sp_keyring::Sr25519Keyring::*;
+
+		if self.alice { Some(Alice) }
+		else if self.bob { Some(Bob) }
+		else if self.charlie { Some(Charlie) }
+		else if self.dave { Some(Dave) }
+		else if self.eve { Some(Eve) }
+		else if self.ferdie { Some(Ferdie) }
+		else if self.one { Some(One) }
+		else if self.two { Some(Two) }
+		else { None }
+	}
+
+	/// Update and prepare a `Configuration` with command line parameters of `RunCmd` and `VersionInfo`
+	pub fn update_config<G, E, F>(
+		&self,
+		mut config: &mut Configuration<G, E>,
+		spec_factory: F,
+		version: &VersionInfo,
+	) -> error::Result<()>
+	where
+		G: RuntimeGenesis,
+		E: ChainSpecExtension,
+		F: FnOnce(&str) -> Result<Option<ChainSpec<G, E>>, String>,
+	{
+		self.shared_params.update_config(&mut config, spec_factory, version)?;
+
+		let password = if self.password_interactive {
+			#[cfg(not(target_os = "unknown"))]
+			{
+				Some(input_keystore_password()?.into())
+			}
+			#[cfg(target_os = "unknown")]
+			None
+		} else if let Some(ref file) = self.password_filename {
+			Some(fs::read_to_string(file).map_err(|e| format!("{}", e))?.into())
+		} else if let Some(ref password) = self.password {
+			Some(password.clone().into())
+		} else {
+			None
+		};
+
+		let path = self.keystore_path.clone().or(
+			config.in_chain_config_dir(DEFAULT_KEYSTORE_CONFIG_PATH)
+		);
+
+		config.keystore = KeystoreConfig::Path {
+			path: path.ok_or_else(|| "No `base_path` provided to create keystore path!".to_string())?,
+			password,
+		};
+
+		let keyring = self.get_keyring();
+		let is_dev = self.shared_params.dev;
+		let is_light = self.light;
+		let is_authority = (self.validator || self.sentry || is_dev || keyring.is_some())
+			&& !is_light;
+		let role =
+			if is_light {
+				sc_service::Roles::LIGHT
+			} else if is_authority {
+				sc_service::Roles::AUTHORITY
+			} else {
+				sc_service::Roles::FULL
+			};
+
+		self.import_params.update_config(&mut config, role, is_dev)?;
+
+		config.name = match (self.name.as_ref(), keyring) {
+			(Some(name), _) => name.to_string(),
+			(_, Some(keyring)) => keyring.to_string(),
+			(None, None) => generate_node_name(),
+		};
+		if let Err(msg) = is_node_name_valid(&config.name) {
+			return Err(error::Error::Input(
+				format!("Invalid node name '{}'. Reason: {}. If unsure, use none.",
+					config.name,
+					msg,
+				)
+			));
+		}
+
+		// set sentry mode (i.e. act as an authority but **never** actively participate)
+		config.sentry_mode = self.sentry;
+
+		config.offchain_worker = match (&self.offchain_worker, role) {
+			(OffchainWorkerEnabled::WhenValidating, sc_service::Roles::AUTHORITY) => true,
+			(OffchainWorkerEnabled::Always, _) => true,
+			(OffchainWorkerEnabled::Never, _) => false,
+			(OffchainWorkerEnabled::WhenValidating, _) => false,
+		};
+
+		config.roles = role;
+		config.disable_grandpa = self.no_grandpa;
+
+		let client_id = config.client_id();
+		let network_path = config
+			.in_chain_config_dir(crate::commands::DEFAULT_NETWORK_CONFIG_PATH)
+			.expect("We provided a basepath");
+		self.network_config.update_config(
+			&mut config,
+			network_path,
+			client_id,
+			is_dev,
+		)?;
+
+		self.pool_config.update_config(&mut config)?;
+
+		config.dev_key_seed = keyring
+			.map(|a| format!("//{}", a)).or_else(|| {
+				if is_dev && !is_light {
+					Some("//Alice".into())
+				} else {
+					None
+				}
+			});
+
+		if config.rpc_http.is_none() || self.rpc_port.is_some() {
+			let rpc_interface: &str = interface_str(self.rpc_external, self.unsafe_rpc_external, self.validator)?;
+			config.rpc_http = Some(parse_address(&format!("{}:{}", rpc_interface, 9933), self.rpc_port)?);
+		}
+		if config.rpc_ws.is_none() || self.ws_port.is_some() {
+			let ws_interface: &str = interface_str(self.ws_external, self.unsafe_ws_external, self.validator)?;
+			config.rpc_ws = Some(parse_address(&format!("{}:{}", ws_interface, 9944), self.ws_port)?);
+		}
+
+		config.rpc_ws_max_connections = self.ws_max_connections;
+		config.rpc_cors = self.rpc_cors.clone().unwrap_or_else(|| if is_dev {
+			log::warn!("Running in --dev mode, RPC CORS has been disabled.");
+			Cors::All
+		} else {
+			Cors::List(vec![
+				"http://localhost:*".into(),
+				"http://127.0.0.1:*".into(),
+				"https://localhost:*".into(),
+				"https://127.0.0.1:*".into(),
+				"https://polkadot.js.org".into(),
+				"https://substrate-ui.parity.io".into(),
+			])
+		}).into();
+
+		// Override telemetry
+		if self.no_telemetry {
+			config.telemetry_endpoints = None;
+		} else if !self.telemetry_endpoints.is_empty() {
+			config.telemetry_endpoints = Some(
+				TelemetryEndpoints::new(self.telemetry_endpoints.clone())
+			);
+		}
+
+		// Override prometheus
+		if self.no_prometheus {
+			config.prometheus_port = None;
+		} else if config.prometheus_port.is_none() {
+			let prometheus_interface: &str = if self.prometheus_external { "0.0.0.0" } else { "127.0.0.1" };
+			config.prometheus_port = Some(
+			parse_address(&format!("{}:{}", prometheus_interface, 9615), self.prometheus_port)?);
+		}
+
+		config.tracing_targets = self.import_params.tracing_targets.clone().into();
+		config.tracing_receiver = self.import_params.tracing_receiver.clone().into();
+
+		// Imply forced authoring on --dev
+		config.force_authoring = self.shared_params.dev || self.force_authoring;
+
+		Ok(())
+	}
+
+	/// Run the command that runs the node
+	pub fn run<G, E, FNL, FNF, SL, SF>(
+		self,
+		config: Configuration<G, E>,
+		new_light: FNL,
+		new_full: FNF,
+		version: &VersionInfo,
+	) -> error::Result<()>
+	where
+		G: RuntimeGenesis,
+		E: ChainSpecExtension,
+		FNL: FnOnce(Configuration<G, E>) -> Result<SL, sc_service::error::Error>,
+		FNF: FnOnce(Configuration<G, E>) -> Result<SF, sc_service::error::Error>,
+		SL: AbstractService + Unpin,
+		SF: AbstractService + Unpin,
+	{
+		info!("{}", version.name);
+		info!("  version {}", config.full_version());
+		info!("  by {}, {}-{}", version.author, version.copyright_start_year, Local::today().year());
+		info!("Chain specification: {}", config.expect_chain_spec().name());
+		info!("Node name: {}", config.name);
+		info!("Roles: {}", config.display_role());
+
+		match config.roles {
+			Roles::LIGHT => run_service_until_exit(
+				config,
+				new_light,
+			),
+			_ => run_service_until_exit(
+				config,
+				new_full,
+			),
+		}
+	}
+
+	/// Initialize substrate. This must be done only once.
+	///
+	/// This method:
+	///
+	/// 1. Set the panic handler
+	/// 2. Raise the FD limit
+	/// 3. Initialize the logger
+	pub fn init(&self, version: &VersionInfo) -> error::Result<()> {
+		self.shared_params.init(version)
+	}
+}
+
+/// Check whether a node name is considered as valid
+pub fn is_node_name_valid(_name: &str) -> Result<(), &str> {
+	let name = _name.to_string();
+	if name.chars().count() >= NODE_NAME_MAX_LENGTH {
+		return Err("Node name too long");
+	}
+
+	let invalid_chars = r"[\\.@]";
+	let re = Regex::new(invalid_chars).unwrap();
+	if re.is_match(&name) {
+		return Err("Node name should not contain invalid chars such as '.' and '@'");
+	}
+
+	let invalid_patterns = r"(https?:\\/+)?(www)+";
+	let re = Regex::new(invalid_patterns).unwrap();
+	if re.is_match(&name) {
+		return Err("Node name should not contain urls");
+	}
+
+	Ok(())
+}
+
+#[cfg(not(target_os = "unknown"))]
+fn input_keystore_password() -> Result<String, String> {
+	rpassword::read_password_from_tty(Some("Keystore password: "))
+		.map_err(|e| format!("{:?}", e))
+}
+
+fn generate_node_name() -> String {
+	let result = loop {
+		let node_name = Generator::with_naming(Name::Numbered).next().unwrap();
+		let count = node_name.chars().count();
+
+		if count < NODE_NAME_MAX_LENGTH {
+			break node_name
+		}
+	};
+
+	result
+}
+
+fn parse_address(
+	address: &str,
+	port: Option<u16>,
+) -> Result<SocketAddr, String> {
+	let mut address: SocketAddr = address.parse().map_err(
+		|_| format!("Invalid address: {}", address)
+	)?;
+	if let Some(port) = port {
+		address.set_port(port);
+	}
+
+	Ok(address)
+}
+
+fn interface_str(
+	is_external: bool,
+	is_unsafe_external: bool,
+	is_validator: bool,
+) -> Result<&'static str, error::Error> {
+	if is_external && is_validator {
+		return Err(error::Error::Input("--rpc-external and --ws-external options shouldn't be \
+		used if the node is running as a validator. Use `--unsafe-rpc-external` if you understand \
+		the risks. See the options description for more information.".to_owned()));
+	}
+
+	if is_external || is_unsafe_external {
+		log::warn!("It isn't safe to expose RPC publicly without a proxy server that filters \
+		available set of RPC methods.");
+
+		Ok("0.0.0.0")
+	} else {
+		Ok("127.0.0.1")
+	}
+}
+
+/// Default to verbosity level 0, if none is provided.
+fn parse_telemetry_endpoints(s: &str) -> Result<(String, u8), Box<dyn std::error::Error>> {
+	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))
+		}
+	}
+}
+
+/// CORS setting
+///
+/// The type is introduced to overcome `Option<Option<T>>`
+/// handling of `structopt`.
+#[derive(Clone, Debug)]
+pub enum Cors {
+	/// All hosts allowed
+	All,
+	/// Only hosts on the list are allowed.
+	List(Vec<String>),
+}
+
+impl From<Cors> for Option<Vec<String>> {
+	fn from(cors: Cors) -> Self {
+		match cors {
+			Cors::All => None,
+			Cors::List(list) => Some(list),
+		}
+	}
+}
+
+/// Parse cors origins
+fn parse_cors(s: &str) -> Result<Cors, Box<dyn std::error::Error>> {
+	let mut is_all = false;
+	let mut origins = Vec::new();
+	for part in s.split(',') {
+		match part {
+			"all" | "*" => {
+				is_all = true;
+				break;
+			},
+			other => origins.push(other.to_owned()),
+		}
+	}
+
+	Ok(if is_all { Cors::All } else { Cors::List(origins) })
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sc_service::config::DatabaseConfig;
+
+	const TEST_VERSION_INFO: &'static VersionInfo = &VersionInfo {
+		name: "node-test",
+		version: "0.1.0",
+		commit: "some_commit",
+		executable_name: "node-test",
+		description: "description",
+		author: "author",
+		support_url: "http://example.org",
+		copyright_start_year: 2020,
+	};
+
+	#[test]
+	fn tests_node_name_good() {
+		assert!(is_node_name_valid("short name").is_ok());
+	}
+
+	#[test]
+	fn tests_node_name_bad() {
+		assert!(is_node_name_valid("long names are not very cool for the ui").is_err());
+		assert!(is_node_name_valid("Dots.not.Ok").is_err());
+		assert!(is_node_name_valid("http://visit.me").is_err());
+		assert!(is_node_name_valid("https://visit.me").is_err());
+		assert!(is_node_name_valid("www.visit.me").is_err());
+		assert!(is_node_name_valid("email@domain").is_err());
+	}
+
+	#[test]
+	fn keystore_path_is_generated_correctly() {
+		let chain_spec = ChainSpec::from_genesis(
+			"test",
+			"test-id",
+			|| (),
+			Vec::new(),
+			None,
+			None,
+			None,
+			None::<()>,
+		);
+
+		for keystore_path in vec![None, Some("/keystore/path")] {
+			let args: Vec<&str> = vec![];
+			let mut cli = RunCmd::from_iter(args);
+			cli.keystore_path = keystore_path.clone().map(PathBuf::from);
+
+			let mut config = Configuration::default();
+			config.config_dir = Some(PathBuf::from("/test/path"));
+			config.chain_spec = Some(chain_spec.clone());
+			let chain_spec = chain_spec.clone();
+			cli.update_config(&mut config, move |_| Ok(Some(chain_spec)), TEST_VERSION_INFO).unwrap();
+
+			let expected_path = match keystore_path {
+				Some(path) => PathBuf::from(path),
+				None => PathBuf::from("/test/path/chains/test-id/keystore"),
+			};
+
+			assert_eq!(expected_path, config.keystore.path().unwrap().to_owned());
+		}
+	}
+
+	#[test]
+	fn ensure_load_spec_provide_defaults() {
+		let chain_spec = ChainSpec::from_genesis(
+			"test",
+			"test-id",
+			|| (),
+			vec!["boo".to_string()],
+			Some(TelemetryEndpoints::new(vec![("foo".to_string(), 42)])),
+			None,
+			None,
+			None::<()>,
+		);
+
+		let args: Vec<&str> = vec![];
+		let cli = RunCmd::from_iter(args);
+
+		let mut config = Configuration::from_version(TEST_VERSION_INFO);
+		cli.update_config(&mut config, |_| Ok(Some(chain_spec)), TEST_VERSION_INFO).unwrap();
+
+		assert!(config.chain_spec.is_some());
+		assert!(!config.network.boot_nodes.is_empty());
+		assert!(config.telemetry_endpoints.is_some());
+	}
+
+	#[test]
+	fn ensure_update_config_for_running_node_provides_defaults() {
+		let chain_spec = ChainSpec::from_genesis(
+			"test",
+			"test-id",
+			|| (),
+			vec![],
+			None,
+			None,
+			None,
+			None::<()>,
+		);
+
+		let args: Vec<&str> = vec![];
+		let cli = RunCmd::from_iter(args);
+
+		let mut config = Configuration::from_version(TEST_VERSION_INFO);
+		cli.init(&TEST_VERSION_INFO).unwrap();
+		cli.update_config(&mut config, |_| Ok(Some(chain_spec)), TEST_VERSION_INFO).unwrap();
+
+		assert!(config.config_dir.is_some());
+		assert!(config.database.is_some());
+		if let Some(DatabaseConfig::Path { ref cache_size, .. }) = config.database {
+			assert!(cache_size.is_some());
+		} else {
+			panic!("invalid config.database variant");
+		}
+		assert!(!config.name.is_empty());
+		assert!(config.network.config_path.is_some());
+		assert!(!config.network.listen_addresses.is_empty());
+	}
+}