Add the code for compiling node-cli for WASM-browser (#3974)

* Extract CLI to separate module in node/cli * Make node/cli compile for WASM * More work on node/cli browser * More work on browser node * More work * More work * Purge a bit the CI script * More clean up * Remove substrate-finality-grandpa from the CI Its tests use tokio, which fails to compile. * Address review * Add rocksdb feature to the service * Fix substrate-service WASM CI * Apply suggestions from code review Co-Authored-By: Bastian Köcher <bkchr@users.noreply.github.com> * Don't WASM-compile substrate-service altogether
2026-04-27 20:57:59 +00:00 · 2019-10-31 16:34:12 +01:00
parent c0a1926704
commit 4264613a96
18 changed files with 687 additions and 224 deletions
@@ -0,0 +1,159 @@
+// Copyright 2019 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 crate::ChainSpec;
+use futures::{prelude::*, sync::oneshot, sync::mpsc};
+use libp2p::wasm_ext;
+use log::{debug, info};
+use std::sync::Arc;
+use substrate_service::{AbstractService, RpcSession, Roles as ServiceRoles, Configuration, config::DatabaseConfig};
+use wasm_bindgen::prelude::*;
+
+/// Starts the client.
+///
+/// You must pass a libp2p transport that supports .
+#[wasm_bindgen]
+pub fn start_client(wasm_ext: wasm_ext::ffi::Transport) -> Result<Client, JsValue> {
+	start_inner(wasm_ext)
+		.map_err(|err| JsValue::from_str(&err.to_string()))
+}
+
+fn start_inner(wasm_ext: wasm_ext::ffi::Transport) -> Result<Client, Box<dyn std::error::Error>> {
+	console_error_panic_hook::set_once();
+	console_log::init_with_level(log::Level::Info);
+
+	// Build the configuration to pass to the service.
+	let config = {
+		let wasm_ext = wasm_ext::ExtTransport::new(wasm_ext);
+		let chain_spec = ChainSpec::FlamingFir.load().map_err(|e| format!("{:?}", e))?;
+		let mut config = Configuration::<(), _, _>::default_with_spec(chain_spec);
+		config.network.transport = network::config::TransportConfig::Normal {
+			wasm_external_transport: Some(wasm_ext.clone()),
+			enable_mdns: false,
+		};
+		config.telemetry_external_transport = Some(wasm_ext);
+		config.roles = ServiceRoles::LIGHT;
+		config.name = "Browser node".to_string();
+		config.database = {
+			let db = Arc::new(kvdb_memorydb::create(10));
+			DatabaseConfig::Custom(db)
+		};
+		config
+	};
+
+	info!("Substrate browser node");
+	info!("  version {}", config.full_version());
+	info!("  by Parity Technologies, 2017-2019");
+	info!("Chain specification: {}", config.chain_spec.name());
+	info!("Node name: {}", config.name);
+	info!("Roles: {:?}", config.roles);
+
+	// Create the service. This is the most heavy initialization step.
+	let mut service = crate::service::new_light(config).map_err(|e| format!("{:?}", e))?;
+
+	// We now dispatch a background task responsible for processing the service.
+	//
+	// The main action performed by the code below consists in polling the service with
+	// `service.poll()`.
+	// The rest consists in handling RPC requests.
+	let (rpc_send_tx, mut rpc_send_rx) = mpsc::unbounded::<RpcMessage>();
+	wasm_bindgen_futures::spawn_local(futures::future::poll_fn(move || {
+		loop {
+			match rpc_send_rx.poll() {
+				Ok(Async::Ready(Some(message))) => {
+					let fut = service.rpc_query(&message.session, &message.rpc_json);
+					let _ = message.send_back.send(Box::new(fut));
+				},
+				Ok(Async::NotReady) => break,
+				Err(_) | Ok(Async::Ready(None)) => return Ok(Async::Ready(())),
+			}
+		}
+
+		loop {
+			match service.poll().map_err(|_| ())? {
+				Async::Ready(()) => return Ok(Async::Ready(())),
+				Async::NotReady => break
+			}
+		}
+
+		Ok(Async::NotReady)
+	}));
+
+	Ok(Client {
+		rpc_send_tx,
+	})
+}
+
+/// A running client.
+#[wasm_bindgen]
+pub struct Client {
+	rpc_send_tx: mpsc::UnboundedSender<RpcMessage>,
+}
+
+struct RpcMessage {
+	rpc_json: String,
+	session: RpcSession,
+	send_back: oneshot::Sender<Box<dyn Future<Item = Option<String>, Error = ()>>>,
+}
+
+#[wasm_bindgen]
+impl Client {
+	/// Allows starting an RPC request. Returns a `Promise` containing the result of that request.
+	#[wasm_bindgen(js_name = "rpcSend")]
+	pub fn rpc_send(&mut self, rpc: &str) -> js_sys::Promise {
+		let rpc_session = RpcSession::new(mpsc::channel(1).0);
+		let (tx, rx) = oneshot::channel();
+		let _ = self.rpc_send_tx.unbounded_send(RpcMessage {
+			rpc_json: rpc.to_owned(),
+			session: rpc_session,
+			send_back: tx,
+		});
+		let fut = rx
+			.map_err(|_| ())
+			.and_then(|fut| fut)
+			.map(|s| JsValue::from_str(&s.unwrap_or(String::new())))
+			.map_err(|_| JsValue::NULL);
+		wasm_bindgen_futures::future_to_promise(fut)
+	}
+
+	/// Subscribes to an RPC pubsub endpoint.
+	#[wasm_bindgen(js_name = "rpcSubscribe")]
+	pub fn rpc_subscribe(&mut self, rpc: &str, callback: js_sys::Function) {
+		let (tx, rx) = mpsc::channel(4);
+		let rpc_session = RpcSession::new(tx);
+		let (fut_tx, fut_rx) = oneshot::channel();
+		let _ = self.rpc_send_tx.unbounded_send(RpcMessage {
+			rpc_json: rpc.to_owned(),
+			session: rpc_session.clone(),
+			send_back: fut_tx,
+		});
+		let fut_rx = fut_rx
+			.map_err(|_| ())
+			.and_then(|fut| fut);
+		wasm_bindgen_futures::spawn_local(fut_rx.then(|_| Ok(())));
+		wasm_bindgen_futures::spawn_local(rx.for_each(move |s| {
+			match callback.call1(&callback, &JsValue::from_str(&s)) {
+				Ok(_) => Ok(()),
+				Err(_) => Err(()),
+			}
+		}).then(move |v| {
+			// We need to keep `rpc_session` alive.
+			debug!("RPC subscription has ended");
+			drop(rpc_session);
+			v
+		}));
+	}
+}
@@ -0,0 +1,210 @@
+// Copyright 2018-2019 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/>.
+
+pub use substrate_cli::error;
+use tokio::prelude::Future;
+use tokio::runtime::{Builder as RuntimeBuilder, Runtime};
+pub use substrate_cli::{VersionInfo, IntoExit, NoCustom, SharedParams, ExecutionStrategyParam};
+use substrate_service::{AbstractService, Roles as ServiceRoles, Configuration};
+use log::info;
+use structopt::{StructOpt, clap::App};
+use substrate_cli::{display_role, parse_and_prepare, AugmentClap, GetLogFilter, ParseAndPrepare};
+use crate::{service, ChainSpec, load_spec};
+use crate::factory_impl::FactoryState;
+use transaction_factory::RuntimeAdapter;
+use client::ExecutionStrategies;
+
+/// Custom subcommands.
+#[derive(Clone, Debug, StructOpt)]
+pub enum CustomSubcommands {
+	/// The custom factory subcommmand for manufacturing transactions.
+	#[structopt(
+		name = "factory",
+		about = "Manufactures num transactions from Alice to random accounts. \
+		Only supported for development or local testnet."
+	)]
+	Factory(FactoryCmd),
+}
+
+impl GetLogFilter for CustomSubcommands {
+	fn get_log_filter(&self) -> Option<String> {
+		None
+	}
+}
+
+/// The `factory` command used to generate transactions.
+/// Please note: this command currently only works on an empty database!
+#[derive(Debug, StructOpt, Clone)]
+pub struct FactoryCmd {
+	/// How often to repeat. This option only has an effect in mode `MasterToNToM`.
+	#[structopt(long="rounds", default_value = "1")]
+	pub rounds: u64,
+
+	/// MasterToN: Manufacture `num` transactions from the master account
+	///            to `num` randomly created accounts, one each.
+	///
+	/// MasterTo1: Manufacture `num` transactions from the master account
+	///            to exactly one other randomly created account.
+	///
+	/// MasterToNToM: Manufacture `num` transactions from the master account
+	///               to `num` randomly created accounts.
+	///               From each of these randomly created accounts manufacture
+	///               a transaction to another randomly created account.
+	///               Repeat this `rounds` times. If `rounds` = 1 the behavior
+	///               is the same as `MasterToN`.{n}
+	///               A -> B, A -> C, A -> D, ... x `num`{n}
+	///               B -> E, C -> F, D -> G, ...{n}
+	///               ... x `rounds`
+	///
+	/// These three modes control manufacturing.
+	#[structopt(long="mode", default_value = "MasterToN")]
+	pub mode: transaction_factory::Mode,
+
+	/// Number of transactions to generate. In mode `MasterNToNToM` this is
+	/// the number of transactions per round.
+	#[structopt(long="num", default_value = "8")]
+	pub num: u64,
+
+	#[allow(missing_docs)]
+	#[structopt(flatten)]
+	pub shared_params: SharedParams,
+
+	/// The means of execution used when calling into the runtime while importing blocks.
+	#[structopt(
+		long = "execution",
+		value_name = "STRATEGY",
+		possible_values = &ExecutionStrategyParam::variants(),
+		case_insensitive = true,
+		default_value = "NativeElseWasm"
+	)]
+	pub execution: ExecutionStrategyParam,
+}
+
+impl AugmentClap for FactoryCmd {
+	fn augment_clap<'a, 'b>(app: App<'a, 'b>) -> App<'a, 'b> {
+		FactoryCmd::augment_clap(app)
+	}
+}
+
+/// Parse command line arguments into service configuration.
+pub fn run<I, T, E>(args: I, exit: E, version: substrate_cli::VersionInfo) -> error::Result<()> where
+	I: IntoIterator<Item = T>,
+	T: Into<std::ffi::OsString> + Clone,
+	E: IntoExit,
+{
+	type Config<A, B> = Configuration<(), A, B>;
+
+	match parse_and_prepare::<CustomSubcommands, NoCustom, _>(&version, "substrate-node", args) {
+		ParseAndPrepare::Run(cmd) => cmd.run(load_spec, exit,
+		|exit, _cli_args, _custom_args, config: Config<_, _>| {
+			info!("{}", version.name);
+			info!("  version {}", config.full_version());
+			info!("  by Parity Technologies, 2017-2019");
+			info!("Chain specification: {}", config.chain_spec.name());
+			info!("Node name: {}", config.name);
+			info!("Roles: {}", display_role(&config));
+			let runtime = RuntimeBuilder::new().name_prefix("main-tokio-").build()
+				.map_err(|e| format!("{:?}", e))?;
+			match config.roles {
+				ServiceRoles::LIGHT => run_until_exit(
+					runtime,
+					service::new_light(config)?,
+					exit
+				),
+				_ => run_until_exit(
+					runtime,
+					service::new_full(config)?,
+					exit
+				),
+			}
+		}),
+		ParseAndPrepare::BuildSpec(cmd) => cmd.run(load_spec),
+		ParseAndPrepare::ExportBlocks(cmd) => cmd.run_with_builder(|config: Config<_, _>|
+			Ok(new_full_start!(config).0), load_spec, exit),
+		ParseAndPrepare::ImportBlocks(cmd) => cmd.run_with_builder(|config: Config<_, _>|
+			Ok(new_full_start!(config).0), load_spec, exit),
+		ParseAndPrepare::PurgeChain(cmd) => cmd.run(load_spec),
+		ParseAndPrepare::RevertChain(cmd) => cmd.run_with_builder(|config: Config<_, _>|
+			Ok(new_full_start!(config).0), load_spec),
+		ParseAndPrepare::CustomCommand(CustomSubcommands::Factory(cli_args)) => {
+			let mut config: Config<_, _> = substrate_cli::create_config_with_db_path(
+				load_spec,
+				&cli_args.shared_params,
+				&version,
+			)?;
+			config.execution_strategies = ExecutionStrategies {
+				importing: cli_args.execution.into(),
+				block_construction: cli_args.execution.into(),
+				other: cli_args.execution.into(),
+				..Default::default()
+			};
+
+			match ChainSpec::from(config.chain_spec.id()) {
+				Some(ref c) if c == &ChainSpec::Development || c == &ChainSpec::LocalTestnet => {},
+				_ => panic!("Factory is only supported for development and local testnet."),
+			}
+
+			let factory_state = FactoryState::new(
+				cli_args.mode.clone(),
+				cli_args.num,
+				cli_args.rounds,
+			);
+
+			let service_builder = new_full_start!(config).0;
+			transaction_factory::factory::<FactoryState<_>, _, _, _, _, _>(
+				factory_state,
+				service_builder.client(),
+				service_builder.select_chain()
+					.expect("The select_chain is always initialized by new_full_start!; QED")
+			).map_err(|e| format!("Error in transaction factory: {}", e))?;
+
+			Ok(())
+		}
+	}
+}
+
+fn run_until_exit<T, E>(
+	mut runtime: Runtime,
+	service: T,
+	e: E,
+) -> error::Result<()>
+where
+	T: AbstractService,
+	E: IntoExit,
+{
+	let (exit_send, exit) = exit_future::signal();
+
+	let informant = substrate_cli::informant::build(&service);
+	runtime.executor().spawn(exit.until(informant).map(|_| ()));
+
+	// we eagerly drop the service so that the internal exit future is fired,
+	// but we need to keep holding a reference to the global telemetry guard
+	let _telemetry = service.telemetry();
+
+	let service_res = {
+		let exit = e.into_exit().map_err(|_| error::Error::Other("Exit future failed.".into()));
+		let service = service.map_err(|err| error::Error::Service(err));
+		let select = service.select(exit).map(|_| ()).map_err(|(err, _)| err);
+		runtime.block_on(select)
+	};
+
+	exit_send.fire();
+
+	// TODO [andre]: timeout this future #1318
+	let _ = runtime.shutdown_on_idle().wait();
+
+	service_res
+}
@@ -15,26 +15,35 @@
 // along with Substrate.  If not, see <http://www.gnu.org/licenses/>.

 //! Substrate CLI library.
