Phase 1 of repo reorg (#719)

* Remove unneeded script

* Rename Substrate Demo -> Substrate

* Rename demo -> node

* Build wasm from last rename.

* Merge ed25519 into substrate-primitives

* Minor tweak

* Rename substrate -> core

* Move substrate-runtime-support to core/runtime/support

* Rename/move substrate-runtime-version

* Move codec up a level

* Rename substrate-codec -> parity-codec

* Move environmental up a level

* Move pwasm-* up to top, ready for removal

* Remove requirement of s-r-support from s-r-primitives

* Move core/runtime/primitives into core/runtime-primitives

* Remove s-r-support dep from s-r-version

* Remove dep of s-r-support from bft

* Remove dep of s-r-support from node/consensus

* Sever all other core deps from s-r-support

* Forgot the no_std directive

* Rename non-SRML modules to sr-* to avoid match clashes

* Move runtime/* to srml/*

* Rename substrate-runtime-* -> srml-*

* Move srml to top-level

substrate/core/cli/src/cli.yml

@@ -0,0 +1,229 @@
+name: {name}
+author: {author}
+about: {description}
+args:
+  - log:
+      short: l
+      long: log
+      value_name: LOG_PATTERN
+      help: Sets a custom logging filter
+      takes_value: true
+  - base-path:
+      long: base-path
+      short: d
+      value_name: PATH
+      help: Specify custom base path
+      takes_value: true
+  - keystore-path:
+      long: keystore-path
+      value_name: PATH
+      help: Specify custom keystore path
+      takes_value: true
+  - key:
+      long: key
+      value_name: STRING
+      help: Specify additional key seed
+      takes_value: true
+  - node-key:
+      long: node-key
+      value_name: KEY
+      help: Specify node secret key (64-character hex string)
+      takes_value: true
+  - validator:
+      long: validator
+      help: Enable validator mode
+      takes_value: false
+  - light:
+      long: light
+      help: Run in light client mode
+      takes_value: false
+  - dev:
+      long: dev
+      help: Run in development mode; implies --chain=dev --validator --key Alice
+      takes_value: false
+  - listen-addr:
+      long: listen-addr
+      value_name: LISTEN_ADDR
+      help: Listen on this multiaddress
+      takes_value: true
+      multiple: true
+  - port:
+      long: port
+      value_name: PORT
+      help: Specify p2p protocol TCP port. Only used if --listen-addr is not specified.
+      takes_value: true
+  - rpc-external:
+      long: rpc-external
+      help: Listen to all RPC interfaces (default is local)
+      takes_value: false
+  - ws-external:
+      long: ws-external
+      help: Listen to all Websocket interfaces (default is local)
+      takes_value: false
+  - rpc-port:
+      long: rpc-port
+      value_name: PORT
+      help: Specify HTTP RPC server TCP port
+      takes_value: true
+  - ws-port:
+      long: ws-port
+      value_name: PORT
+      help: Specify WebSockets RPC server TCP port
+      takes_value: true
+  - bootnodes:
+      long: bootnodes
+      value_name: URL
+      help: Specify a list of bootnodes
+      takes_value: true
+      multiple: true
+  - reserved-nodes:
+      long: reserved-nodes
+      value_name: URL
+      help: Specify a list of reserved node addresses
+      takes_value: true
+      multiple: true
+  - min-peers:
+      long: min-peers
+      value_name: MIN_PEERS
+      help: Specify the minimum number of peers
+      takes_value: true
+  - max-peers:
+      long: max-peers
+      value_name: MAX_PEERS
+      help: Specify the maximum number of peers
+      takes_value: true
+  - chain:
+      long: chain
+      value_name: CHAIN_SPEC
+      help: Specify the chain specification (one of krummelanke, dev, local or staging)
+      takes_value: true
+  - pruning:
+      long: pruning
+      value_name: PRUNING_MODE
+      help: Specify the pruning mode, a number of blocks to keep or "archive". Default is 256.
+      takes_value: true
+  - name:
+      long: name
+      value_name: NAME
+      help: The human-readable name for this node, as reported to the telemetry server, if enabled
+      takes_value: true
+  - telemetry:
+      short: t
+      long: telemetry
+      help: Should connect to the Polkadot telemetry server (telemetry is off by default on local chains)
+      takes_value: false
+  - no-telemetry:
+      long: no-telemetry
+      help: Should not connect to the Polkadot telemetry server (telemetry is on by default on global chains)
+      takes_value: false
+  - telemetry-url:
+      long: telemetry-url
+      value_name: TELEMETRY_URL
+      help: The URL of the telemetry server. Implies --telemetry
+      takes_value: true
+  - execution:
+      long: execution
+      value_name: STRATEGY
+      help: The means of execution used when calling into the runtime. Can be either wasm, native or both.
+subcommands:
+  - build-spec:
+      about: Build a spec.json file, outputing to stdout
+      args:
+        - raw:
+            long: raw
+            help: Force raw genesis storage output.
+            takes_value: false
+        - chain:
+            long: chain
+            value_name: CHAIN_SPEC
+            help: Specify the chain specification (one of krummelanke, dev, local or staging)
+            takes_value: true
+  - export-blocks:
+      about: Export blocks to a file
+      args:
+          - OUTPUT:
+              index: 1
+              help: Output file name or stdout if unspecified.
+              required: false
+          - chain:
+              long: chain
+              value_name: CHAIN_SPEC
+              help: Specify the chain specification.
+              takes_value: true
+          - base-path:
+              long: base-path
+              short: d
+              value_name: PATH
+              help: Specify custom base path.
+              takes_value: true
+          - from:
+              long: from
+              value_name: BLOCK
+              help: Specify starting block number. 1 by default.
+              takes_value: true
+          - to:
+              long: to
+              value_name: BLOCK
+              help: Specify last block number. Best block by default.
+              takes_value: true
+          - json:
+              long: json
+              help: Use JSON output rather than binary.
+              takes_value: false
+  - import-blocks:
+      about: Import blocks from file.
+      args:
+          - INPUT:
+              index: 1
+              help: Input file or stdin if unspecified.
+              required: false
+          - chain:
+              long: chain
+              value_name: CHAIN_SPEC
+              help: Specify the chain specification.
+              takes_value: true
+          - base-path:
+              long: base-path
+              short: d
+              value_name: PATH
+              help: Specify custom base path.
+              takes_value: true
+          - execution:
+              long: execution
+              value_name: STRATEGY
+              help: The means of execution used when calling into the runtime. Can be either wasm, native or both.
+          - max-heap-pages:
+              long: max-heap-pages
+              value_name: COUNT
+              help: The maximum number of 64KB pages to ever allocate for Wasm execution. Don't alter this unless you know what you're doing.
+  - revert:
+      about: Revert chain to the previous state
+      args:
+          - NUM:
+              index: 1
+              help: Number of blocks to revert. Default is 256.
+          - chain:
+              long: chain
+              value_name: CHAIN_SPEC
+              help: Specify the chain specification.
+              takes_value: true
+          - base-path:
+              long: base-path
+              short: d
+              value_name: PATH
+              help: Specify custom base path.
+              takes_value: true
+  - purge-chain:
+      about: Remove the whole chain data.
+      args:
+          - chain:
+              long: chain
+              value_name: CHAIN_SPEC
+              help: Specify the chain specification.
+              takes_value: true
+          - base-path:
+              long: base-path
+              short: d
+              value_name: PATH
+              help: Specify custom base path.
+              takes_value: true

substrate/core/cli/src/error.rs

@@ -0,0 +1,37 @@
+// Copyright 2017 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/>.
+
+//! Initialization errors.
+
+use client;
+
+error_chain! {
+	foreign_links {
+		Io(::std::io::Error) #[doc="IO error"];
+		Cli(::clap::Error) #[doc="CLI error"];
+		Service(::service::Error) #[doc="Substrate service error"];
+	}
+	links {
+		Client(client::error::Error, client::error::ErrorKind) #[doc="Client error"];
+	}
+	errors {
+		/// Input error.
+		Input(m: String) {
+			description("Invalid input"),
+			display("{}", m),
+		}
+	}
+}

substrate/core/cli/src/informant.rs

@@ -0,0 +1,124 @@
+// Copyright 2017 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/>.
+
+//! Console informant. Prints sync progress and block events. Runs on the calling thread.
+
+use ansi_term::Colour;
+use std::time::{Duration, Instant};
+use futures::{Future, Stream};
+use service::{Service, Components};
+use tokio::runtime::TaskExecutor;
+use tokio::timer::Interval;
+use sysinfo::{get_current_pid, ProcessExt, System, SystemExt};
+use network::{SyncState, SyncProvider};
+use client::BlockchainEvents;
+use runtime_primitives::traits::{Header, As};
+
+const TIMER_INTERVAL_MS: u64 = 5000;
+
+/// Spawn informant on the event loop
+pub fn start<C>(service: &Service<C>, exit: ::exit_future::Exit, handle: TaskExecutor)
+	where
+		C: Components,
+{
+	let interval = Interval::new(Instant::now(), Duration::from_millis(TIMER_INTERVAL_MS));
+
+	let network = service.network();
+	let client = service.client();
+	let txpool = service.extrinsic_pool();
+	let mut last_number = None;
+
+	let mut sys = System::new();
+	let self_pid = get_current_pid();
+
+	let display_notifications = interval.map_err(|e| debug!("Timer error: {:?}", e)).for_each(move |_| {
+		let sync_status = network.status();
+
+		if let Ok(best_block) = client.best_block_header() {
+			let hash = best_block.hash();
+			let num_peers = sync_status.num_peers;
+			let best_number: u64 = best_block.number().as_();
+			let speed = move || speed(best_number, last_number);
+			let (status, target) = match (sync_status.sync.state, sync_status.sync.best_seen_block) {
+				(SyncState::Idle, _) => ("Idle".into(), "".into()),
+				(SyncState::Downloading, None) => (format!("Syncing{}", speed()), "".into()),
+				(SyncState::Downloading, Some(n)) => (format!("Syncing{}", speed()), format!(", target=#{}", n)),
+			};
+			last_number = Some(best_number);
+			let txpool_status = txpool.light_status();
+			info!(
+				target: "substrate",
+				"{}{} ({} peers), best: #{} ({})",
+				Colour::White.bold().paint(&status),
+				target,
+				Colour::White.bold().paint(format!("{}", sync_status.num_peers)),
+				Colour::White.paint(format!("{}", best_number)),
+				hash
+			);
+
+			// get cpu usage and memory usage of this process
+			let (cpu_usage, memory) = if sys.refresh_process(self_pid) {
+				let proc = sys.get_process(self_pid).expect("Above refresh_process succeeds, this should be Some(), qed");
+				(proc.cpu_usage(), proc.memory())
+			} else { (0.0, 0) };
+
+			telemetry!(
+				"system.interval";
+				"status" => format!("{}{}", status, target),
+				"peers" => num_peers,
+				"height" => best_number,
+				"best" => ?hash,
+				"txcount" => txpool_status.transaction_count,
+				"cpu" => cpu_usage,
+				"memory" => memory
+			);
+		} else {
+			warn!("Error getting best block information");
+		}
+
+		Ok(())
+	});
+
+	let client = service.client();
+	let display_block_import = client.import_notification_stream().for_each(|n| {
+		info!(target: "substrate", "Imported #{} ({})", n.header.number(), n.hash);
+		Ok(())
+	});
+
+	let txpool = service.extrinsic_pool();
+	let display_txpool_import = txpool.import_notification_stream().for_each(move |_| {
+		let status = txpool.light_status();
+		telemetry!("txpool.import"; "mem_usage" => status.mem_usage, "count" => status.transaction_count, "sender" => status.senders);
+		Ok(())
+	});
+
+	let informant_work = display_notifications.join3(display_block_import, display_txpool_import);
+	handle.spawn(exit.until(informant_work).map(|_| ()));
+}
+
+fn speed(best_number: u64, last_number: Option<u64>) -> String {
+	let speed = match last_number {
+		Some(num) => (best_number.saturating_sub(num) * 10_000 / TIMER_INTERVAL_MS) as f64,
+		None => 0.0
+	};
+
+	if speed < 1.0 {
+		"".into()
+	} else {
+		format!(" {:4.1} bps", speed / 10.0)
+	}
+}
+

substrate/core/cli/src/lib.rs

@@ -0,0 +1,571 @@
+// Copyright 2017 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/>.
+
+// tag::description[]
+//! Substrate CLI library.
+// end::description[]
+
+#![warn(missing_docs)]
+#![warn(unused_extern_crates)]
+
+extern crate app_dirs;
+extern crate env_logger;
+extern crate atty;
+extern crate ansi_term;
+extern crate regex;
+extern crate time;
+extern crate fdlimit;
+extern crate futures;
+extern crate tokio;
+extern crate names;
+extern crate backtrace;
+extern crate sysinfo;
+
+extern crate substrate_client as client;
+extern crate substrate_network as network;
+extern crate substrate_network_libp2p as network_libp2p;
+extern crate sr_primitives as runtime_primitives;
+extern crate substrate_service as service;
+#[macro_use]
+extern crate slog;	// needed until we can reexport `slog_info` from `substrate_telemetry`
+#[macro_use]
+extern crate substrate_telemetry;
+extern crate exit_future;
+
+#[macro_use]
+extern crate lazy_static;
+extern crate clap;
+#[macro_use]
+extern crate error_chain;
+#[macro_use]
+extern crate log;
+
+pub mod error;
+pub mod informant;
+mod panic_hook;
+
+use network_libp2p::AddrComponent;
+use runtime_primitives::traits::As;
+use service::{
+	ServiceFactory, FactoryFullConfiguration, RuntimeGenesis,
+	FactoryGenesis, PruningMode, ChainSpec,
+};
+use network::NonReservedPeerMode;
+
+use std::io::{Write, Read, stdin, stdout};
+use std::iter;
+use std::fs;
+use std::fs::File;
+use std::net::{Ipv4Addr, SocketAddr};
+use std::path::{Path, PathBuf};
+use names::{Generator, Name};
+use regex::Regex;
+
+use futures::Future;
+
+/// Executable version. Used to pass version information from the root crate.
+pub struct VersionInfo {
+	/// Implementation version.
+	pub version: &'static str,
+	/// SCM Commit hash.
+	pub commit: &'static str,
+	/// Executable file name.
+	pub executable_name: &'static str,
+	/// Executable file description.
+	pub description: &'static str,
+	/// Executable file author.
+	pub author: &'static str,
+}
+
+/// CLI Action
+pub enum Action<F: ServiceFactory, E: IntoExit> {
+	/// Substrate handled the command. No need to do anything.
+	ExecutedInternally,
+	/// Service mode requested. Caller should start the service.
+	RunService((FactoryFullConfiguration<F>, E)),
+}
+
+/// Something that can be converted into an exit signal.
+pub trait IntoExit {
+	/// Exit signal type.
+	type Exit: Future<Item=(),Error=()> + Send + 'static;
+	/// Convert into exit signal.
+	fn into_exit(self) -> Self::Exit;
+}
+
+fn load_spec<F, G>(matches: &clap::ArgMatches, factory: F) -> Result<ChainSpec<G>, String>
+	where G: RuntimeGenesis, F: FnOnce(&str) -> Result<Option<ChainSpec<G>>, String>,
+{
+	let chain_key = matches.value_of("chain").unwrap_or_else(|| if matches.is_present("dev") { "dev" } else { "" });
+	let spec = match factory(chain_key)? {
+		Some(spec) => spec,
+		None => ChainSpec::from_json_file(PathBuf::from(chain_key))?
+	};
+	Ok(spec)
+}
+
+fn base_path(matches: &clap::ArgMatches) -> PathBuf {
+	matches.value_of("base-path")
+		.map(|x| Path::new(x).to_owned())
+		.unwrap_or_else(default_base_path)
+}
+
+/// Check whether a node name is considered as valid
+fn is_node_name_valid(_name: &str) -> Result<(), &str> {
+	const MAX_NODE_NAME_LENGTH: usize = 32;
+	let name = _name.to_string();
+	if name.chars().count() >= MAX_NODE_NAME_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(())
+}
+
+/// Parse command line arguments and execute commands or return service configuration.
+///
+/// IANA unassigned port ranges that we could use:
+/// 6717-6766		Unassigned
+/// 8504-8553		Unassigned
+/// 9556-9591		Unassigned
+/// 9803-9874		Unassigned
+/// 9926-9949		Unassigned
+pub fn prepare_execution<F, I, T, E, S>(
+	args: I,
+	exit: E,
+	version: VersionInfo,
+	spec_factory: S,
+	impl_name: &'static str,
+) -> error::Result<Action<F, E>>
+where
+	I: IntoIterator<Item = T>,
+	T: Into<std::ffi::OsString> + Clone,
+	E: IntoExit,
+	F: ServiceFactory,
+	S: FnOnce(&str) -> Result<Option<ChainSpec<FactoryGenesis<F>>>, String>,
+{
+	panic_hook::set();
+
+	let full_version = service::config::full_version_from_strs(
+		version.version,
+		version.commit
+	);
+	let yaml = format!(include_str!("./cli.yml"),
+		name = version.executable_name,
+		description = version.description,
+		author = version.author,
+	);
+	let yaml = &clap::YamlLoader::load_from_str(&yaml).expect("Invalid yml file")[0];
+	let matches = match clap::App::from_yaml(yaml)
+		.version(&(full_version + "\n")[..])
+		.get_matches_from_safe(args) {
+			Ok(m) => m,
+			Err(e) => e.exit(),
+	};
+
+	// TODO [ToDr] Split parameters parsing from actual execution.
+	let log_pattern = matches.value_of("log").unwrap_or("");
+	init_logger(log_pattern);
+	fdlimit::raise_fd_limit();
+
+	if let Some(matches) = matches.subcommand_matches("build-spec") {
+		let spec = load_spec(&matches, spec_factory)?;
+		build_spec::<F>(matches, spec)?;
+		return Ok(Action::ExecutedInternally);
+	}
+
+	if let Some(matches) = matches.subcommand_matches("export-blocks") {
+		let spec = load_spec(&matches, spec_factory)?;
+		export_blocks::<F, _>(matches, spec, exit.into_exit())?;
+		return Ok(Action::ExecutedInternally);
+	}
+
+	if let Some(matches) = matches.subcommand_matches("import-blocks") {
+		let spec = load_spec(&matches, spec_factory)?;
+		import_blocks::<F, _>(matches, spec, exit.into_exit())?;
+		return Ok(Action::ExecutedInternally);
+	}
+
+	if let Some(matches) = matches.subcommand_matches("revert") {
+		let spec = load_spec(&matches, spec_factory)?;
+		revert_chain::<F>(matches, spec)?;
+		return Ok(Action::ExecutedInternally);
+	}
+
+	if let Some(matches) = matches.subcommand_matches("purge-chain") {
+		let spec = load_spec(&matches, spec_factory)?;
+		purge_chain::<F>(matches, spec)?;
+		return Ok(Action::ExecutedInternally);
+	}
+
+	let spec = load_spec(&matches, spec_factory)?;
+	let mut config = service::Configuration::default_with_spec(spec);
+
+	config.impl_name = impl_name;
+	config.impl_commit = version.commit;
+	config.impl_version = version.version;
+
+	config.name = match matches.value_of("name") {
+		None => Generator::with_naming(Name::Numbered).next().unwrap(),
+		Some(name) => name.into(),
+	};
+	match is_node_name_valid(&config.name) {
+		Ok(_) => (),
+		Err(msg) => return Err(error::ErrorKind::Input(
+			format!("Invalid node name '{}'. Reason: {}. If unsure, use none.", config.name, msg)).into())
+	}
+
+	let base_path = base_path(&matches);
+
+	config.keystore_path = matches.value_of("keystore")
+		.map(|x| Path::new(x).to_owned())
+		.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.pruning = match matches.value_of("pruning") {
+		Some("archive") => PruningMode::ArchiveAll,
+		None => PruningMode::default(),
+		Some(s) => PruningMode::keep_blocks(s.parse()
+			.map_err(|_| error::ErrorKind::Input("Invalid pruning mode specified".to_owned()))?),
+	};
+
+	let role =
+		if matches.is_present("light") {
+			config.execution_strategy = service::ExecutionStrategy::NativeWhenPossible;
+			service::Roles::LIGHT
+		} else if matches.is_present("validator") || matches.is_present("dev") {
+			config.execution_strategy = service::ExecutionStrategy::Both;
+			service::Roles::AUTHORITY
+		} else {
+			config.execution_strategy = service::ExecutionStrategy::NativeWhenPossible;
+			service::Roles::FULL
+		};
+
+	if let Some(s) = matches.value_of("execution") {
+		config.execution_strategy = match s {
+			"both" => service::ExecutionStrategy::Both,
+			"native" => service::ExecutionStrategy::NativeWhenPossible,
+			"wasm" => service::ExecutionStrategy::AlwaysWasm,
+			_ => return Err(error::ErrorKind::Input("Invalid execution mode specified".to_owned()).into()),
+		};
+	}
+
+	config.roles = role;
+	{
+		config.network.boot_nodes.extend(matches
+			.values_of("bootnodes")
+			.map_or(Default::default(), |v| v.map(|n| n.to_owned()).collect::<Vec<_>>()));
+		config.network.config_path = Some(network_path(&base_path, config.chain_spec.id()).to_string_lossy().into());
+		config.network.net_config_path = config.network.config_path.clone();
+		config.network.reserved_nodes.extend(matches
+			 .values_of("reserved-nodes")
+			 .map_or(Default::default(), |v| v.map(|n| n.to_owned()).collect::<Vec<_>>()));
+		if !config.network.reserved_nodes.is_empty() {
+			config.network.non_reserved_mode = NonReservedPeerMode::Deny;
+		}
+
+		config.network.listen_addresses = Vec::new();
+		for addr in matches.values_of("listen-addr").unwrap_or_default() {
+			let addr = addr.parse().map_err(|_| "Invalid listen multiaddress")?;
+			config.network.listen_addresses.push(addr);
+		}
+		if config.network.listen_addresses.is_empty() {
+			let port = match matches.value_of("port") {
+				Some(port) => port.parse().map_err(|_| "Invalid p2p port value specified.")?,
+				None => 30333,
+			};
+			config.network.listen_addresses = vec![
+				iter::once(AddrComponent::IP4(Ipv4Addr::new(0, 0, 0, 0)))
+					.chain(iter::once(AddrComponent::TCP(port)))
+					.collect()
+			];
+		}
+
+		config.network.public_addresses = Vec::new();
+
+		config.network.client_version = config.client_id();
+		config.network.use_secret = match matches.value_of("node-key").map(|s| s.parse()) {
+			Some(Ok(secret)) => Some(secret),
+			Some(Err(err)) => return Err(format!("Error parsing node key: {}", err).into()),
+			None => None,
+		};
+
+		let min_peers = match matches.value_of("min-peers") {
+			Some(min_peers) => min_peers.parse().map_err(|_| "Invalid min-peers value specified.")?,
+			None => 25,
+		};
+		let max_peers = match matches.value_of("max-peers") {
+			Some(max_peers) => max_peers.parse().map_err(|_| "Invalid max-peers value specified.")?,
+			None => 50,
+		};
+		if min_peers > max_peers {
+			return Err(error::ErrorKind::Input("Min-peers mustn't be larger than max-peers.".to_owned()).into());
+		}
+		config.network.min_peers = min_peers;
+		config.network.max_peers = max_peers;
+	}
+
+	config.keys = matches.values_of("key").unwrap_or_default().map(str::to_owned).collect();
+	if matches.is_present("dev") {
+		config.keys.push("Alice".into());
+	}
+
+	let rpc_interface: &str = if matches.is_present("rpc-external") { "0.0.0.0" } else { "127.0.0.1" };
+	let ws_interface: &str = if matches.is_present("ws-external") { "0.0.0.0" } else { "127.0.0.1" };
+
+	config.rpc_http = Some(parse_address(&format!("{}:{}", rpc_interface, 9933), "rpc-port", &matches)?);
+	config.rpc_ws = Some(parse_address(&format!("{}:{}", ws_interface, 9944), "ws-port", &matches)?);
+
+	// Override telemetry
+	if matches.is_present("no-telemetry") {
+		config.telemetry_url = None;
+	} else if let Some(url) = matches.value_of("telemetry-url") {
+		config.telemetry_url = Some(url.to_owned());
+	}
+
+	Ok(Action::RunService((config, exit)))
+}
+
+fn build_spec<F>(matches: &clap::ArgMatches, spec: ChainSpec<FactoryGenesis<F>>) -> error::Result<()>
+	where F: ServiceFactory,
+{
+	info!("Building chain spec");
+	let raw = matches.is_present("raw");
+	let json = service::chain_ops::build_spec::<FactoryGenesis<F>>(spec, raw)?;
+	print!("{}", json);
+	Ok(())
+}
+
+fn export_blocks<F, E>(matches: &clap::ArgMatches, spec: ChainSpec<FactoryGenesis<F>>, exit: E) -> error::Result<()>
+	where F: ServiceFactory, E: Future<Item=(),Error=()> + Send + 'static,
+{
+	let base_path = base_path(matches);
+	let mut config = service::Configuration::default_with_spec(spec);
+	config.database_path = db_path(&base_path, config.chain_spec.id()).to_string_lossy().into();
+	info!("DB path: {}", config.database_path);
+	let from: u64 = match matches.value_of("from") {
+		Some(v) => v.parse().map_err(|_| "Invalid --from argument")?,
+		None => 1,
+	};
+
+	let to: Option<u64> = match matches.value_of("to") {
+		Some(v) => Some(v.parse().map_err(|_| "Invalid --to argument")?),
+		None => None,
+	};
+	let json = matches.is_present("json");
+
+	let file: Box<Write> = match matches.value_of("OUTPUT") {
+		Some(filename) => Box::new(File::create(filename)?),
+		None => Box::new(stdout()),
+	};
+
+	Ok(service::chain_ops::export_blocks::<F, _, _>(config, exit, file, As::sa(from), to.map(As::sa), json)?)
+}
+
+fn import_blocks<F, E>(matches: &clap::ArgMatches, spec: ChainSpec<FactoryGenesis<F>>, exit: E) -> error::Result<()>
+	where F: ServiceFactory, E: Future<Item=(),Error=()> + Send + 'static,
+{
+	let base_path = base_path(matches);
+	let mut config = service::Configuration::default_with_spec(spec);
+	config.database_path = db_path(&base_path, config.chain_spec.id()).to_string_lossy().into();
+
+	if let Some(s) = matches.value_of("execution") {
+		config.execution_strategy = match s {
+			"both" => service::ExecutionStrategy::Both,
+			"native" => service::ExecutionStrategy::NativeWhenPossible,
+			"wasm" => service::ExecutionStrategy::AlwaysWasm,
+			_ => return Err(error::ErrorKind::Input("Invalid execution mode specified".to_owned()).into()),
+		};
+	}
+
+	let file: Box<Read> = match matches.value_of("INPUT") {
+		Some(filename) => Box::new(File::open(filename)?),
+		None => Box::new(stdin()),
+	};
+
+	Ok(service::chain_ops::import_blocks::<F, _, _>(config, exit, file)?)
+}
+
+fn revert_chain<F>(matches: &clap::ArgMatches, spec: ChainSpec<FactoryGenesis<F>>) -> error::Result<()>
+	where F: ServiceFactory,
+{
+	let base_path = base_path(matches);
+	let mut config = service::Configuration::default_with_spec(spec);
+	config.database_path = db_path(&base_path, config.chain_spec.id()).to_string_lossy().into();
+
+	let blocks = match matches.value_of("NUM") {
+		Some(v) => v.parse().map_err(|_| "Invalid block count specified")?,
+		None => 256,
+	};
+
+	Ok(service::chain_ops::revert_chain::<F>(config, As::sa(blocks))?)
+}
+
+fn purge_chain<F>(matches: &clap::ArgMatches, spec: ChainSpec<FactoryGenesis<F>>) -> error::Result<()>
+	where F: ServiceFactory,
+{
+	let base_path = base_path(matches);
+	let database_path = db_path(&base_path, spec.id());
+
+	print!("Are you sure to remove {:?}? (y/n)", &database_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(&database_path)?;
+			println!("{:?} removed.", &database_path);
+		},
+		_ => println!("Aborted"),
+	}
+
+	Ok(())
+}
+
+fn parse_address(default: &str, port_param: &str, matches: &clap::ArgMatches) -> Result<SocketAddr, String> {
+	let mut address: SocketAddr = default.parse().ok().ok_or_else(|| format!("Invalid address specified for --{}.", port_param))?;
+	if let Some(port) = matches.value_of(port_param) {
+		let port: u16 = port.parse().ok().ok_or_else(|| format!("Invalid port for --{} specified.", port_param))?;
+		address.set_port(port);
+	}
+
+	Ok(address)
+}
+
+fn keystore_path(base_path: &Path, chain_id: &str) -> PathBuf {
+	let mut path = base_path.to_owned();
+	path.push("chains");
+	path.push(chain_id);
+	path.push("keystore");
+	path
+}
+
+fn db_path(base_path: &Path, chain_id: &str) -> PathBuf {
+	let mut path = base_path.to_owned();
+	path.push("chains");
+	path.push(chain_id);
+	path.push("db");
+	path
+}
+
+fn network_path(base_path: &Path, chain_id: &str) -> PathBuf {
+	let mut path = base_path.to_owned();
+	path.push("chains");
+	path.push(chain_id);
+	path.push("network");
+	path
+}
+
+fn default_base_path() -> PathBuf {
+	use app_dirs::{AppInfo, AppDataType};
+
+	let app_info = AppInfo {
+		name: "Polkadot",
+		author: "Parity Technologies",
+	};
+
+	app_dirs::get_app_root(
+		AppDataType::UserData,
+		&app_info,
+	).expect("app directories exist on all supported platforms; qed")
+}
+
+fn init_logger(pattern: &str) {
+	use ansi_term::Colour;
+
+	let mut builder = env_logger::LogBuilder::new();
+	// Disable info logging by default for some modules:
+	builder.filter(Some("ws"), log::LogLevelFilter::Warn);
+	builder.filter(Some("hyper"), log::LogLevelFilter::Warn);
+	// Enable info for others.
+	builder.filter(None, log::LogLevelFilter::Info);
+
+	if let Ok(lvl) = std::env::var("RUST_LOG") {
+		builder.parse(&lvl);
+	}
+
+	builder.parse(pattern);
+	let isatty = atty::is(atty::Stream::Stderr);
+	let enable_color = isatty;
+
+	let format = move |record: &log::LogRecord| {
+		let timestamp = time::strftime("%Y-%m-%d %H:%M:%S", &time::now()).expect("Error formatting log timestamp");
+
+		let mut output = if log::max_log_level() <= log::LogLevelFilter::Info {
+			format!("{} {}", Colour::Black.bold().paint(timestamp), record.args())
+		} else {
+			let name = ::std::thread::current().name().map_or_else(Default::default, |x| format!("{}", Colour::Blue.bold().paint(x)));
+			format!("{} {} {} {}  {}", Colour::Black.bold().paint(timestamp), name, record.level(), record.target(), record.args())
+		};
+
+		if !enable_color {
+			output = kill_color(output.as_ref());
+		}
+
+		if !isatty && record.level() <= log::LogLevel::Info && atty::is(atty::Stream::Stdout) {
+			// duplicate INFO/WARN output to console
+			println!("{}", output);
+		}
+		output
+	};
+	builder.format(format);
+
+	builder.init().expect("Logger initialized only once.");
+}
+
+fn kill_color(s: &str) -> String {
+	lazy_static! {
+		static ref RE: Regex = Regex::new("\x1b\\[[^m]+m").expect("Error initializing color regex");
+	}
+	RE.replace_all(s, "").to_string()
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[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());
+	}
+}

substrate/core/cli/src/panic_hook.rs

@@ -0,0 +1,69 @@
+// Copyright 2017 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/>.
+
+//! Custom panic hook with bug report link
+
+use backtrace::Backtrace;
+use std::io::{self, Write};
+use std::panic::{self, PanicInfo};
+use std::thread;
+
+/// Set the panic hook
+pub fn set() {
+	panic::set_hook(Box::new(panic_hook));
+}
+
+static ABOUT_PANIC: &str = "
+This is a bug. Please report it at:
+
+    https://github.com/paritytech/polkadot/issues/new
+";
+
+fn panic_hook(info: &PanicInfo) {
+	let location = info.location();
+	let file = location.as_ref().map(|l| l.file()).unwrap_or("<unknown>");
+	let line = location.as_ref().map(|l| l.line()).unwrap_or(0);
+
+	let msg = match info.payload().downcast_ref::<&'static str>() {
+		Some(s) => *s,
+		None => match info.payload().downcast_ref::<String>() {
+			Some(s) => &s[..],
+			None => "Box<Any>",
+		}
+	};
+
+	let thread = thread::current();
+	let name = thread.name().unwrap_or("<unnamed>");
+
+	let backtrace = Backtrace::new();
+
+	let mut stderr = io::stderr();
+
+	let _ = writeln!(stderr, "");
+	let _ = writeln!(stderr, "====================");
+	let _ = writeln!(stderr, "");
+	let _ = writeln!(stderr, "{:?}", backtrace);
+	let _ = writeln!(stderr, "");
+	let _ = writeln!(
+		stderr,
+		"Thread '{}' panicked at '{}', {}:{}",
+		name, msg, file, line
+	);
+
+	let _ = writeln!(stderr, "{}", ABOUT_PANIC);
+	::std::process::exit(1);
+}
+