RpcHandlers Refactorings

bin/node-template/node/src/command.rs

@@ -47,36 +47,36 @@ impl SubstrateCli for Cli {
 		2017
 	}
 
-	fn load_spec(&self, id: &str) -> Result<Box<dyn sc_service::ChainSpec>, String> {
-		Ok(match id {
-			"dev" => Box::new(chain_spec::development_config()?),
-			"" | "local" => Box::new(chain_spec::local_testnet_config()?),
-			path => Box::new(chain_spec::ChainSpec::from_json_file(
-				std::path::PathBuf::from(path),
-			)?),
-		})
-	}
-
 	fn native_runtime_version(_: &Box<dyn ChainSpec>) -> &'static RuntimeVersion {
 		&node_template_runtime::VERSION
 	}
 }
 
+fn spec_factory(id: String) -> Result<Box<dyn ChainSpec>, String> {
+	Ok(match &*id {
+		"dev" => Box::new(chain_spec::development_config()?),
+		"" | "local" => Box::new(chain_spec::local_testnet_config()?),
+		path => Box::new(chain_spec::ChainSpec::from_json_file(
+			std::path::PathBuf::from(path),
+		)?),
+	})
+}
+
 /// Parse and run command line arguments
 pub fn run() -> sc_cli::Result<()> {
 	let cli = Cli::from_args();
 
 	match &cli.subcommand {
 		Some(subcommand) => {
-			let runner = cli.create_runner(subcommand)?;
+			let runner = cli.create_runner(subcommand, spec_factory)?;
 			runner.run_subcommand(subcommand, |config| {
 				let PartialComponents { client, backend, task_manager, import_queue, .. }
 					= new_partial(&config)?;
 				Ok((client, backend, import_queue, task_manager))
 			})
 		}
 		None => {
-			let runner = cli.create_runner(&cli.run)?;
+			let runner = cli.create_runner(&cli.run, spec_factory)?;
 			runner.run_node_until_exit(|config| match config.role {
 				Role::Light => service::new_light(config),
 				_ => service::new_full(config),

bin/node-template/node/src/service.rs

@@ -81,7 +81,7 @@ pub fn new_full(config: Configuration) -> Result<TaskManager, ServiceError> {
 	} = new_partial(&config)?;
 
 	let finality_proof_provider =
-		GrandpaFinalityProofProvider::new_for_service(backend.clone(), client.clone());
+		GrandpaFinalityProofProvider::new_for_service(backend.clone(),client.clone());
 
 	let (network, network_status_sinks, system_rpc_tx, network_starter) =
 		sc_service::build_network(sc_service::BuildNetworkParams {

bin/node/cli/src/command.rs

@@ -48,43 +48,43 @@ impl SubstrateCli for Cli {
 		2017
 	}
 
-	fn load_spec(&self, id: &str) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {
-		Ok(match id {
-			"dev" => Box::new(chain_spec::development_config()),
-			"local" => Box::new(chain_spec::local_testnet_config()),
-			"" | "fir" | "flaming-fir" => Box::new(chain_spec::flaming_fir_config()?),
-			"staging" => Box::new(chain_spec::staging_testnet_config()),
-			path => Box::new(chain_spec::ChainSpec::from_json_file(
-				std::path::PathBuf::from(path),
-			)?),
-		})
-	}
-
 	fn native_runtime_version(_: &Box<dyn ChainSpec>) -> &'static RuntimeVersion {
 		&node_runtime::VERSION
 	}
 }
 
+fn spec_factory(id: String) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {
+	Ok(match &*id {
+		"dev" => Box::new(chain_spec::development_config()),
+		"local" => Box::new(chain_spec::local_testnet_config()),
+		"" | "fir" | "flaming-fir" => Box::new(chain_spec::flaming_fir_config()?),
+		"staging" => Box::new(chain_spec::staging_testnet_config()),
+		path => Box::new(chain_spec::ChainSpec::from_json_file(
+			std::path::PathBuf::from(path),
+		)?),
+	})
+}
+
 /// Parse command line arguments into service configuration.
 pub fn run() -> Result<()> {
 	let cli = Cli::from_args();
 
 	match &cli.subcommand {
 		None => {
-			let runner = cli.create_runner(&cli.run)?;
+			let runner = cli.create_runner(&cli.run, spec_factory)?;
 			runner.run_node_until_exit(|config| match config.role {
 				Role::Light => service::new_light(config),
 				_ => service::new_full(config),
 			})
 		}
 		Some(Subcommand::Inspect(cmd)) => {
-			let runner = cli.create_runner(cmd)?;
+			let runner = cli.create_runner(cmd, spec_factory)?;
 
 			runner.sync_run(|config| cmd.run::<Block, RuntimeApi, Executor>(config))
 		}
 		Some(Subcommand::Benchmark(cmd)) => {
 			if cfg!(feature = "runtime-benchmarks") {
-				let runner = cli.create_runner(cmd)?;
+				let runner = cli.create_runner(cmd, spec_factory)?;
 
 				runner.sync_run(|config| cmd.run::<Block, Executor>(config))
 			} else {
@@ -94,7 +94,7 @@ pub fn run() -> Result<()> {
 			}
 		}
 		Some(Subcommand::Base(subcommand)) => {
-			let runner = cli.create_runner(subcommand)?;
+			let runner = cli.create_runner(subcommand, spec_factory)?;
 			runner.run_subcommand(subcommand, |config| {
 				let PartialComponents { client, backend, task_manager, import_queue, ..}
 					= new_partial(&config)?;

bin/node/cli/src/service.rs

@@ -335,7 +335,7 @@ pub fn new_full(config: Configuration)
 }
 
 pub fn new_light_base(config: Configuration) -> Result<(
-	TaskManager, Arc<RpcHandlers>, Arc<LightClient>,
+	TaskManager, RpcHandlers, Arc<LightClient>,
 	Arc<NetworkService<Block, <Block as BlockT>::Hash>>,
 	Arc<sc_transaction_pool::LightPool<Block, LightClient, sc_network::config::OnDemand<Block>>>
 ), ServiceError> {

client/cli/src/config.rs

@@ -403,14 +403,18 @@ pub trait CliConfiguration: Sized {
 	}
 
 	/// Create a Configuration object from the current object
-	fn create_configuration<C: SubstrateCli>(
+	fn create_configuration<C, F>(
 		&self,
-		cli: &C,
+		factory: F,
 		task_executor: TaskExecutor,
-	) -> Result<Configuration> {
+	) -> Result<Configuration>
+		where
+			C: SubstrateCli,
+			F: ChainSpecFactory,
+	{
 		let is_dev = self.is_dev()?;
 		let chain_id = self.chain_id(is_dev)?;
-		let chain_spec = cli.load_spec(chain_id.as_str())?;
+		let chain_spec = factory.load_spec(chain_id)?;
 		let base_path = self
 			.base_path()?
 			.unwrap_or_else(|| BasePath::from_project("", "", &C::executable_name()));
@@ -507,6 +511,22 @@ pub trait CliConfiguration: Sized {
 	}
 }
 
+/// Chain spec factory, allows for creating different chain specs, given different
+/// chain_id's.
+pub trait ChainSpecFactory {
+	/// produces a chain spec given a valid chain_id.
+	fn load_spec(&self, id: String) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String>;
+}
+
+impl<F> ChainSpecFactory for F
+	where
+		F: Fn(String) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String>
+{
+	fn load_spec(&self, id: String) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {
+		(self)(id)
+	}
+}
+
 /// Generate a valid random name for the node
 pub fn generate_node_name() -> String {
 	loop {

client/cli/src/lib.rs

@@ -88,9 +88,6 @@ pub trait SubstrateCli: Sized {
 	/// Copyright starting year (x-current year)
 	fn copyright_start_year() -> i32;
 
-	/// Chain spec factory
-	fn load_spec(&self, id: &str) -> std::result::Result<Box<dyn ChainSpec>, String>;
-
 	/// Helper function used to parse the command line arguments. This is the equivalent of
 	/// `structopt`'s `from_iter()` except that it takes a `VersionInfo` argument to provide the name of
 	/// the application, author, "about" and version. It will also set `AppSettings::GlobalVersion`.
@@ -209,19 +206,28 @@ pub trait SubstrateCli: Sized {
 	}
 
 	/// Only create a Configuration for the command provided in argument
-	fn create_configuration<T: CliConfiguration>(
+	fn create_configuration<T, F>(
 		&self,
 		command: &T,
+		factory: F,
 		task_executor: TaskExecutor,
-	) -> error::Result<Configuration> {
-		command.create_configuration(self, task_executor)
+	) -> Result<Configuration>
+		where
+			T: CliConfiguration,
+			F: ChainSpecFactory,
+	{
+		command.create_configuration::<Self, F>(factory, task_executor)
 	}
 
 	/// Create a runner for the command provided in argument. This will create a Configuration and
 	/// a tokio runtime
-	fn create_runner<T: CliConfiguration>(&self, command: &T) -> error::Result<Runner<Self>> {
+	fn create_runner<C, F>(&self, command: &C, factory: F) -> error::Result<Runner<Self>>
+		where
+			C: CliConfiguration,
+			F: ChainSpecFactory,
+	{
 		command.init::<Self>()?;
-		Runner::new(self, command)
+		Runner::new::<C, F>(command, factory)
 	}
 
 	/// Native runtime version.

client/cli/src/runner.rs

@@ -16,7 +16,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-use crate::CliConfiguration;
+use crate::{CliConfiguration, ChainSpecFactory};
 use crate::Result;
 use crate::Subcommand;
 use crate::SubstrateCli;
@@ -122,7 +122,11 @@ pub struct Runner<C: SubstrateCli> {
 
 impl<C: SubstrateCli> Runner<C> {
 	/// Create a new runtime with the command provided in argument
-	pub fn new<T: CliConfiguration>(cli: &C, command: &T) -> Result<Runner<C>> {
+	pub fn new<T, F>(command: &T, factory: F) -> Result<Runner<C>>
+		where
+			T: CliConfiguration,
+			F: ChainSpecFactory,
+	{
 		let tokio_runtime = build_runtime()?;
 		let runtime_handle = tokio_runtime.handle().clone();
 
@@ -136,7 +140,7 @@ impl<C: SubstrateCli> Runner<C> {
 		};
 
 		Ok(Runner {
-			config: command.create_configuration(cli, task_executor.into())?,
+			config: command.create_configuration::<C, F>(factory, task_executor.into())?,
 			tokio_runtime,
 			phantom: PhantomData,
 		})

client/consensus/manual-seal/src/rpc.rs

@@ -105,7 +105,7 @@ impl<Hash> ManualSeal<Hash> {
 	}
 }
 
-impl<Hash: Send + 'static> ManualSealApi<Hash> for ManualSeal<Hash> {
+impl<Hash: std::fmt::Debug + Send + 'static> ManualSealApi<Hash> for ManualSeal<Hash> {
 	fn create_block(
 		&self,
 		create_empty: bool,
@@ -122,7 +122,8 @@ impl<Hash: Send + 'static> ManualSealApi<Hash> for ManualSeal<Hash> {
 				sender: Some(sender),
 			};
 			sink.send(command).await?;
-			receiver.await?
+			let res = receiver.await?;
+			res
 		}.boxed();
 
 		Box::new(future.map_err(Error::from).compat())

client/service/Cargo.toml

@@ -26,7 +26,8 @@ test-helpers = []
 derive_more = "0.99.2"
 futures01 = { package = "futures", version = "0.1.29" }
 futures = { version = "0.3.4", features = ["compat"] }
-jsonrpc-pubsub = "14.2.0"
+jsonrpc-pubsub = "14.2"
+jsonrpc-core = "14.2"
 rand = "0.7.3"
 parking_lot = "0.10.0"
 lazy_static = "1.4.0"

client/service/src/builder.rs

@@ -442,7 +442,7 @@ pub fn build_offchain_workers<TBl, TBackend, TCl>(
 /// Spawn the tasks that are required to run a node.
 pub fn spawn_tasks<TBl, TBackend, TExPool, TRpc, TCl>(
 	params: SpawnTasksParams<TBl, TCl, TExPool, TRpc, TBackend>,
-) -> Result<Arc<RpcHandlers>, Error>
+) -> Result<RpcHandlers, Error>
 	where
 		TCl: ProvideRuntimeApi<TBl> + HeaderMetadata<TBl, Error=sp_blockchain::Error> + Chain<TBl> +
 		BlockBackend<TBl> + BlockIdTo<TBl, Error=sp_blockchain::Error> + ProofProvider<TBl> +
@@ -540,7 +540,7 @@ pub fn spawn_tasks<TBl, TBackend, TExPool, TRpc, TCl>(
 	);
 	let rpc = start_rpc_servers(&config, gen_handler)?;
 	// This is used internally, so don't restrict access to unsafe RPC
-	let rpc_handlers = Arc::new(RpcHandlers(gen_handler(sc_rpc::DenyUnsafe::No)));
+	let rpc_handlers = RpcHandlers(Arc::new(gen_handler(sc_rpc::DenyUnsafe::No).into()));
 
 	// Telemetry
 	let telemetry = config.telemetry_endpoints.clone().and_then(|endpoints| {

client/service/src/lib.rs

@@ -96,7 +96,8 @@ impl<T: MallocSizeOf> MallocSizeOfWasm for T {}
 impl<T> MallocSizeOfWasm for T {}
 
 /// RPC handlers that can perform RPC queries.
-pub struct RpcHandlers(sc_rpc_server::RpcHandler<sc_rpc::Metadata>);
+#[derive(Clone)]
+pub struct RpcHandlers(Arc<jsonrpc_core::MetaIoHandler<sc_rpc::Metadata>>);
 
 impl RpcHandlers {
 	/// Starts an RPC query.
@@ -115,8 +116,14 @@ impl RpcHandlers {
 			.map(|res| res.expect("this should never fail"))
 			.boxed()
 	}
+
+	/// Provides access to the underlying `MetaIoHandler`
+	pub fn io_handler(&self) -> Arc<jsonrpc_core::MetaIoHandler<sc_rpc::Metadata>> {
+		self.0.clone()
+	}
 }
 
+
 /// Sinks to propagate network status updates.
 /// For each element, every time the `Interval` fires we push an element on the sender.
 #[derive(Clone)]

client/service/src/task_manager/mod.rs

@@ -336,9 +336,12 @@ impl TaskManager {
 		}
 	}
 
-	/// Set what the task manager should keep alive.
-	pub(super) fn keep_alive<T: 'static + Send + Sync>(&mut self, to_keep_alive: T) {
-		self.keep_alive = Box::new(to_keep_alive);
+	/// Set what the task manager should keep alive, can be called multiple times.
+	pub fn keep_alive<T: 'static + Send + Sync>(&mut self, to_keep_alive: T) {
+		// allows this fn to safely called multiple times.
+		use std::mem;
+		let old = mem::replace(&mut self.keep_alive, Box::new(()));
+		self.keep_alive = Box::new((to_keep_alive, old));
 	}
 
 	/// Register another TaskManager to terminate and gracefully shutdown when the parent

utils/browser/src/lib.rs

@@ -27,7 +27,7 @@ use wasm_bindgen::prelude::*;
 use futures::{
 	prelude::*, channel::{oneshot, mpsc}, compat::*, future::{ready, ok, select}
 };
-use std::{sync::Arc, pin::Pin};
+use std::pin::Pin;
 use sc_chain_spec::Extension;
 use libp2p_wasm_ext::{ExtTransport, ffi};
 
@@ -124,7 +124,7 @@ struct RpcMessage {
 }
 
 /// Create a Client object that connects to a service.
-pub fn start_client(mut task_manager: TaskManager, rpc_handlers: Arc<RpcHandlers>) -> Client {
+pub fn start_client(mut task_manager: TaskManager, rpc_handlers: RpcHandlers) -> Client {
 	// We dispatch a background task responsible for processing the service.
 	//
 	// The main action performed by the code below consists in polling the service with