+//!
+//! This package has two Cargo features:
+//!
+//! - `cli` (default): exposes functions that parse command-line options, then start and run the
+//! node as a CLI application.
+//!
+//! - `browser`: exposes the content of the `browser` module, which consists of exported symbols
+//! that are meant to be passed through the `wasm-bindgen` utility and called from JavaScript.
+//! Despite its name the produced WASM can theoretically also be used from NodeJS, although this
+//! hasn't been tested.

 #![warn(missing_docs)]
 #![warn(unused_extern_crates)]

-pub use cli::error;
 pub mod chain_spec;
+
 #[macro_use]
 mod service;
+#[cfg(feature = "browser")]
+mod browser;
+#[cfg(feature = "cli")]
+mod cli;
+#[cfg(feature = "cli")]
 mod factory_impl;

-use tokio::prelude::Future;
-use tokio::runtime::{Builder as RuntimeBuilder, Runtime};
-pub use cli::{VersionInfo, IntoExit, NoCustom, SharedParams, ExecutionStrategyParam};
-use substrate_service::{AbstractService, Roles as ServiceRoles, Configuration};
-use log::info;
-use structopt::{StructOpt, clap::App};
-use cli::{display_role, parse_and_prepare, AugmentClap, GetLogFilter, ParseAndPrepare};
-use crate::factory_impl::FactoryState;
-use transaction_factory::RuntimeAdapter;
-use client::ExecutionStrategies;
+#[cfg(feature = "browser")]
+pub use browser::*;
+#[cfg(feature = "cli")]
+pub use cli::*;

 /// The chain specification option.
 #[derive(Clone, Debug, PartialEq)]
@@ -49,78 +58,6 @@ pub enum ChainSpec {
 	StagingTestnet,
 }

-/// Custom subcommands.
-#[derive(Clone, Debug, StructOpt)]
-pub enum CustomSubcommands {
-	/// The custom factory subcommmand for manufacturing transactions.
-	#[structopt(
-		name = "factory",
-		about = "Manufactures num transactions from Alice to random accounts. \
-		Only supported for development or local testnet."
-	)]
-	Factory(FactoryCmd),
-}
-
-impl GetLogFilter for CustomSubcommands {
-	fn get_log_filter(&self) -> Option<String> {
-		None
-	}
-}
-
-/// The `factory` command used to generate transactions.
-/// Please note: this command currently only works on an empty database!
-#[derive(Debug, StructOpt, Clone)]
-pub struct FactoryCmd {
-	/// How often to repeat. This option only has an effect in mode `MasterToNToM`.
-	#[structopt(long="rounds", default_value = "1")]
-	pub rounds: u64,
-
-	/// MasterToN: Manufacture `num` transactions from the master account
-	///            to `num` randomly created accounts, one each.
-	///
-	/// MasterTo1: Manufacture `num` transactions from the master account
-	///            to exactly one other randomly created account.
-	///
-	/// MasterToNToM: Manufacture `num` transactions from the master account
-	///               to `num` randomly created accounts.
-	///               From each of these randomly created accounts manufacture
-	///               a transaction to another randomly created account.
-	///               Repeat this `rounds` times. If `rounds` = 1 the behavior
-	///               is the same as `MasterToN`.{n}
-	///               A -> B, A -> C, A -> D, ... x `num`{n}
-	///               B -> E, C -> F, D -> G, ...{n}
-	///               ... x `rounds`
-	///
-	/// These three modes control manufacturing.
-	#[structopt(long="mode", default_value = "MasterToN")]
-	pub mode: transaction_factory::Mode,
-
-	/// Number of transactions to generate. In mode `MasterNToNToM` this is
-	/// the number of transactions per round.
-	#[structopt(long="num", default_value = "8")]
-	pub num: u64,
-
-	#[allow(missing_docs)]
-	#[structopt(flatten)]
-	pub shared_params: SharedParams,
-
-	/// The means of execution used when calling into the runtime while importing blocks.
-	#[structopt(
-		long = "execution",
-		value_name = "STRATEGY",
-		possible_values = &ExecutionStrategyParam::variants(),
-		case_insensitive = true,
-		default_value = "NativeElseWasm"
-	)]
-	pub execution: ExecutionStrategyParam,
-}
-
-impl AugmentClap for FactoryCmd {
-	fn augment_clap<'a, 'b>(app: App<'a, 'b>) -> App<'a, 'b> {
-		FactoryCmd::augment_clap(app)
-	}
-}
-
 /// Get a chain config from a spec setting.
 impl ChainSpec {
 	pub(crate) fn load(self) -> Result<chain_spec::ChainSpec, String> {
@@ -149,113 +86,3 @@ fn load_spec(id: &str) -> Result<Option<chain_spec::ChainSpec>, String> {
 		None => None,
 	})
 }
-
-/// Parse command line arguments into service configuration.
-pub fn run<I, T, E>(args: I, exit: E, version: cli::VersionInfo) -> error::Result<()> where
-	I: IntoIterator<Item = T>,
-	T: Into<std::ffi::OsString> + Clone,
-	E: IntoExit,
-{
-	type Config<A, B> = Configuration<(), A, B>;
-
-	match parse_and_prepare::<CustomSubcommands, NoCustom, _>(&version, "substrate-node", args) {
-		ParseAndPrepare::Run(cmd) => cmd.run(load_spec, exit,
-		|exit, _cli_args, _custom_args, config: Config<_, _>| {
-			info!("{}", version.name);
-			info!("  version {}", config.full_version());
-			info!("  by Parity Technologies, 2017-2019");
-			info!("Chain specification: {}", config.chain_spec.name());
-			info!("Node name: {}", config.name);
-			info!("Roles: {}", display_role(&config));
-			let runtime = RuntimeBuilder::new().name_prefix("main-tokio-").build()
-				.map_err(|e| format!("{:?}", e))?;
-			match config.roles {
-				ServiceRoles::LIGHT => run_until_exit(
-					runtime,
-					service::new_light(config)?,
-					exit
-				),
-				_ => run_until_exit(
-					runtime,
-					service::new_full(config)?,
-					exit
-				),
-			}
-		}),
-		ParseAndPrepare::BuildSpec(cmd) => cmd.run(load_spec),
-		ParseAndPrepare::ExportBlocks(cmd) => cmd.run_with_builder(|config: Config<_, _>|
-			Ok(new_full_start!(config).0), load_spec, exit),
-		ParseAndPrepare::ImportBlocks(cmd) => cmd.run_with_builder(|config: Config<_, _>|
-			Ok(new_full_start!(config).0), load_spec, exit),
-		ParseAndPrepare::PurgeChain(cmd) => cmd.run(load_spec),
-		ParseAndPrepare::RevertChain(cmd) => cmd.run_with_builder(|config: Config<_, _>|
-			Ok(new_full_start!(config).0), load_spec),
-		ParseAndPrepare::CustomCommand(CustomSubcommands::Factory(cli_args)) => {
-			let mut config: Config<_, _> = cli::create_config_with_db_path(
-				load_spec,
-				&cli_args.shared_params,
-				&version,
-			)?;
-			config.execution_strategies = ExecutionStrategies {
-				importing: cli_args.execution.into(),
-				block_construction: cli_args.execution.into(),
-				other: cli_args.execution.into(),
-				..Default::default()
-			};
-
-			match ChainSpec::from(config.chain_spec.id()) {
-				Some(ref c) if c == &ChainSpec::Development || c == &ChainSpec::LocalTestnet => {},
-				_ => panic!("Factory is only supported for development and local testnet."),
-			}
-
-			let factory_state = FactoryState::new(
-				cli_args.mode.clone(),
-				cli_args.num,
-				cli_args.rounds,
-			);
-
-			let service_builder = new_full_start!(config).0;
-			transaction_factory::factory::<FactoryState<_>, _, _, _, _, _>(
-				factory_state,
-				service_builder.client(),
-				service_builder.select_chain()
-					.expect("The select_chain is always initialized by new_full_start!; QED")
-			).map_err(|e| format!("Error in transaction factory: {}", e))?;
-
-			Ok(())
-		}
-	}
-}
-
-fn run_until_exit<T, E>(
-	mut runtime: Runtime,
-	service: T,
-	e: E,
-) -> error::Result<()>
-where
-	T: AbstractService,
-	E: IntoExit,
-{
-	let (exit_send, exit) = exit_future::signal();
-
-	let informant = cli::informant::build(&service);
-	runtime.executor().spawn(exit.until(informant).map(|_| ()));
-
-	// we eagerly drop the service so that the internal exit future is fired,
-	// but we need to keep holding a reference to the global telemetry guard
-	let _telemetry = service.telemetry();
-
-	let service_res = {
-		let exit = e.into_exit().map_err(|_| error::Error::Other("Exit future failed.".into()));
-		let service = service.map_err(|err| error::Error::Service(err));
-		let select = service.select(exit).map(|_| ()).map_err(|(err, _)| err);
-		runtime.block_on(select)
-	};
-
-	exit_send.fire();
-
-	// TODO [andre]: timeout this future #1318
-	let _ = runtime.shutdown_on_idle().wait();
-
-	service_res
-}