Service factory refactor (#3382)

* Move Service::new to a macro

* Move function calls to macros

* Extract offchain_workers and start_rpc in separate function

In follow-up commits, we want to be able to directly call maintain_transaction_pool, offchain_workers, and start_rpc, without having to implement the Components trait.
This commit is a preliminary step: we extract the code to freestanding functions.

* Introduce an AbstractService trait

* Introduce NewService as an implementation detail of Service

* Implement traits on NewService instead

Instead of implementing AbstractService, Future, and Executor on Service, we implement them on NewService instead.

The implementations of AbstractService, Future, and Executor on Service still exist, but they just wrap to the respective implementations for NewService.

* Move components creation back to macro invocation

Instead of having multiple $build_ parameters passed to the macro, let's group them all into one.

This change is necessary for the follow-up commits, because we are going to call new_impl! only after all the components have already been built.

* Add a $block parameter to new_impl

This makes it possible to be explicit as what the generic parameter of the NewServiceis, without relying on type inference.

* Introduce the ServiceBuilder struct

Introduces a new builder-like ServiceBuilder struct that creates a NewService.

* Macro-ify import_blocks, export_blocks and revert_chain

Similar to the introduction of new_impl!, we extract the actual code into a macro, letting us get rid of the Components and Factory traits

* Add export_blocks, import_blocks and revert_chain methods on ServiceBuilder

Can be used as a replacement for the chain_ops::* methods

* Add run_with_builder

Instead of just run, adds run_with_builder to ParseAndPrepareExport/Import/Revert. This lets you run these operations with a ServiceBuilder instead of a ServiceFactory.

* Transition node and node-template to ServiceBuilder

* Transition transaction-factory to the new service factory

This is technically a breaking change, but the transaction-factory crate is only ever used from within substrate-node, which this commit updates as well.

* Remove old service factory

* Adjust the AbstractService trait to be more usable

We slightly change the trait bounds in order to make all the methods usable.

* Make substrate-service-test compile

* Fix the node-cli tests

* Remove the old API

* Remove the components module

* Fix indentation on chain_ops

* Line widths

* Fix bad line widths commit

* Line widths again 🤦

* Fix the sync test

* Apply suggestions from code review

Co-Authored-By: Gavin Wood <i@gavwood.com>

* Address some concerns

* Remove TelemetryOnConnect

* Remove informant::start

* Update jsonrpc

* Rename factory to builder

* Line widths 😩

substrate/core/service/src/builder.rs

@@ -0,0 +1,809 @@
+// Copyright 2017-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::{NewService, NetworkStatus, NetworkState, error::{self, Error}, DEFAULT_PROTOCOL_ID};
+use crate::{SpawnTaskHandle, start_rpc_servers, build_network_future, TransactionPoolAdapter};
+use crate::TaskExecutor;
+use crate::config::Configuration;
+use client::{BlockchainEvents, Client, runtime_api};
+use codec::{Decode, Encode, IoReader};
+use consensus_common::import_queue::ImportQueue;
+use futures::{prelude::*, sync::mpsc};
+use futures03::{FutureExt as _, compat::Compat, StreamExt as _, TryStreamExt as _};
+use keystore::{Store as Keystore, KeyStorePtr};
+use log::{info, warn};
+use network::{FinalityProofProvider, OnDemand, NetworkService, NetworkStateInfo};
+use network::{config::BoxFinalityProofRequestBuilder, specialization::NetworkSpecialization};
+use parking_lot::{Mutex, RwLock};
+use primitives::{Blake2Hasher, H256, Hasher};
+use rpc::{self, system::SystemInfo};
+use sr_primitives::{BuildStorage, generic::BlockId};
+use sr_primitives::traits::{Block as BlockT, ProvideRuntimeApi, NumberFor, One, Zero, Header, SaturatedConversion};
+use substrate_executor::{NativeExecutor, NativeExecutionDispatch};
+use serde::{Serialize, de::DeserializeOwned};
+use std::{io::{Read, Write, Seek}, marker::PhantomData, sync::Arc, sync::atomic::AtomicBool};
+use sysinfo::{get_current_pid, ProcessExt, System, SystemExt};
+use tel::{telemetry, SUBSTRATE_INFO};
+use transaction_pool::txpool::{self, ChainApi, Pool as TransactionPool};
+
+/// Aggregator for the components required to build a service.
+///
+/// # Usage
+///
+/// Call [`ServiceBuilder::new_full`] or [`ServiceBuilder::new_light`], then call the various
+/// `with_` methods to add the required components that you built yourself:
+///
+/// - [`with_select_chain`](ServiceBuilder::with_select_chain)
+/// - [`with_import_queue`](ServiceBuilder::with_import_queue)
+/// - [`with_network_protocol`](ServiceBuilder::with_network_protocol)
+/// - [`with_finality_proof_provider`](ServiceBuilder::with_finality_proof_provider)
+/// - [`with_transaction_pool`](ServiceBuilder::with_transaction_pool)
+///
+/// After this is done, call [`build`](ServiceBuilder::build) to construct the service.
+///
+/// The order in which the `with_*` methods are called doesn't matter, as the correct binding of
+/// generics is done when you call `build`.
+///
+pub struct ServiceBuilder<TBl, TRtApi, TCfg, TGen, TCl, TFchr, TSc, TImpQu, TFprb, TFpp, TNetP, TExPool, TRpc> {
+	config: Configuration<TCfg, TGen>,
+	client: Arc<TCl>,
+	keystore: Arc<RwLock<Keystore>>,
+	fetcher: Option<TFchr>,
+	select_chain: Option<TSc>,
+	import_queue: TImpQu,
+	finality_proof_request_builder: Option<TFprb>,
+	finality_proof_provider: Option<TFpp>,
+	network_protocol: TNetP,
+	transaction_pool: Arc<TExPool>,
+	rpc_extensions: TRpc,
+	marker: PhantomData<(TBl, TRtApi)>,
+}
+
+impl<TCfg, TGen> ServiceBuilder<(), (), TCfg, TGen, (), (), (), (), (), (), (), (), ()>
+where TGen: Serialize + DeserializeOwned + BuildStorage {
+	/// Start the service builder with a configuration.
+	pub fn new_full<TBl: BlockT<Hash=H256>, TRtApi, TExecDisp: NativeExecutionDispatch>(
+		config: Configuration<TCfg, TGen>
+	) -> Result<ServiceBuilder<
+		TBl,
+		TRtApi,
+		TCfg,
+		TGen,
+		Client<
+			client_db::Backend<TBl>,
+			client::LocalCallExecutor<client_db::Backend<TBl>, NativeExecutor<TExecDisp>>,
+			TBl,
+			TRtApi
+		>,
+		Arc<OnDemand<TBl>>,
+		(),
+		(),
+		BoxFinalityProofRequestBuilder<TBl>,
+		(),
+		(),
+		(),
+		()
+	>, Error> {
+		let keystore = Keystore::open(config.keystore_path.clone(), config.keystore_password.clone())?;
+
+		let db_settings = client_db::DatabaseSettings {
+			cache_size: None,
+			state_cache_size: config.state_cache_size,
+			state_cache_child_ratio:
+				config.state_cache_child_ratio.map(|v| (v, 100)),
+			path: config.database_path.clone(),
+			pruning: config.pruning.clone(),
+		};
+
+		let executor = NativeExecutor::<TExecDisp>::new(config.default_heap_pages);
+
+		let client = Arc::new(client_db::new_client(
+			db_settings,
+			executor,
+			&config.chain_spec,
+			config.execution_strategies.clone(),
+			Some(keystore.clone()),
+		)?);
+
+		Ok(ServiceBuilder {
+			config,
+			client,
+			keystore,
+			fetcher: None,
+			select_chain: None,
+			import_queue: (),
+			finality_proof_request_builder: None,
+			finality_proof_provider: None,
+			network_protocol: (),
+			transaction_pool: Arc::new(()),
+			rpc_extensions: Default::default(),
+			marker: PhantomData,
+		})
+	}
+
+	/// Start the service builder with a configuration.
+	pub fn new_light<TBl: BlockT<Hash=H256>, TRtApi, TExecDisp: NativeExecutionDispatch + 'static>(
+		config: Configuration<TCfg, TGen>
+	) -> Result<ServiceBuilder<
+		TBl,
+		TRtApi,
+		TCfg,
+		TGen,
+		Client<
+			client::light::backend::Backend<client_db::light::LightStorage<TBl>, network::OnDemand<TBl>, Blake2Hasher>,
+			client::light::call_executor::RemoteOrLocalCallExecutor<
+				TBl,
+				client::light::backend::Backend<
+					client_db::light::LightStorage<TBl>,
+					network::OnDemand<TBl>,
+					Blake2Hasher
+				>,
+				client::light::call_executor::RemoteCallExecutor<
+					client::light::blockchain::Blockchain<
+						client_db::light::LightStorage<TBl>,
+						network::OnDemand<TBl>
+					>,
+					network::OnDemand<TBl>,
+				>,
+				client::LocalCallExecutor<
+					client::light::backend::Backend<
+						client_db::light::LightStorage<TBl>,
+						network::OnDemand<TBl>,
+						Blake2Hasher
+					>,
+					NativeExecutor<TExecDisp>
+				>
+			>,
+			TBl,
+			TRtApi
+		>,
+		Arc<OnDemand<TBl>>,
+		(),
+		(),
+		BoxFinalityProofRequestBuilder<TBl>,
+		(),
+		(),
+		(),
+		()
+	>, Error> {
+		let keystore = Keystore::open(config.keystore_path.clone(), config.keystore_password.clone())?;
+
+		let db_settings = client_db::DatabaseSettings {
+			cache_size: config.database_cache_size.map(|u| u as usize),
+			state_cache_size: config.state_cache_size,
+			state_cache_child_ratio:
+				config.state_cache_child_ratio.map(|v| (v, 100)),
+			path: config.database_path.clone(),
+			pruning: config.pruning.clone(),
+		};
+
+		let executor = NativeExecutor::<TExecDisp>::new(config.default_heap_pages);
+
+		let db_storage = client_db::light::LightStorage::new(db_settings)?;
+		let light_blockchain = client::light::new_light_blockchain(db_storage);
+		let fetch_checker = Arc::new(client::light::new_fetch_checker(light_blockchain.clone(), executor.clone()));
+		let fetcher = Arc::new(network::OnDemand::new(fetch_checker));
+		let client_backend = client::light::new_light_backend(light_blockchain, fetcher.clone());
+		let client = client::light::new_light(client_backend, fetcher.clone(), &config.chain_spec, executor)?;
+
+		Ok(ServiceBuilder {
+			config,
+			client: Arc::new(client),
+			keystore,
+			fetcher: Some(fetcher),
+			select_chain: None,
+			import_queue: (),
+			finality_proof_request_builder: None,
+			finality_proof_provider: None,
+			network_protocol: (),
+			transaction_pool: Arc::new(()),
+			rpc_extensions: Default::default(),
+			marker: PhantomData,
+		})
+	}
+}
+
+impl<TBl, TRtApi, TCfg, TGen, TCl, TFchr, TSc, TImpQu, TFprb, TFpp, TNetP, TExPool, TRpc>
+	ServiceBuilder<TBl, TRtApi, TCfg, TGen, TCl, TFchr, TSc, TImpQu, TFprb, TFpp, TNetP, TExPool, TRpc> {
+
+	/// Returns a reference to the client that was stored in this builder.
+	pub fn client(&self) -> &Arc<TCl> {
+		&self.client
+	}
+
+	/// Returns a reference to the select-chain that was stored in this builder.
+	pub fn select_chain(&self) -> Option<&TSc> {
+		self.select_chain.as_ref()
+	}
+
+	/// Defines which head-of-chain strategy to use.
+	pub fn with_opt_select_chain<USc>(
+		mut self,
+		select_chain_builder: impl FnOnce(&mut Configuration<TCfg, TGen>, Arc<TCl>) -> Result<Option<USc>, Error>
+	) -> Result<ServiceBuilder<TBl, TRtApi, TCfg, TGen, TCl, TFchr, USc, TImpQu, TFprb, TFpp,
+		TNetP, TExPool, TRpc>, Error> {
+		let select_chain = select_chain_builder(&mut self.config, self.client.clone())?;
+
+		Ok(ServiceBuilder {
+			config: self.config,
+			client: self.client,
+			keystore: self.keystore,
+			fetcher: self.fetcher,
+			select_chain,
+			import_queue: self.import_queue,
+			finality_proof_request_builder: self.finality_proof_request_builder,
+			finality_proof_provider: self.finality_proof_provider,
+			network_protocol: self.network_protocol,
+			transaction_pool: self.transaction_pool,
+			rpc_extensions: self.rpc_extensions,
+			marker: self.marker,
+		})
+	}
+
+	/// Defines which head-of-chain strategy to use.
+	pub fn with_select_chain<USc>(
+		self,
+		builder: impl FnOnce(&mut Configuration<TCfg, TGen>, Arc<TCl>) -> Result<USc, Error>
+	) -> Result<ServiceBuilder<TBl, TRtApi, TCfg, TGen, TCl, TFchr, USc, TImpQu, TFprb, TFpp,
+		TNetP, TExPool, TRpc>, Error> {
+		self.with_opt_select_chain(|cfg, cl| builder(cfg, cl).map(Option::Some))
+	}
+
+	/// Defines which import queue to use.
+	pub fn with_import_queue<UImpQu>(
+		mut self,
+		builder: impl FnOnce(&mut Configuration<TCfg, TGen>, Arc<TCl>, Option<TSc>, Arc<TExPool>)
+			-> Result<UImpQu, Error>
+	) -> Result<ServiceBuilder<TBl, TRtApi, TCfg, TGen, TCl, TFchr, TSc, UImpQu, TFprb, TFpp,
+			TNetP, TExPool, TRpc>, Error>
+	where TSc: Clone {
+		let import_queue = builder(
+			&mut self.config,
+			self.client.clone(),
+			self.select_chain.clone(),
+			self.transaction_pool.clone()
+		)?;
+
+		Ok(ServiceBuilder {
+			config: self.config,
+			client: self.client,
+			keystore: self.keystore,
+			fetcher: self.fetcher,
+			select_chain: self.select_chain,
+			import_queue,
+			finality_proof_request_builder: self.finality_proof_request_builder,
+			finality_proof_provider: self.finality_proof_provider,
+			network_protocol: self.network_protocol,
+			transaction_pool: self.transaction_pool,
+			rpc_extensions: self.rpc_extensions,
+			marker: self.marker,
+		})
+	}
+
+	/// Defines which network specialization protocol to use.
+	pub fn with_network_protocol<UNetP>(
+		self,
+		network_protocol_builder: impl FnOnce(&Configuration<TCfg, TGen>) -> Result<UNetP, Error>
+	) -> Result<ServiceBuilder<TBl, TRtApi, TCfg, TGen, TCl, TFchr, TSc, TImpQu, TFprb, TFpp,
+		UNetP, TExPool, TRpc>, Error> {
+		let network_protocol = network_protocol_builder(&self.config)?;
+
+		Ok(ServiceBuilder {
+			config: self.config,
+			client: self.client,
+			keystore: self.keystore,
+			fetcher: self.fetcher,
+			select_chain: self.select_chain,
+			import_queue: self.import_queue,
+			finality_proof_request_builder: self.finality_proof_request_builder,
+			finality_proof_provider: self.finality_proof_provider,
+			network_protocol,
+			transaction_pool: self.transaction_pool,
+			rpc_extensions: self.rpc_extensions,
+			marker: self.marker,
+		})
+	}
+
+	/// Defines which strategy to use for providing finality proofs.
+	pub fn with_opt_finality_proof_provider(
+		self,
+		builder: impl FnOnce(Arc<TCl>) -> Result<Option<Arc<FinalityProofProvider<TBl>>>, Error>
+	) -> Result<ServiceBuilder<
+		TBl,
+		TRtApi,
+		TCfg,
+		TGen,
+		TCl,
+		TFchr,
+		TSc,
+		TImpQu,
+		TFprb,
+		Arc<FinalityProofProvider<TBl>>,
+		TNetP,
+		TExPool,
+		TRpc
+	>, Error> {
+		let finality_proof_provider = builder(self.client.clone())?;
+
+		Ok(ServiceBuilder {
+			config: self.config,
+			client: self.client,
+			keystore: self.keystore,
+			fetcher: self.fetcher,
+			select_chain: self.select_chain,
+			import_queue: self.import_queue,
+			finality_proof_request_builder: self.finality_proof_request_builder,
+			finality_proof_provider,
+			network_protocol: self.network_protocol,
+			transaction_pool: self.transaction_pool,
+			rpc_extensions: self.rpc_extensions,
+			marker: self.marker,
+		})
+	}
+
+	/// Defines which strategy to use for providing finality proofs.
+	pub fn with_finality_proof_provider(
+		self,
+		build: impl FnOnce(Arc<TCl>) -> Result<Arc<FinalityProofProvider<TBl>>, Error>
+	) -> Result<ServiceBuilder<
+		TBl,
+		TRtApi,
+		TCfg,
+		TGen,
+		TCl,
+		TFchr,
+		TSc,
+		TImpQu,
+		TFprb,
+		Arc<FinalityProofProvider<TBl>>,
+		TNetP,
+		TExPool,
+		TRpc
+	>, Error> {
+		self.with_opt_finality_proof_provider(|client| build(client).map(Option::Some))
+	}
+
+	/// Defines which import queue to use.
+	pub fn with_import_queue_and_opt_fprb<UImpQu, UFprb>(
+		mut self,
+		builder: impl FnOnce(&mut Configuration<TCfg, TGen>, Arc<TCl>, Option<TSc>, Arc<TExPool>)
+			-> Result<(UImpQu, Option<UFprb>), Error>
+	) -> Result<ServiceBuilder<TBl, TRtApi, TCfg, TGen, TCl, TFchr, TSc, UImpQu, UFprb, TFpp,
+		TNetP, TExPool, TRpc>, Error>
+	where TSc: Clone {
+		let (import_queue, fprb) = builder(
+			&mut self.config,
+			self.client.clone(),
+			self.select_chain.clone(),
+			self.transaction_pool.clone()
+		)?;
+
+		Ok(ServiceBuilder {
+			config: self.config,
+			client: self.client,
+			keystore: self.keystore,
+			fetcher: self.fetcher,
+			select_chain: self.select_chain,
+			import_queue,
+			finality_proof_request_builder: fprb,
+			finality_proof_provider: self.finality_proof_provider,
+			network_protocol: self.network_protocol,
+			transaction_pool: self.transaction_pool,
+			rpc_extensions: self.rpc_extensions,
+			marker: self.marker,
+		})
+	}
+
+	/// Defines which import queue to use.
+	pub fn with_import_queue_and_fprb<UImpQu, UFprb>(
+		self,
+		builder: impl FnOnce(&mut Configuration<TCfg, TGen>, Arc<TCl>, Option<TSc>, Arc<TExPool>)
+			-> Result<(UImpQu, UFprb), Error>
+	) -> Result<ServiceBuilder<TBl, TRtApi, TCfg, TGen, TCl, TFchr, TSc, UImpQu, UFprb, TFpp,
+			TNetP, TExPool, TRpc>, Error>
+	where TSc: Clone {
+		self.with_import_queue_and_opt_fprb(|cfg, cl, sc, tx| builder(cfg, cl, sc, tx).map(|(q, f)| (q, Some(f))))
+	}
+
+	/// Defines which transaction pool to use.
+	pub fn with_transaction_pool<UExPool>(
+		self,
+		transaction_pool_builder: impl FnOnce(transaction_pool::txpool::Options, Arc<TCl>) -> Result<UExPool, Error>
+	) -> Result<ServiceBuilder<TBl, TRtApi, TCfg, TGen, TCl, TFchr, TSc, TImpQu, TFprb, TFpp,
+		TNetP, UExPool, TRpc>, Error> {
+		let transaction_pool = transaction_pool_builder(self.config.transaction_pool.clone(), self.client.clone())?;
+
+		Ok(ServiceBuilder {
+			config: self.config,
+			client: self.client,
+			keystore: self.keystore,
+			fetcher: self.fetcher,
+			select_chain: self.select_chain,
+			import_queue: self.import_queue,
+			finality_proof_request_builder: self.finality_proof_request_builder,
+			finality_proof_provider: self.finality_proof_provider,
+			network_protocol: self.network_protocol,
+			transaction_pool: Arc::new(transaction_pool),
+			rpc_extensions: self.rpc_extensions,
+			marker: self.marker,
+		})
+	}
+
+	/// Defines the RPC extensions to use.
+	pub fn with_rpc_extensions<URpc>(
+		self,
+		rpc_ext_builder: impl FnOnce(Arc<TCl>, Arc<TExPool>) -> URpc
+	) -> Result<ServiceBuilder<TBl, TRtApi, TCfg, TGen, TCl, TFchr, TSc, TImpQu, TFprb, TFpp,
+		TNetP, TExPool, URpc>, Error> {
+		let rpc_extensions = rpc_ext_builder(self.client.clone(), self.transaction_pool.clone());
+
+		Ok(ServiceBuilder {
+			config: self.config,
+			client: self.client,
+			keystore: self.keystore,
+			fetcher: self.fetcher,
+			select_chain: self.select_chain,
+			import_queue: self.import_queue,
+			finality_proof_request_builder: self.finality_proof_request_builder,
+			finality_proof_provider: self.finality_proof_provider,
+			network_protocol: self.network_protocol,
+			transaction_pool: self.transaction_pool,
+			rpc_extensions,
+			marker: self.marker,
+		})
+	}
+}
+
+/// Implemented on `ServiceBuilder`. Allows importing blocks once you have given all the required
+/// components to the builder.
+pub trait ServiceBuilderImport {
+	/// Starts the process of importing blocks.
+	fn import_blocks(
+		self,
+		exit: impl Future<Item=(),Error=()> + Send + 'static,
+		input: impl Read + Seek,
+	) -> Result<Box<dyn Future<Item = (), Error = ()> + Send>, Error>;
+}
+
+/// Implemented on `ServiceBuilder`. Allows exporting blocks once you have given all the required
+/// components to the builder.
+pub trait ServiceBuilderExport {
+	/// Type of block of the builder.
+	type Block: BlockT;
+
+	/// Performs the blocks export.
+	fn export_blocks(
+		&self,
+		exit: impl Future<Item=(),Error=()> + Send + 'static,
+		output: impl Write,
+		from: NumberFor<Self::Block>,
+		to: Option<NumberFor<Self::Block>>,
+		json: bool
+	) -> Result<(), Error>;
+}
+
+/// Implemented on `ServiceBuilder`. Allows reverting the chain once you have given all the
+/// required components to the builder.
+pub trait ServiceBuilderRevert {
+	/// Type of block of the builder.
+	type Block: BlockT;
+
+	/// Performs a revert of `blocks` bocks.
+	fn revert_chain(
+		&self,
+		blocks: NumberFor<Self::Block>
+	) -> Result<(), Error>;
+}
+
+impl<TBl, TRtApi, TCfg, TGen, TBackend, TExec, TFchr, TSc, TImpQu, TFprb, TFpp, TNetP, TExPool, TRpc>
+	ServiceBuilderImport for ServiceBuilder<TBl, TRtApi, TCfg, TGen, Client<TBackend, TExec, TBl, TRtApi>,
+		TFchr, TSc, TImpQu, TFprb, TFpp, TNetP, TExPool, TRpc>
+where
+	TBl: BlockT<Hash = <Blake2Hasher as Hasher>::Out>,
+	TBackend: 'static + client::backend::Backend<TBl, Blake2Hasher> + Send,
+	TExec: 'static + client::CallExecutor<TBl, Blake2Hasher> + Send + Sync + Clone,
+	TImpQu: 'static + ImportQueue<TBl>,
+	TRtApi: 'static + Send + Sync,
+{
+	fn import_blocks(
+		self,
+		exit: impl Future<Item=(),Error=()> + Send + 'static,
+		input: impl Read + Seek,
+	) -> Result<Box<dyn Future<Item = (), Error = ()> + Send>, Error> {
+		let client = self.client;
+		let mut queue = self.import_queue;
+		import_blocks!(TBl, client, queue, exit, input)
+			.map(|f| Box::new(f) as Box<_>)
+	}
+}
+
+impl<TBl, TRtApi, TCfg, TGen, TBackend, TExec, TFchr, TSc, TImpQu, TFprb, TFpp, TNetP, TExPool, TRpc>
+	ServiceBuilderExport for ServiceBuilder<TBl, TRtApi, TCfg, TGen, Client<TBackend, TExec, TBl, TRtApi>,
+		TFchr, TSc, TImpQu, TFprb, TFpp, TNetP, TExPool, TRpc>
+where
+	TBl: BlockT<Hash = <Blake2Hasher as Hasher>::Out>,
+	TBackend: 'static + client::backend::Backend<TBl, Blake2Hasher> + Send,
+	TExec: 'static + client::CallExecutor<TBl, Blake2Hasher> + Send + Sync + Clone
+{
+	type Block = TBl;
+
+	fn export_blocks(
+		&self,
+		exit: impl Future<Item=(),Error=()> + Send + 'static,
+		mut output: impl Write,
+		from: NumberFor<TBl>,
+		to: Option<NumberFor<TBl>>,
+		json: bool
+	) -> Result<(), Error> {
+		let client = &self.client;
+		export_blocks!(client, exit, output, from, to, json)
+	}
+}
+
+impl<TBl, TRtApi, TCfg, TGen, TBackend, TExec, TFchr, TSc, TImpQu, TFprb, TFpp, TNetP, TExPool, TRpc>
+	ServiceBuilderRevert for ServiceBuilder<TBl, TRtApi, TCfg, TGen, Client<TBackend, TExec, TBl, TRtApi>,
+		TFchr, TSc, TImpQu, TFprb, TFpp, TNetP, TExPool, TRpc>
+where
+	TBl: BlockT<Hash = <Blake2Hasher as Hasher>::Out>,
+	TBackend: 'static + client::backend::Backend<TBl, Blake2Hasher> + Send,
+	TExec: 'static + client::CallExecutor<TBl, Blake2Hasher> + Send + Sync + Clone
+{
+	type Block = TBl;
+
+	fn revert_chain(
+		&self,
+		blocks: NumberFor<TBl>
+	) -> Result<(), Error> {
+		let client = &self.client;
+		revert_chain!(client, blocks)
+	}
+}
+
+impl<TBl, TRtApi, TCfg, TGen, TBackend, TExec, TSc, TImpQu, TNetP, TExPoolApi, TRpc>
+ServiceBuilder<
+	TBl,
+	TRtApi,
+	TCfg,
+	TGen,
+	Client<TBackend, TExec, TBl, TRtApi>,
+	Arc<OnDemand<TBl>>,
+	TSc,
+	TImpQu,
+	BoxFinalityProofRequestBuilder<TBl>,
+	Arc<FinalityProofProvider<TBl>>,
+	TNetP,
+	TransactionPool<TExPoolApi>,
+	TRpc
+> where
+	Client<TBackend, TExec, TBl, TRtApi>: ProvideRuntimeApi,
+	<Client<TBackend, TExec, TBl, TRtApi> as ProvideRuntimeApi>::Api:
+		runtime_api::Metadata<TBl> +
+		offchain::OffchainWorkerApi<TBl> +
+		runtime_api::TaggedTransactionQueue<TBl> +
+		session::SessionKeys<TBl>,
+	TBl: BlockT<Hash = <Blake2Hasher as Hasher>::Out>,
+	TRtApi: 'static + Send + Sync,
+	TCfg: Default,
+	TGen: Serialize + DeserializeOwned + BuildStorage,
+	TBackend: 'static + client::backend::Backend<TBl, Blake2Hasher> + Send,
+	TExec: 'static + client::CallExecutor<TBl, Blake2Hasher> + Send + Sync + Clone,
+	TSc: Clone,
+	TImpQu: 'static + ImportQueue<TBl>,
+	TNetP: NetworkSpecialization<TBl>,
+	TExPoolApi: 'static + ChainApi<Block = TBl, Hash = <TBl as BlockT>::Hash>,
+	TRpc: rpc::RpcExtension<rpc::Metadata> + Clone,
+{
+	/// Builds the service.
+	pub fn build(self) -> Result<NewService<
+		Configuration<TCfg, TGen>,
+		TBl,
+		Client<TBackend, TExec, TBl, TRtApi>,
+		TSc,
+		NetworkStatus<TBl>,
+		NetworkService<TBl, TNetP, <TBl as BlockT>::Hash>,
+		TransactionPool<TExPoolApi>,
+		offchain::OffchainWorkers<
+			Client<TBackend, TExec, TBl, TRtApi>,
+			TBackend::OffchainStorage,
+			TBl
+		>,
+	>, Error> {
+		let mut config = self.config;
+		session::generate_initial_session_keys(
+			self.client.clone(),
+			config.dev_key_seed.clone().map(|s| vec![s]).unwrap_or_default()
+		)?;
+		let (
+			client,
+			fetcher,
+			keystore,
+			select_chain,
+			import_queue,
+			finality_proof_request_builder,
+			finality_proof_provider,
+			network_protocol,
+			transaction_pool,
+			rpc_extensions
+		) = (
+			self.client,
+			self.fetcher,
+			self.keystore,
+			self.select_chain,
+			self.import_queue,
+			self.finality_proof_request_builder,
+			self.finality_proof_provider,
+			self.network_protocol,
+			self.transaction_pool,
+			self.rpc_extensions
+		);
+
+		new_impl!(
+			TBl,
+			config,
+			move |_| -> Result<_, Error> {
+				Ok((
+					client,
+					fetcher,
+					keystore,
+					select_chain,
+					import_queue,
+					finality_proof_request_builder,
+					finality_proof_provider,
+					network_protocol,
+					transaction_pool,
+					rpc_extensions
+				))
+			},
+			|h, c, tx| maintain_transaction_pool(h, c, tx),
+			|n, o, p, ns, v| offchain_workers(n, o, p, ns, v),
+			|c, ssb, si, te, tp, ext, ks| start_rpc(c, ssb, si, te, tp, ext, ks),
+		)
+	}
+}
+
+pub(crate) fn start_rpc<Api, Backend, Block, Executor, PoolApi>(
+	client: Arc<Client<Backend, Executor, Block, Api>>,
+	system_send_back: futures03::channel::mpsc::UnboundedSender<rpc::system::Request<Block>>,
+	rpc_system_info: SystemInfo,
+	task_executor: TaskExecutor,
+	transaction_pool: Arc<TransactionPool<PoolApi>>,
+	rpc_extensions: impl rpc::RpcExtension<rpc::Metadata>,
+	keystore: KeyStorePtr,
+) -> rpc_servers::RpcHandler<rpc::Metadata>
+where
+	Block: BlockT<Hash = <Blake2Hasher as primitives::Hasher>::Out>,
+	Backend: client::backend::Backend<Block, Blake2Hasher> + 'static,
+	Client<Backend, Executor, Block, Api>: ProvideRuntimeApi,
+	<Client<Backend, Executor, Block, Api> as ProvideRuntimeApi>::Api:
+		runtime_api::Metadata<Block> + session::SessionKeys<Block>,
+	Api: Send + Sync + 'static,
+	Executor: client::CallExecutor<Block, Blake2Hasher> + Send + Sync + Clone + 'static,
+	PoolApi: txpool::ChainApi<Hash = Block::Hash, Block = Block> + 'static {
+	use rpc::{chain, state, author, system};
+	let subscriptions = rpc::Subscriptions::new(task_executor.clone());
+	let chain = chain::Chain::new(client.clone(), subscriptions.clone());
+	let state = state::State::new(client.clone(), subscriptions.clone());
+	let author = rpc::author::Author::new(
+		client,
+		transaction_pool,
+		subscriptions,
+		keystore,
+	);
+	let system = system::System::new(rpc_system_info, system_send_back);
+
+	rpc_servers::rpc_handler((
+		state::StateApi::to_delegate(state),
+		chain::ChainApi::to_delegate(chain),
+		author::AuthorApi::to_delegate(author),
+		system::SystemApi::to_delegate(system),
+		rpc_extensions,
+	))
+}
+
+pub(crate) fn maintain_transaction_pool<Api, Backend, Block, Executor, PoolApi>(
+	id: &BlockId<Block>,
+	client: &Client<Backend, Executor, Block, Api>,
+	transaction_pool: &TransactionPool<PoolApi>,
+) -> error::Result<()> where
+	Block: BlockT<Hash = <Blake2Hasher as primitives::Hasher>::Out>,
+	Backend: client::backend::Backend<Block, Blake2Hasher>,
+	Client<Backend, Executor, Block, Api>: ProvideRuntimeApi,
+	<Client<Backend, Executor, Block, Api> as ProvideRuntimeApi>::Api: runtime_api::TaggedTransactionQueue<Block>,
+	Executor: client::CallExecutor<Block, Blake2Hasher>,
+	PoolApi: txpool::ChainApi<Hash = Block::Hash, Block = Block>,
+{
+	// Avoid calling into runtime if there is nothing to prune from the pool anyway.
+	if transaction_pool.status().is_empty() {
+		return Ok(())
+	}
+
+	if let Some(block) = client.block(id)? {
+		let parent_id = BlockId::hash(*block.block.header().parent_hash());
+		let extrinsics = block.block.extrinsics();
+		transaction_pool.prune(id, &parent_id, extrinsics).map_err(|e| format!("{:?}", e))?;
+	}
+
+	Ok(())
+}
+
+pub(crate) fn offchain_workers<Api, Backend, Block, Executor, PoolApi>(
+	number: &NumberFor<Block>,
+	offchain: &offchain::OffchainWorkers<
+		Client<Backend, Executor, Block, Api>,
+		<Backend as client::backend::Backend<Block, Blake2Hasher>>::OffchainStorage,
+		Block
+	>,
+	pool: &Arc<TransactionPool<PoolApi>>,
+	network_state: &Arc<dyn NetworkStateInfo + Send + Sync>,
+	is_validator: bool,
+) -> error::Result<Box<dyn Future<Item = (), Error = ()> + Send>>
+where
+	Block: BlockT<Hash = <Blake2Hasher as primitives::Hasher>::Out>,
+	Backend: client::backend::Backend<Block, Blake2Hasher> + 'static,
+	Api: 'static,
+	<Backend as client::backend::Backend<Block, Blake2Hasher>>::OffchainStorage: 'static,
+	Client<Backend, Executor, Block, Api>: ProvideRuntimeApi + Send + Sync,
+	<Client<Backend, Executor, Block, Api> as ProvideRuntimeApi>::Api: offchain::OffchainWorkerApi<Block>,
+	Executor: client::CallExecutor<Block, Blake2Hasher> + 'static,
+	PoolApi: txpool::ChainApi<Hash = Block::Hash, Block = Block> + 'static,
+{
+	let future = offchain.on_block_imported(number, pool, network_state.clone(), is_validator)
+		.map(|()| Ok(()));
+	Ok(Box::new(Compat::new(future)))
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use consensus_common::{BlockOrigin, SelectChain};
+	use substrate_test_runtime_client::{prelude::*, runtime::Transfer};
+
+	#[test]
+	fn should_remove_transactions_from_the_pool() {
+		let (client, longest_chain) = TestClientBuilder::new().build_with_longest_chain();
+		let client = Arc::new(client);
+		let pool = TransactionPool::new(Default::default(), ::transaction_pool::ChainApi::new(client.clone()));
+		let transaction = Transfer {
+			amount: 5,
+			nonce: 0,
+			from: AccountKeyring::Alice.into(),
+			to: Default::default(),
+		}.into_signed_tx();
+		let best = longest_chain.best_chain().unwrap();
+
+		// store the transaction in the pool
+		pool.submit_one(&BlockId::hash(best.hash()), transaction.clone()).unwrap();
+
+		// import the block
+		let mut builder = client.new_block(Default::default()).unwrap();
+		builder.push(transaction.clone()).unwrap();
+		let block = builder.bake().unwrap();
+		let id = BlockId::hash(block.header().hash());
+		client.import(BlockOrigin::Own, block).unwrap();
+
+		// fire notification - this should clean up the queue
+		assert_eq!(pool.status().ready, 1);
+		maintain_transaction_pool(
+			&id,
+			&client,
+			&pool,
+		).unwrap();
+
+		// then
+		assert_eq!(pool.status().ready, 0);
+		assert_eq!(pool.status().future, 0);
+	}
+}

substrate/core/service/src/chain_ops.rs

@@ -16,44 +16,19 @@
 
 //! Chain utilities.
 
-use std::{self, io::{Read, Write, Seek}};
-use futures::prelude::*;
-use futures03::TryFutureExt as _;
-use log::{info, warn};
-
-use sr_primitives::generic::{SignedBlock, BlockId};
-use sr_primitives::traits::{SaturatedConversion, Zero, One, Block, Header, NumberFor};
-use consensus_common::import_queue::{ImportQueue, IncomingBlock, Link, BlockImportError, BlockImportResult};
-use network::message;
-
-use consensus_common::BlockOrigin;
-use crate::components::{self, Components, ServiceFactory, FactoryFullConfiguration, FactoryBlockNumber, RuntimeGenesis};
-use crate::new_client;
-use codec::{Decode, Encode, IoReader};
+use crate::RuntimeGenesis;
 use crate::error;
 use crate::chain_spec::ChainSpec;
 
-/// Export a range of blocks to a binary stream.
-pub fn export_blocks<F, E, W>(
-	config: FactoryFullConfiguration<F>,
-	exit: E,
-	mut output: W,
-	from: FactoryBlockNumber<F>,
-	to: Option<FactoryBlockNumber<F>>,
-	json: bool
-) -> error::Result<()>
-	where
-	F: ServiceFactory,
-	E: Future<Item=(),Error=()> + Send + 'static,
-	W: Write,
-{
-	let client = new_client::<F>(&config)?;
-	let mut block = from;
+#[macro_export]
+macro_rules! export_blocks {
+($client:ident, $exit:ident, $output:ident, $from:ident, $to:ident, $json:ident) => {{
+	let mut block = $from;
 
-	let last = match to {
+	let last = match $to {
 		Some(v) if v.is_zero() => One::one(),
 		Some(v) => v,
-		None => client.info().chain.best_number,
+		None => $client.info().chain.best_number,
 	};
 
 	if last < block {
@@ -62,28 +37,28 @@ pub fn export_blocks<F, E, W>(
 
 	let (exit_send, exit_recv) = std::sync::mpsc::channel();
 	::std::thread::spawn(move || {
-		let _ = exit.wait();
+		let _ = $exit.wait();
 		let _ = exit_send.send(());
 	});
 	info!("Exporting blocks from #{} to #{}", block, last);
-	if !json {
+	if !$json {
 		let last_: u64 = last.saturated_into::<u64>();
 		let block_: u64 = block.saturated_into::<u64>();
 		let len: u64 = last_ - block_ + 1;
-		output.write(&len.encode())?;
+		$output.write(&len.encode())?;
 	}
 
 	loop {
 		if exit_recv.try_recv().is_ok() {
 			break;
 		}
-		match client.block(&BlockId::number(block))? {
+		match $client.block(&BlockId::number(block))? {
 			Some(block) => {
-				if json {
-					serde_json::to_writer(&mut output, &block)
+				if $json {
+					serde_json::to_writer(&mut $output, &block)
 						.map_err(|e| format!("Error writing JSON: {}", e))?;
 				} else {
-					output.write(&block.encode())?;
+					$output.write(&block.encode())?;
 				}
 			},
 			None => break,
@@ -97,66 +72,59 @@ pub fn export_blocks<F, E, W>(
 		block += One::one();
 	}
 	Ok(())
+}}
 }
 
-struct WaitLink {
-	imported_blocks: u64,
-	has_error: bool,
-}
+#[macro_export]
+macro_rules! import_blocks {
+($block:ty, $client:ident, $queue:ident, $exit:ident, $input:ident) => {{
+	use consensus_common::import_queue::{IncomingBlock, Link, BlockImportError, BlockImportResult};
+	use consensus_common::BlockOrigin;
+	use network::message;
+	use sr_primitives::generic::SignedBlock;
+	use sr_primitives::traits::Block;
+	use futures03::TryFutureExt as _;
 
-impl WaitLink {
-	fn new() -> WaitLink {
-		WaitLink {
-			imported_blocks: 0,
-			has_error: false,
-		}
+	struct WaitLink {
+		imported_blocks: u64,
+		has_error: bool,
 	}
-}
 
-impl<B: Block> Link<B> for WaitLink {
-	fn blocks_processed(
-		&mut self,
-		imported: usize,
-		_count: usize,
-		results: Vec<(Result<BlockImportResult<NumberFor<B>>, BlockImportError>, B::Hash)>
-	) {
-		self.imported_blocks += imported as u64;
-
-		for result in results {
-			if let (Err(err), hash) = result {
-				warn!("There was an error importing block with hash {:?}: {:?}", hash, err);
-				self.has_error = true;
-				break;
+	impl WaitLink {
+		fn new() -> WaitLink {
+			WaitLink {
+				imported_blocks: 0,
+				has_error: false,
 			}
 		}
 	}
-}
 
-/// Returns a future that import blocks from a binary stream.
-pub fn import_blocks<F, E, R>(
-	mut config: FactoryFullConfiguration<F>,
-	exit: E,
-	input: R
-) -> error::Result<impl Future<Item = (), Error = ()>>
-	where F: ServiceFactory, E: Future<Item=(),Error=()> + Send + 'static, R: Read + Seek,
-{
-	let client = new_client::<F>(&config)?;
-	// FIXME #1134 this shouldn't need a mutable config.
-	let select_chain = components::FullComponents::<F>::build_select_chain(&mut config, client.clone())?;
-	let (mut queue, _) = components::FullComponents::<F>::build_import_queue(
-		&mut config,
-		client.clone(),
-		select_chain,
-		None,
-	)?;
+	impl<B: Block> Link<B> for WaitLink {
+		fn blocks_processed(
+			&mut self,
+			imported: usize,
+			_count: usize,
+			results: Vec<(Result<BlockImportResult<NumberFor<B>>, BlockImportError>, B::Hash)>
+		) {
+			self.imported_blocks += imported as u64;
+
+			for result in results {
+				if let (Err(err), hash) = result {
+					warn!("There was an error importing block with hash {:?}: {:?}", hash, err);
+					self.has_error = true;
+					break;
+				}
+			}
+		}
+	}
 
 	let (exit_send, exit_recv) = std::sync::mpsc::channel();
 	::std::thread::spawn(move || {
-		let _ = exit.wait();
+		let _ = $exit.wait();
 		let _ = exit_send.send(());
 	});
 
-	let mut io_reader_input = IoReader(input);
+	let mut io_reader_input = IoReader($input);
 	let count: u64 = Decode::decode(&mut io_reader_input)
 		.map_err(|e| format!("Error reading file: {}", e))?;
 	info!("Importing {} blocks", count);
@@ -165,11 +133,11 @@ pub fn import_blocks<F, E, R>(
 		if exit_recv.try_recv().is_ok() {
 			break;
 		}
-		match SignedBlock::<F::Block>::decode(&mut io_reader_input) {
+		match SignedBlock::<$block>::decode(&mut io_reader_input) {
 			Ok(signed) => {
 				let (header, extrinsics) = signed.block.deconstruct();
 				let hash = header.hash();
-				let block  = message::BlockData::<F::Block> {
+				let block  = message::BlockData::<$block> {
 					hash,
 					justification: signed.justification,
 					header: Some(header),
@@ -178,8 +146,8 @@ pub fn import_blocks<F, E, R>(
 					message_queue: None
 				};
 				// import queue handles verification and importing it into the client
-				queue.import_blocks(BlockOrigin::File, vec![
-					IncomingBlock::<F::Block> {
+				$queue.import_blocks(BlockOrigin::File, vec![
+					IncomingBlock::<$block> {
 						hash: block.hash,
 						header: block.header,
 						body: block.body,
@@ -208,7 +176,7 @@ pub fn import_blocks<F, E, R>(
 
 		let blocks_before = link.imported_blocks;
 		let _ = futures03::future::poll_fn(|cx| {
-			queue.poll_actions(cx, &mut link);
+			$queue.poll_actions(cx, &mut link);
 			std::task::Poll::Pending::<Result<(), ()>>
 		}).compat().poll();
 		if link.has_error {
@@ -226,24 +194,20 @@ pub fn import_blocks<F, E, R>(
 			);
 		}
 		if link.imported_blocks >= count {
-			info!("Imported {} blocks. Best: #{}", block_count, client.info().chain.best_number);
+			info!("Imported {} blocks. Best: #{}", block_count, $client.info().chain.best_number);
 			Ok(Async::Ready(()))
 		} else {
 			Ok(Async::NotReady)
 		}
 	}))
+}}
 }
 
-/// Revert the chain.
-pub fn revert_chain<F>(
-	config: FactoryFullConfiguration<F>,
-	blocks: FactoryBlockNumber<F>
-) -> error::Result<()>
-	where F: ServiceFactory,
-{
-	let client = new_client::<F>(&config)?;
-	let reverted = client.revert(blocks)?;
-	let info = client.info().chain;
+#[macro_export]
+macro_rules! revert_chain {
+($client:ident, $blocks:ident) => {{
+	let reverted = $client.revert($blocks)?;
+	let info = $client.info().chain;
 
 	if reverted.is_zero() {
 		info!("There aren't any non-finalized blocks to revert.");
@@ -251,6 +215,7 @@ pub fn revert_chain<F>(
 		info!("Reverted {} blocks. Best: #{} ({})", reverted, info.best_number, info.best_hash);
 	}
 	Ok(())
+}}
 }
 
 /// Build a chain spec json

substrate/core/service/src/chain_spec.rs

@@ -24,7 +24,7 @@ use serde::{Serialize, Deserialize};
 use primitives::storage::{StorageKey, StorageData};
 use sr_primitives::{BuildStorage, StorageOverlay, ChildrenStorageOverlay};
 use serde_json as json;
-use crate::components::RuntimeGenesis;
+use crate::RuntimeGenesis;
 use network::Multiaddr;
 use tel::TelemetryEndpoints;
 

substrate/core/service/src/components.rs

@@ -1,808 +0,0 @@
-// Copyright 2017-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/>.
-
-//! Substrate service components.
-
-use std::{sync::Arc, ops::Deref, ops::DerefMut};
-use serde::{Serialize, de::DeserializeOwned};
-use crate::chain_spec::ChainSpec;
-use keystore::KeyStorePtr;
-use client_db;
-use client::{self, Client, runtime_api};
-use crate::{error, Service};
-use consensus_common::{import_queue::ImportQueue, SelectChain};
-use network::{
-	self, OnDemand, FinalityProofProvider, NetworkStateInfo, config::BoxFinalityProofRequestBuilder
-};
-use substrate_executor::{NativeExecutor, NativeExecutionDispatch};
-use transaction_pool::txpool::{self, Options as TransactionPoolOptions, Pool as TransactionPool};
-use sr_primitives::{
-	BuildStorage, traits::{Block as BlockT, Header as HeaderT, ProvideRuntimeApi}, generic::BlockId
-};
-use crate::config::Configuration;
-use primitives::{Blake2Hasher, H256, traits::BareCryptoStorePtr};
-use rpc::{self, system::SystemInfo};
-use futures::{prelude::*, future::Executor};
-use futures03::{FutureExt as _, channel::mpsc, compat::Compat};
-
-// Type aliases.
-// These exist mainly to avoid typing `<F as Factory>::Foo` all over the code.
-
-/// Network service type for `Components`.
-pub type NetworkService<C> = network::NetworkService<
-	ComponentBlock<C>,
-	<<C as Components>::Factory as ServiceFactory>::NetworkProtocol,
-	ComponentExHash<C>
->;
-
-/// Code executor type for a factory.
-pub type CodeExecutor<F> = NativeExecutor<<F as ServiceFactory>::RuntimeDispatch>;
-
-/// Full client backend type for a factory.
-pub type FullBackend<F> = client_db::Backend<<F as ServiceFactory>::Block>;
-
-/// Full client executor type for a factory.
-pub type FullExecutor<F> = client::LocalCallExecutor<
-	client_db::Backend<<F as ServiceFactory>::Block>,
-	CodeExecutor<F>,
->;
-
-/// Light client backend type for a factory.
-pub type LightBackend<F> = client::light::backend::Backend<
-	client_db::light::LightStorage<<F as ServiceFactory>::Block>,
-	network::OnDemand<<F as ServiceFactory>::Block>,
-	Blake2Hasher,
->;
-
-/// Light client executor type for a factory.
-pub type LightExecutor<F> = client::light::call_executor::RemoteOrLocalCallExecutor<
-	<F as ServiceFactory>::Block,
-	client::light::backend::Backend<
-		client_db::light::LightStorage<<F as ServiceFactory>::Block>,
-		network::OnDemand<<F as ServiceFactory>::Block>,
-		Blake2Hasher
-	>,
-	client::light::call_executor::RemoteCallExecutor<
-		client::light::blockchain::Blockchain<
-			client_db::light::LightStorage<<F as ServiceFactory>::Block>,
-			network::OnDemand<<F as ServiceFactory>::Block>
-		>,
-		network::OnDemand<<F as ServiceFactory>::Block>,
-	>,
-	client::LocalCallExecutor<
-		client::light::backend::Backend<
-			client_db::light::LightStorage<<F as ServiceFactory>::Block>,
-			network::OnDemand<<F as ServiceFactory>::Block>,
-			Blake2Hasher
-		>,
-		CodeExecutor<F>
-	>
->;
-
-/// Full client type for a factory.
-pub type FullClient<F> = Client<FullBackend<F>, FullExecutor<F>, <F as ServiceFactory>::Block, <F as ServiceFactory>::RuntimeApi>;
-
-/// Light client type for a factory.
-pub type LightClient<F> = Client<LightBackend<F>, LightExecutor<F>, <F as ServiceFactory>::Block, <F as ServiceFactory>::RuntimeApi>;
-
-/// `ChainSpec` specialization for a factory.
-pub type FactoryChainSpec<F> = ChainSpec<<F as ServiceFactory>::Genesis>;
-
-/// `Genesis` specialization for a factory.
-pub type FactoryGenesis<F> = <F as ServiceFactory>::Genesis;
-
-/// `Block` type for a factory.
-pub type FactoryBlock<F> = <F as ServiceFactory>::Block;
-
-/// `Extrinsic` type for a factory.
-pub type FactoryExtrinsic<F> = <<F as ServiceFactory>::Block as BlockT>::Extrinsic;
-
-/// `Number` type for a factory.
-pub type FactoryBlockNumber<F> = <<FactoryBlock<F> as BlockT>::Header as HeaderT>::Number;
-
-/// Full `Configuration` type for a factory.
-pub type FactoryFullConfiguration<F> = Configuration<<F as ServiceFactory>::Configuration, FactoryGenesis<F>>;
-
-/// Client type for `Components`.
-pub type ComponentClient<C> = Client<
-	<C as Components>::Backend,
-	<C as Components>::Executor,
-	FactoryBlock<<C as Components>::Factory>,
-	<C as Components>::RuntimeApi,
->;
-
-/// A offchain workers storage backend type.
-pub type ComponentOffchainStorage<C> = <
-	<C as Components>::Backend as client::backend::Backend<ComponentBlock<C>, Blake2Hasher>
->::OffchainStorage;
-
-/// Block type for `Components`
-pub type ComponentBlock<C> = <<C as Components>::Factory as ServiceFactory>::Block;
-
-/// Extrinsic hash type for `Components`
-pub type ComponentExHash<C> = <<C as Components>::TransactionPoolApi as txpool::ChainApi>::Hash;
-
-/// Extrinsic type.
-pub type ComponentExtrinsic<C> = <ComponentBlock<C> as BlockT>::Extrinsic;
-
-/// Extrinsic pool API type for `Components`.
-pub type PoolApi<C> = <C as Components>::TransactionPoolApi;
-
-/// A set of traits for the runtime genesis config.
-pub trait RuntimeGenesis: Serialize + DeserializeOwned + BuildStorage {}
-impl<T: Serialize + DeserializeOwned + BuildStorage> RuntimeGenesis for T {}
-
-/// A transport-agnostic handler of the RPC queries.
-pub type RpcHandler = rpc_servers::RpcHandler<rpc::Metadata>;
-
-/// Something that can create and store initial session keys from given seeds.
-pub trait InitialSessionKeys<C: Components> {
-	/// Generate the initial session keys for the given seeds and store them in
-	/// an internal keystore.
-	fn generate_initial_session_keys(
-		client: Arc<ComponentClient<C>>,
-		seeds: Vec<String>,
-	) -> error::Result<()>;
-}
-
-impl<C: Components> InitialSessionKeys<Self> for C where
-	ComponentClient<C>: ProvideRuntimeApi,
-	<ComponentClient<C> as ProvideRuntimeApi>::Api: session::SessionKeys<ComponentBlock<C>>,
-{
-	fn generate_initial_session_keys(
-		client: Arc<ComponentClient<C>>,
-		seeds: Vec<String>,
-	) -> error::Result<()> {
-		session::generate_initial_session_keys(client, seeds).map_err(Into::into)
-	}
-}
-
-/// Something that can start the RPC service.
-pub trait StartRpc<C: Components> {
-	fn start_rpc(
-		client: Arc<ComponentClient<C>>,
-		system_send_back: mpsc::UnboundedSender<rpc::system::Request<ComponentBlock<C>>>,
-		system_info: SystemInfo,
-		task_executor: TaskExecutor,
-		transaction_pool: Arc<TransactionPool<C::TransactionPoolApi>>,
-		rpc_extensions: impl rpc::RpcExtension<rpc::Metadata>,
-		keystore: KeyStorePtr,
-	) -> RpcHandler;
-}
-
-impl<C: Components> StartRpc<C> for C where
-	ComponentClient<C>: ProvideRuntimeApi,
-	<ComponentClient<C> as ProvideRuntimeApi>::Api:
-		runtime_api::Metadata<ComponentBlock<C>> + session::SessionKeys<ComponentBlock<C>>,
-{
-	fn start_rpc(
-		client: Arc<ComponentClient<C>>,
-		system_send_back: mpsc::UnboundedSender<rpc::system::Request<ComponentBlock<C>>>,
-		rpc_system_info: SystemInfo,
-		task_executor: TaskExecutor,
-		transaction_pool: Arc<TransactionPool<C::TransactionPoolApi>>,
-		rpc_extensions: impl rpc::RpcExtension<rpc::Metadata>,
-		keystore: KeyStorePtr,
-	) -> RpcHandler {
-		use rpc::{chain, state, author, system};
-		let subscriptions = rpc::Subscriptions::new(task_executor.clone());
-		let chain = chain::Chain::new(client.clone(), subscriptions.clone());
-		let state = state::State::new(client.clone(), subscriptions.clone());
-		let author = rpc::author::Author::new(
-			client,
-			transaction_pool,
-			subscriptions,
-			keystore,
-		);
-		let system = system::System::new(rpc_system_info, system_send_back);
-
-		rpc_servers::rpc_handler((
-			state::StateApi::to_delegate(state),
-			chain::ChainApi::to_delegate(chain),
-			author::AuthorApi::to_delegate(author),
-			system::SystemApi::to_delegate(system),
-			rpc_extensions,
-		))
-	}
-}
-
-/// Something that can maintain transaction pool on every imported block.
-pub trait MaintainTransactionPool<C: Components> {
-	fn maintain_transaction_pool(
-		id: &BlockId<ComponentBlock<C>>,
-		client: &ComponentClient<C>,
-		transaction_pool: &TransactionPool<C::TransactionPoolApi>,
-	) -> error::Result<()>;
-}
-
-fn maintain_transaction_pool<Api, Backend, Block, Executor, PoolApi>(
-	id: &BlockId<Block>,
-	client: &Client<Backend, Executor, Block, Api>,
-	transaction_pool: &TransactionPool<PoolApi>,
-) -> error::Result<()> where
-	Block: BlockT<Hash = <Blake2Hasher as primitives::Hasher>::Out>,
-	Backend: client::backend::Backend<Block, Blake2Hasher>,
-	Client<Backend, Executor, Block, Api>: ProvideRuntimeApi,
-	<Client<Backend, Executor, Block, Api> as ProvideRuntimeApi>::Api: runtime_api::TaggedTransactionQueue<Block>,
-	Executor: client::CallExecutor<Block, Blake2Hasher>,
-	PoolApi: txpool::ChainApi<Hash = Block::Hash, Block = Block>,
-{
-	// Avoid calling into runtime if there is nothing to prune from the pool anyway.
-	if transaction_pool.status().is_empty() {
-		return Ok(())
-	}
-
-	if let Some(block) = client.block(id)? {
-		let parent_id = BlockId::hash(*block.block.header().parent_hash());
-		let extrinsics = block.block.extrinsics();
-		transaction_pool.prune(id, &parent_id, extrinsics).map_err(|e| format!("{:?}", e))?;
-	}
-
-	Ok(())
-}
-
-impl<C: Components> MaintainTransactionPool<Self> for C where
-	ComponentClient<C>: ProvideRuntimeApi,
-	<ComponentClient<C> as ProvideRuntimeApi>::Api: runtime_api::TaggedTransactionQueue<ComponentBlock<C>>,
-{
-	fn maintain_transaction_pool(
-		id: &BlockId<ComponentBlock<C>>,
-		client: &ComponentClient<C>,
-		transaction_pool: &TransactionPool<C::TransactionPoolApi>,
-	) -> error::Result<()> {
-		maintain_transaction_pool(id, client, transaction_pool)
-	}
-}
-
-pub trait OffchainWorker<C: Components> {
-	fn offchain_workers(
-		number: &FactoryBlockNumber<C::Factory>,
-		offchain: &offchain::OffchainWorkers<
-			ComponentClient<C>,
-			ComponentOffchainStorage<C>,
-			ComponentBlock<C>
-		>,
-		pool: &Arc<TransactionPool<C::TransactionPoolApi>>,
-		network_state: &Arc<dyn NetworkStateInfo + Send + Sync>,
-		is_validator: bool,
-	) -> error::Result<Box<dyn Future<Item = (), Error = ()> + Send>>;
-}
-
-impl<C: Components> OffchainWorker<Self> for C where
-	ComponentClient<C>: ProvideRuntimeApi,
-	<ComponentClient<C> as ProvideRuntimeApi>::Api: offchain::OffchainWorkerApi<ComponentBlock<C>>,
-{
-	fn offchain_workers(
-		number: &FactoryBlockNumber<C::Factory>,
-		offchain: &offchain::OffchainWorkers<
-			ComponentClient<C>,
-			ComponentOffchainStorage<C>,
-			ComponentBlock<C>
-		>,
-		pool: &Arc<TransactionPool<C::TransactionPoolApi>>,
-		network_state: &Arc<dyn NetworkStateInfo + Send + Sync>,
-		is_validator: bool,
-	) -> error::Result<Box<dyn Future<Item = (), Error = ()> + Send>> {
-		let future = offchain.on_block_imported(number, pool, network_state.clone(), is_validator)
-			.map(|()| Ok(()));
-		Ok(Box::new(Compat::new(future)))
-	}
-}
-
-/// The super trait that combines all required traits a `Service` needs to implement.
-pub trait ServiceTrait<C: Components>:
-	Deref<Target = Service<C>>
-	+ Send
-	+ 'static
-	+ StartRpc<C>
-	+ MaintainTransactionPool<C>
-	+ OffchainWorker<C>
-	+ InitialSessionKeys<C>
-{}
-impl<C: Components, T> ServiceTrait<C> for T where
-	T: Deref<Target = Service<C>>
-	+ Send
-	+ 'static
-	+ StartRpc<C>
-	+ MaintainTransactionPool<C>
-	+ OffchainWorker<C>
-	+ InitialSessionKeys<C>
-{}
-
-/// Alias for a an implementation of `futures::future::Executor`.
-pub type TaskExecutor = Arc<dyn Executor<Box<dyn Future<Item = (), Error = ()> + Send>> + Send + Sync>;
-
-/// A collection of types and methods to build a service on top of the substrate service.
-pub trait ServiceFactory: 'static + Sized {
-	/// Block type.
-	type Block: BlockT<Hash=H256>;
-	/// The type that implements the runtime API.
-	type RuntimeApi: Send + Sync;
-	/// Network protocol extensions.
-	type NetworkProtocol: network::specialization::NetworkSpecialization<Self::Block>;
-	/// Chain runtime.
-	type RuntimeDispatch: NativeExecutionDispatch + Send + Sync + 'static;
-	/// Extrinsic pool backend type for the full client.
-	type FullTransactionPoolApi: txpool::ChainApi<Hash = <Self::Block as BlockT>::Hash, Block = Self::Block> + Send + 'static;
-	/// Extrinsic pool backend type for the light client.
-	type LightTransactionPoolApi: txpool::ChainApi<Hash = <Self::Block as BlockT>::Hash, Block = Self::Block> + 'static;
-	/// Genesis configuration for the runtime.
-	type Genesis: RuntimeGenesis;
-	/// Other configuration for service members.
-	type Configuration: Default;
-	/// RPC initialisation.
-	type RpcExtensions: rpc::RpcExtension<rpc::Metadata>;
-	/// Extended full service type.
-	type FullService: ServiceTrait<FullComponents<Self>>;
-	/// Extended light service type.
-	type LightService: ServiceTrait<LightComponents<Self>>;
-	/// ImportQueue for full client
-	type FullImportQueue: ImportQueue<Self::Block> + 'static;
-	/// ImportQueue for light clients
-	type LightImportQueue: ImportQueue<Self::Block> + 'static;
-	/// The Fork Choice Strategy for the chain
-	type SelectChain: SelectChain<Self::Block> + 'static;
-
-	//TODO: replace these with a constructor trait. that TransactionPool implements. (#1242)
-	/// Extrinsic pool constructor for the full client.
-	fn build_full_transaction_pool(config: TransactionPoolOptions, client: Arc<FullClient<Self>>)
-		-> Result<TransactionPool<Self::FullTransactionPoolApi>, error::Error>;
-	/// Extrinsic pool constructor for the light client.
-	fn build_light_transaction_pool(config: TransactionPoolOptions, client: Arc<LightClient<Self>>)
-		-> Result<TransactionPool<Self::LightTransactionPoolApi>, error::Error>;
-
-	/// Build network protocol.
-	fn build_network_protocol(config: &FactoryFullConfiguration<Self>)
-		-> Result<Self::NetworkProtocol, error::Error>;
-
-	/// Build finality proof provider for serving network requests on full node.
-	fn build_finality_proof_provider(
-		client: Arc<FullClient<Self>>
-	) -> Result<Option<Arc<dyn FinalityProofProvider<Self::Block>>>, error::Error>;
-
-	/// Build the Fork Choice algorithm for full client
-	fn build_select_chain(
-		config: &mut FactoryFullConfiguration<Self>,
-		client: Arc<FullClient<Self>>,
-	) -> Result<Self::SelectChain, error::Error>;
-
-	/// Build full service.
-	fn new_full(config: FactoryFullConfiguration<Self>)
-		-> Result<Self::FullService, error::Error>;
-	/// Build light service.
-	fn new_light(config: FactoryFullConfiguration<Self>)
-		-> Result<Self::LightService, error::Error>;
-
-	/// ImportQueue for a full client
-	fn build_full_import_queue(
-		config: &mut FactoryFullConfiguration<Self>,
-		_client: Arc<FullClient<Self>>,
-		_select_chain: Self::SelectChain,
-		_transaction_pool: Option<Arc<TransactionPool<Self::FullTransactionPoolApi>>>,
-	) -> Result<Self::FullImportQueue, error::Error> {
-		if let Some(name) = config.chain_spec.consensus_engine() {
-			match name {
-				_ => Err(format!("Chain Specification defines unknown consensus engine '{}'", name).into())
-			}
-
-		} else {
-			Err("Chain Specification doesn't contain any consensus_engine name".into())
-		}
-	}
-
-	/// ImportQueue for a light client
-	fn build_light_import_queue(
-		config: &mut FactoryFullConfiguration<Self>,
-		_client: Arc<LightClient<Self>>
-	) -> Result<(Self::LightImportQueue, BoxFinalityProofRequestBuilder<Self::Block>), error::Error> {
-		if let Some(name) = config.chain_spec.consensus_engine() {
-			match name {
-				_ => Err(format!("Chain Specification defines unknown consensus engine '{}'", name).into())
-			}
-
-		} else {
-			Err("Chain Specification doesn't contain any consensus_engine name".into())
-		}
-	}
-
-	/// Create custom RPC method handlers for full node.
-	fn build_full_rpc_extensions(
-		client: Arc<FullClient<Self>>,
-		transaction_pool: Arc<TransactionPool<Self::FullTransactionPoolApi>>,
-	) -> Self::RpcExtensions;
-
-	/// Create custom RPC method handlers for light node.
-	fn build_light_rpc_extensions(
-		client: Arc<LightClient<Self>>,
-		transaction_pool: Arc<TransactionPool<Self::LightTransactionPoolApi>>,
-	) -> Self::RpcExtensions;
-}
-
-/// A collection of types and function to generalize over full / light client type.
-pub trait Components: Sized + 'static {
-	/// Associated service factory.
-	type Factory: ServiceFactory;
-	/// Client backend.
-	type Backend: 'static + client::backend::Backend<FactoryBlock<Self::Factory>, Blake2Hasher>;
-	/// Client executor.
-	type Executor: 'static + client::CallExecutor<FactoryBlock<Self::Factory>, Blake2Hasher> + Send + Sync + Clone;
-	/// The type that implements the runtime API.
-	type RuntimeApi: Send + Sync;
-	/// The type that can start all runtime-dependent services.
-	type RuntimeServices: ServiceTrait<Self>;
-	/// The type that can extend the RPC methods.
-	type RpcExtensions: rpc::RpcExtension<rpc::Metadata>;
-	// TODO: Traitify transaction pool and allow people to implement their own. (#1242)
-	/// Extrinsic pool type.
-	type TransactionPoolApi: 'static + txpool::ChainApi<
-		Hash = <FactoryBlock<Self::Factory> as BlockT>::Hash,
-		Block = FactoryBlock<Self::Factory>
-	>;
-	/// Our Import Queue
-	type ImportQueue: ImportQueue<FactoryBlock<Self::Factory>> + 'static;
-	/// The Fork Choice Strategy for the chain
-	type SelectChain: SelectChain<FactoryBlock<Self::Factory>>;
-
-	/// Create client.
-	fn build_client(
-		config: &FactoryFullConfiguration<Self::Factory>,
-		executor: CodeExecutor<Self::Factory>,
-		keystore: Option<BareCryptoStorePtr>,
-	) -> Result<
-		(
-			Arc<ComponentClient<Self>>,
-			Option<Arc<OnDemand<FactoryBlock<Self::Factory>>>>
-		),
-		error::Error
-	>;
-
-	/// Create extrinsic pool.
-	fn build_transaction_pool(config: TransactionPoolOptions, client: Arc<ComponentClient<Self>>)
-		-> Result<TransactionPool<Self::TransactionPoolApi>, error::Error>;
-
-	/// Build the queue that imports blocks from the network, and optionally a way for the network
-	/// to build requests for proofs of finality.
-	fn build_import_queue(
-		config: &mut FactoryFullConfiguration<Self::Factory>,
-		client: Arc<ComponentClient<Self>>,
-		select_chain: Option<Self::SelectChain>,
-		_transaction_pool: Option<Arc<TransactionPool<Self::TransactionPoolApi>>>,
-	) -> Result<(Self::ImportQueue, Option<BoxFinalityProofRequestBuilder<FactoryBlock<Self::Factory>>>), error::Error>;
-
-	/// Finality proof provider for serving network requests.
-	fn build_finality_proof_provider(
-		client: Arc<ComponentClient<Self>>
-	) -> Result<Option<Arc<dyn FinalityProofProvider<<Self::Factory as ServiceFactory>::Block>>>, error::Error>;
-
-	/// Build fork choice selector
-	fn build_select_chain(
-		config: &mut FactoryFullConfiguration<Self::Factory>,
-		client: Arc<ComponentClient<Self>>
-	) -> Result<Option<Self::SelectChain>, error::Error>;
-
-	/// Build RPC extensions
-	fn build_rpc_extensions(
-		client: Arc<ComponentClient<Self>>,
-		transaction_pool: Arc<TransactionPool<Self::TransactionPoolApi>>,
-	) -> Self::RpcExtensions;
-}
-
-/// A struct that implement `Components` for the full client.
-pub struct FullComponents<Factory: ServiceFactory> {
-	service: Service<FullComponents<Factory>>,
-}
-
-impl<Factory: ServiceFactory> FullComponents<Factory> {
-	/// Create new `FullComponents`
-	pub fn new(
-		config: FactoryFullConfiguration<Factory>
-	) -> Result<Self, error::Error> {
-		Ok(
-			Self {
-				service: Service::new(config)?,
-			}
-		)
-	}
-}
-
-impl<Factory: ServiceFactory> Deref for FullComponents<Factory> {
-	type Target = Service<Self>;
-
-	fn deref(&self) -> &Self::Target {
-		&self.service
-	}
-}
-
-impl<Factory: ServiceFactory> DerefMut for FullComponents<Factory> {
-	fn deref_mut(&mut self) -> &mut Service<Self> {
-		&mut self.service
-	}
-}
-
-impl<Factory: ServiceFactory> Future for FullComponents<Factory> {
-	type Item = ();
-	type Error = super::Error;
-
-	fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-		self.service.poll()
-	}
-}
-
-impl<Factory: ServiceFactory> Executor<Box<dyn Future<Item = (), Error = ()> + Send>>
-for FullComponents<Factory> {
-	fn execute(
-		&self,
-		future: Box<dyn Future<Item = (), Error = ()> + Send>
-	) -> Result<(), futures::future::ExecuteError<Box<dyn Future<Item = (), Error = ()> + Send>>> {
-		self.service.execute(future)
-	}
-}
-
-impl<Factory: ServiceFactory> Components for FullComponents<Factory> {
-	type Factory = Factory;
-	type Executor = FullExecutor<Factory>;
-	type Backend = FullBackend<Factory>;
-	type TransactionPoolApi = <Factory as ServiceFactory>::FullTransactionPoolApi;
-	type ImportQueue = Factory::FullImportQueue;
-	type RuntimeApi = Factory::RuntimeApi;
-	type RuntimeServices = Factory::FullService;
-	type RpcExtensions = Factory::RpcExtensions;
-	type SelectChain = Factory::SelectChain;
-
-	fn build_client(
-		config: &FactoryFullConfiguration<Factory>,
-		executor: CodeExecutor<Self::Factory>,
-		keystore: Option<BareCryptoStorePtr>,
-	) -> Result<
-			(Arc<ComponentClient<Self>>, Option<Arc<OnDemand<FactoryBlock<Self::Factory>>>>),
-			error::Error,
-		>
-	{
-		let db_settings = client_db::DatabaseSettings {
-			cache_size: config.database_cache_size.map(|u| u as usize),
-			state_cache_size: config.state_cache_size,
-			state_cache_child_ratio:
-				config.state_cache_child_ratio.map(|v| (v, 100)),
-			path: config.database_path.clone(),
-			pruning: config.pruning.clone(),
-		};
-
-		Ok((
-			Arc::new(
-				client_db::new_client(
-					db_settings,
-					executor,
-					&config.chain_spec,
-					config.execution_strategies.clone(),
-					keystore,
-				)?
-			),
-			None,
-		))
-	}
-
-	fn build_transaction_pool(
-		config: TransactionPoolOptions,
-		client: Arc<ComponentClient<Self>>
-	) -> Result<TransactionPool<Self::TransactionPoolApi>, error::Error> {
-		Factory::build_full_transaction_pool(config, client)
-	}
-
-	fn build_import_queue(
-		config: &mut FactoryFullConfiguration<Self::Factory>,
-		client: Arc<ComponentClient<Self>>,
-		select_chain: Option<Self::SelectChain>,
-		transaction_pool: Option<Arc<TransactionPool<Self::TransactionPoolApi>>>,
-	) -> Result<(Self::ImportQueue, Option<BoxFinalityProofRequestBuilder<FactoryBlock<Self::Factory>>>), error::Error> {
-		let select_chain = select_chain
-			.ok_or(error::Error::SelectChainRequired)?;
-		Factory::build_full_import_queue(config, client, select_chain, transaction_pool)
-			.map(|queue| (queue, None))
-	}
-
-	fn build_select_chain(
-		config: &mut FactoryFullConfiguration<Self::Factory>,
-		client: Arc<ComponentClient<Self>>
-	) -> Result<Option<Self::SelectChain>, error::Error> {
-		Self::Factory::build_select_chain(config, client).map(Some)
-	}
-
-	fn build_finality_proof_provider(
-		client: Arc<ComponentClient<Self>>
-	) -> Result<Option<Arc<dyn FinalityProofProvider<<Self::Factory as ServiceFactory>::Block>>>, error::Error> {
-		Factory::build_finality_proof_provider(client)
-	}
-
-	fn build_rpc_extensions(
-		client: Arc<ComponentClient<Self>>,
-		transaction_pool: Arc<TransactionPool<Self::TransactionPoolApi>>,
-	) -> Self::RpcExtensions {
-		Factory::build_full_rpc_extensions(client, transaction_pool)
-	}
-}
-
-/// A struct that implement `Components` for the light client.
-pub struct LightComponents<Factory: ServiceFactory> {
-	service: Service<LightComponents<Factory>>,
-}
-
-impl<Factory: ServiceFactory> LightComponents<Factory> {
-	/// Create new `LightComponents`
-	pub fn new(
-		config: FactoryFullConfiguration<Factory>,
-	) -> Result<Self, error::Error> {
-		Ok(
-			Self {
-				service: Service::new(config)?,
-			}
-		)
-	}
-}
-
-impl<Factory: ServiceFactory> Deref for LightComponents<Factory> {
-	type Target = Service<Self>;
-
-	fn deref(&self) -> &Self::Target {
-		&self.service
-	}
-}
-
-impl<Factory: ServiceFactory> DerefMut for LightComponents<Factory> {
-	fn deref_mut(&mut self) -> &mut Self::Target {
-		&mut self.service
-	}
-}
-
-impl<Factory: ServiceFactory> Future for LightComponents<Factory> {
-	type Item = ();
-	type Error = super::Error;
-
-	fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-		self.service.poll()
-	}
-}
-
-impl<Factory: ServiceFactory> Executor<Box<dyn Future<Item = (), Error = ()> + Send>>
-for LightComponents<Factory> {
-	fn execute(
-		&self,
-		future: Box<dyn Future<Item = (), Error = ()> + Send>
-	) -> Result<(), futures::future::ExecuteError<Box<dyn Future<Item = (), Error = ()> + Send>>> {
-		self.service.execute(future)
-	}
-}
-
-impl<Factory: ServiceFactory> Components for LightComponents<Factory> {
-	type Factory = Factory;
-	type Executor = LightExecutor<Factory>;
-	type Backend = LightBackend<Factory>;
-	type TransactionPoolApi = <Factory as ServiceFactory>::LightTransactionPoolApi;
-	type ImportQueue = <Factory as ServiceFactory>::LightImportQueue;
-	type RuntimeApi = Factory::RuntimeApi;
-	type RuntimeServices = Factory::LightService;
-	type RpcExtensions = Factory::RpcExtensions;
-	type SelectChain = Factory::SelectChain;
-
-	fn build_client(
-		config: &FactoryFullConfiguration<Factory>,
-		executor: CodeExecutor<Self::Factory>,
-		_: Option<BareCryptoStorePtr>,
-	)
-		-> Result<
-			(
-				Arc<ComponentClient<Self>>,
-				Option<Arc<OnDemand<FactoryBlock<Self::Factory>>>>
-			), error::Error>
-	{
-		let db_settings = client_db::DatabaseSettings {
-			cache_size: None,
-			state_cache_size: config.state_cache_size,
-			state_cache_child_ratio:
-				config.state_cache_child_ratio.map(|v| (v, 100)),
-			path: config.database_path.clone(),
-			pruning: config.pruning.clone(),
-		};
-
-		let db_storage = client_db::light::LightStorage::new(db_settings)?;
-		let light_blockchain = client::light::new_light_blockchain(db_storage);
-		let fetch_checker = Arc::new(
-			client::light::new_fetch_checker(light_blockchain.clone(), executor.clone())
-		);
-		let fetcher = Arc::new(network::OnDemand::new(fetch_checker));
-		let client_backend = client::light::new_light_backend(light_blockchain, fetcher.clone());
-		let client = client::light::new_light(client_backend, fetcher.clone(), &config.chain_spec, executor)?;
-		Ok((Arc::new(client), Some(fetcher)))
-	}
-
-	fn build_transaction_pool(config: TransactionPoolOptions, client: Arc<ComponentClient<Self>>)
-		-> Result<TransactionPool<Self::TransactionPoolApi>, error::Error>
-	{
-		Factory::build_light_transaction_pool(config, client)
-	}
-
-	fn build_import_queue(
-		config: &mut FactoryFullConfiguration<Self::Factory>,
-		client: Arc<ComponentClient<Self>>,
-		_select_chain: Option<Self::SelectChain>,
-		_transaction_pool: Option<Arc<TransactionPool<Self::TransactionPoolApi>>>,
-	) -> Result<(Self::ImportQueue, Option<BoxFinalityProofRequestBuilder<FactoryBlock<Self::Factory>>>), error::Error> {
-		Factory::build_light_import_queue(config, client)
-			.map(|(queue, builder)| (queue, Some(builder)))
-	}
-
-	fn build_finality_proof_provider(
-		_client: Arc<ComponentClient<Self>>
-	) -> Result<Option<Arc<dyn FinalityProofProvider<<Self::Factory as ServiceFactory>::Block>>>, error::Error> {
-		Ok(None)
-	}
-
-	fn build_select_chain(
-		_config: &mut FactoryFullConfiguration<Self::Factory>,
-		_client: Arc<ComponentClient<Self>>
-	) -> Result<Option<Self::SelectChain>, error::Error> {
-		Ok(None)
-	}
-
-	fn build_rpc_extensions(
-		client: Arc<ComponentClient<Self>>,
-		transaction_pool: Arc<TransactionPool<Self::TransactionPoolApi>>,
-	) -> Self::RpcExtensions {
-		Factory::build_light_rpc_extensions(client, transaction_pool)
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-	use consensus_common::BlockOrigin;
-	use substrate_test_runtime_client::{prelude::*, runtime::Transfer};
-
-	#[test]
-	fn should_remove_transactions_from_the_pool() {
-		let (client, longest_chain) = TestClientBuilder::new().build_with_longest_chain();
-		let client = Arc::new(client);
-		let pool = TransactionPool::new(Default::default(), ::transaction_pool::ChainApi::new(client.clone()));
-		let transaction = Transfer {
-			amount: 5,
-			nonce: 0,
-			from: AccountKeyring::Alice.into(),
-			to: Default::default(),
-		}.into_signed_tx();
-		let best = longest_chain.best_chain().unwrap();
-
-		// store the transaction in the pool
-		pool.submit_one(&BlockId::hash(best.hash()), transaction.clone()).unwrap();
-
-		// import the block
-		let mut builder = client.new_block(Default::default()).unwrap();
-		builder.push(transaction.clone()).unwrap();
-		let block = builder.bake().unwrap();
-		let id = BlockId::hash(block.header().hash());
-		client.import(BlockOrigin::Own, block).unwrap();
-
-		// fire notification - this should clean up the queue
-		assert_eq!(pool.status().ready, 1);
-		maintain_transaction_pool(
-			&id,
-			&client,
-			&pool,
-		).unwrap();
-
-		// then
-		assert_eq!(pool.status().ready, 0);
-		assert_eq!(pool.status().future, 0);
-	}
-}

substrate/core/service/src/lib.rs

@@ -19,51 +19,43 @@
 
 #![warn(missing_docs)]
 
-mod components;
 mod chain_spec;
 pub mod config;
+#[macro_use]
 pub mod chain_ops;
 pub mod error;
 
 use std::io;
+use std::marker::PhantomData;
 use std::net::SocketAddr;
 use std::collections::HashMap;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::{Duration, Instant};
+use serde::{Serialize, de::DeserializeOwned};
 use futures::sync::mpsc;
 use parking_lot::Mutex;
 
-use client::{BlockchainEvents, backend::Backend, runtime_api::BlockT};
+use client::{runtime_api::BlockT, Client};
 use exit_future::Signal;
 use futures::prelude::*;
 use futures03::stream::{StreamExt as _, TryStreamExt as _};
-use keystore::Store as Keystore;
-use network::{NetworkState, NetworkStateInfo};
-use log::{log, info, warn, debug, error, Level};
+use network::{NetworkService, NetworkState, specialization::NetworkSpecialization};
+use log::{log, warn, debug, error, Level};
 use codec::{Encode, Decode};
+use primitives::{Blake2Hasher, H256};
+use sr_primitives::BuildStorage;
 use sr_primitives::generic::BlockId;
-use sr_primitives::traits::{Header, NumberFor, SaturatedConversion};
-use substrate_executor::NativeExecutor;
-use sysinfo::{get_current_pid, ProcessExt, System, SystemExt};
-use tel::{telemetry, SUBSTRATE_INFO};
+use sr_primitives::traits::NumberFor;
 
 pub use self::error::Error;
+pub use self::builder::{ServiceBuilder, ServiceBuilderExport, ServiceBuilderImport, ServiceBuilderRevert};
 pub use config::{Configuration, Roles, PruningMode};
 pub use chain_spec::{ChainSpec, Properties};
 pub use transaction_pool::txpool::{
 	self, Pool as TransactionPool, Options as TransactionPoolOptions, ChainApi, IntoPoolError
 };
 pub use client::FinalityNotifications;
-
-pub use components::{
-	ServiceFactory, FullBackend, FullExecutor, LightBackend,
-	LightExecutor, Components, PoolApi, ComponentClient, ComponentOffchainStorage,
-	ComponentBlock, FullClient, LightClient, FullComponents, LightComponents,
-	CodeExecutor, NetworkService, FactoryChainSpec, FactoryBlock,
-	FactoryFullConfiguration, RuntimeGenesis, FactoryGenesis,
-	ComponentExHash, ComponentExtrinsic, FactoryExtrinsic, InitialSessionKeys,
-};
-use components::{StartRpc, MaintainTransactionPool, OffchainWorker};
+pub use rpc::Metadata as RpcMetadata;
 #[doc(hidden)]
 pub use std::{ops::Deref, result::Result, sync::Arc};
 #[doc(hidden)]
@@ -74,15 +66,15 @@ pub use futures::future::Executor;
 const DEFAULT_PROTOCOL_ID: &str = "sup";
 
 /// Substrate service.
-pub struct Service<Components: components::Components> {
-	client: Arc<ComponentClient<Components>>,
-	select_chain: Option<Components::SelectChain>,
-	network: Arc<components::NetworkService<Components>>,
+pub struct NewService<TCfg, TBl, TCl, TSc, TNetStatus, TNet, TTxPool, TOc> {
+	client: Arc<TCl>,
+	select_chain: Option<TSc>,
+	network: Arc<TNet>,
 	/// Sinks to propagate network status updates.
 	network_status_sinks: Arc<Mutex<Vec<mpsc::UnboundedSender<(
-		NetworkStatus<ComponentBlock<Components>>, NetworkState
+		TNetStatus, NetworkState
 	)>>>>,
-	transaction_pool: Arc<TransactionPool<Components::TransactionPoolApi>>,
+	transaction_pool: Arc<TTxPool>,
 	/// A future that resolves when the service has exited, this is useful to
 	/// make sure any internally spawned futures stop when the service does.
 	exit: exit_future::Exit,
@@ -100,31 +92,22 @@ pub struct Service<Components: components::Components> {
 	/// The elements must then be polled manually.
 	to_poll: Vec<Box<dyn Future<Item = (), Error = ()> + Send>>,
 	/// Configuration of this Service
-	config: FactoryFullConfiguration<Components::Factory>,
-	rpc_handlers: components::RpcHandler,
+	config: TCfg,
+	rpc_handlers: rpc_servers::RpcHandler<rpc::Metadata>,
 	_rpc: Box<dyn std::any::Any + Send + Sync>,
 	_telemetry: Option<tel::Telemetry>,
 	_telemetry_on_connect_sinks: Arc<Mutex<Vec<mpsc::UnboundedSender<()>>>>,
-	_offchain_workers: Option<Arc<offchain::OffchainWorkers<
-		ComponentClient<Components>,
-		ComponentOffchainStorage<Components>,
-		ComponentBlock<Components>>
-	>>,
+	_offchain_workers: Option<Arc<TOc>>,
 	keystore: keystore::KeyStorePtr,
+	marker: PhantomData<TBl>,
 }
 
-/// Creates bare client without any networking.
-pub fn new_client<Factory: components::ServiceFactory>(
-	config: &FactoryFullConfiguration<Factory>,
-) -> Result<Arc<ComponentClient<components::FullComponents<Factory>>>, error::Error> {
-	let executor = NativeExecutor::new(config.default_heap_pages);
+/// A set of traits for the runtime genesis config.
+pub trait RuntimeGenesis: Serialize + DeserializeOwned + BuildStorage {}
+impl<T: Serialize + DeserializeOwned + BuildStorage> RuntimeGenesis for T {}
 
-	components::FullComponents::<Factory>::build_client(
-		config,
-		executor,
-		None,
-	).map(|r| r.0)
-}
+/// Alias for a an implementation of `futures::future::Executor`.
+pub type TaskExecutor = Arc<dyn Executor<Box<dyn Future<Item = (), Error = ()> + Send>> + Send + Sync>;
 
 /// An handle for spawning tasks in the service.
 #[derive(Clone)]
@@ -146,59 +129,38 @@ impl Executor<Box<dyn Future<Item = (), Error = ()> + Send>> for SpawnTaskHandle
 	}
 }
 
-/// Stream of events for connection established to a telemetry server.
-pub type TelemetryOnConnectNotifications = mpsc::UnboundedReceiver<()>;
-
-/// Used to hook on telemetry connection established events.
-pub struct TelemetryOnConnect {
-	/// Event stream.
-	pub telemetry_connection_sinks: TelemetryOnConnectNotifications,
-}
-
-impl<Components: components::Components> Service<Components> {
-	/// Creates a new service.
-	pub fn new(
-		mut config: FactoryFullConfiguration<Components::Factory>,
-	) -> Result<Self, error::Error> {
+macro_rules! new_impl {
+	(
+		$block:ty,
+		$config:ident,
+		$build_components:expr,
+		$maintain_transaction_pool:expr,
+		$offchain_workers:expr,
+		$start_rpc:expr,
+	) => {{
 		let (signal, exit) = exit_future::signal();
 
 		// List of asynchronous tasks to spawn. We collect them, then spawn them all at once.
 		let (to_spawn_tx, to_spawn_rx) =
 			mpsc::unbounded::<Box<dyn Future<Item = (), Error = ()> + Send>>();
 
-		// Create client
-		let executor = NativeExecutor::new(config.default_heap_pages);
-
-		let keystore = Keystore::open(config.keystore_path.clone(), config.keystore_password.clone())?;
-
-		let (client, on_demand) = Components::build_client(&config, executor, Some(keystore.clone()))?;
-		let select_chain = Components::build_select_chain(&mut config, client.clone())?;
-
-		let transaction_pool = Arc::new(
-			Components::build_transaction_pool(config.transaction_pool.clone(), client.clone())?
-		);
-		let transaction_pool_adapter = Arc::new(TransactionPoolAdapter {
-			imports_external_transactions: !config.roles.is_light(),
-			pool: transaction_pool.clone(),
-			client: client.clone(),
-		});
-
-		let (import_queue, finality_proof_request_builder) = Components::build_import_queue(
-			&mut config,
-			client.clone(),
-			select_chain.clone(),
-			Some(transaction_pool.clone()),
-		)?;
+		// Create all the components.
+		let (
+			client,
+			on_demand,
+			keystore,
+			select_chain,
+			import_queue,
+			finality_proof_request_builder,
+			finality_proof_provider,
+			network_protocol,
+			transaction_pool,
+			rpc_extensions
+		) = $build_components(&mut $config)?;
 		let import_queue = Box::new(import_queue);
-		let finality_proof_provider = Components::build_finality_proof_provider(client.clone())?;
 		let chain_info = client.info().chain;
 
-		Components::RuntimeServices::generate_initial_session_keys(
-			client.clone(),
-			config.dev_key_seed.clone().map(|s| vec![s]).unwrap_or_default(),
-		)?;
-
-		let version = config.full_version();
+		let version = $config.full_version();
 		info!("Highest known block at #{}", chain_info.best_number);
 		telemetry!(
 			SUBSTRATE_INFO;
@@ -207,10 +169,14 @@ impl<Components: components::Components> Service<Components> {
 			"best" => ?chain_info.best_hash
 		);
 
-		let network_protocol = <Components::Factory>::build_network_protocol(&config)?;
+		let transaction_pool_adapter = Arc::new(TransactionPoolAdapter {
+			imports_external_transactions: !$config.roles.is_light(),
+			pool: transaction_pool.clone(),
+			client: client.clone(),
+		});
 
 		let protocol_id = {
-			let protocol_id_full = match config.chain_spec.protocol_id() {
+			let protocol_id_full = match $config.chain_spec.protocol_id() {
 				Some(pid) => pid,
 				None => {
 					warn!("Using default protocol ID {:?} because none is configured in the \
@@ -223,8 +189,8 @@ impl<Components: components::Components> Service<Components> {
 		};
 
 		let network_params = network::config::Params {
-			roles: config.roles,
-			network_config: config.network.clone(),
+			roles: $config.roles,
+			network_config: $config.network.clone(),
 			chain: client.clone(),
 			finality_proof_provider,
 			finality_proof_request_builder,
@@ -242,7 +208,7 @@ impl<Components: components::Components> Service<Components> {
 
 		#[allow(deprecated)]
 		let offchain_storage = client.backend().offchain_storage();
-		let offchain_workers = match (config.offchain_worker, offchain_storage) {
+		let offchain_workers = match ($config.offchain_worker, offchain_storage) {
 			(true, Some(db)) => {
 				Some(Arc::new(offchain::OffchainWorkers::new(client.clone(), db)))
 			},
@@ -260,23 +226,25 @@ impl<Components: components::Components> Service<Components> {
 			let offchain = offchain_workers.as_ref().map(Arc::downgrade);
 			let to_spawn_tx_ = to_spawn_tx.clone();
 			let network_state_info: Arc<dyn NetworkStateInfo + Send + Sync> = network.clone();
-			let is_validator = config.roles.is_authority();
+			let is_validator = $config.roles.is_authority();
 
 			let events = client.import_notification_stream()
 				.map(|v| Ok::<_, ()>(v)).compat()
 				.for_each(move |notification| {
 					let number = *notification.header.number();
+					let txpool = txpool.upgrade();
 
-					if let (Some(txpool), Some(client)) = (txpool.upgrade(), wclient.upgrade()) {
-						Components::RuntimeServices::maintain_transaction_pool(
+					if let (Some(txpool), Some(client)) = (txpool.as_ref(), wclient.upgrade()) {
+						$maintain_transaction_pool(
 							&BlockId::hash(notification.hash),
 							&*client,
 							&*txpool,
 						).map_err(|e| warn!("Pool error processing new block: {:?}", e))?;
 					}
 
-					if let (Some(txpool), Some(offchain)) = (txpool.upgrade(), offchain.as_ref().and_then(|o| o.upgrade())) {
-						let future = Components::RuntimeServices::offchain_workers(
+					let offchain = offchain.as_ref().and_then(|o| o.upgrade());
+					if let (Some(txpool), Some(offchain)) = (txpool, offchain) {
+						let future = $offchain_workers(
 							&number,
 							&offchain,
 							&txpool,
@@ -321,7 +289,7 @@ impl<Components: components::Components> Service<Components> {
 		let client_ = client.clone();
 		let mut sys = System::new();
 		let self_pid = get_current_pid().ok();
-		let (netstat_tx, netstat_rx) = mpsc::unbounded::<(NetworkStatus<ComponentBlock<Components>>, NetworkState)>();
+		let (netstat_tx, netstat_rx) = mpsc::unbounded::<(NetworkStatus<_>, NetworkState)>();
 		network_status_sinks.lock().push(netstat_tx);
 		let tel_task = netstat_rx.for_each(move |(net_status, network_state)| {
 			let info = client_.info();
@@ -374,23 +342,23 @@ impl<Components: components::Components> Service<Components> {
 		let (system_rpc_tx, system_rpc_rx) = futures03::channel::mpsc::unbounded();
 		let gen_handler = || {
 			let system_info = rpc::system::SystemInfo {
-				chain_name: config.chain_spec.name().into(),
-				impl_name: config.impl_name.into(),
-				impl_version: config.impl_version.into(),
-				properties: config.chain_spec.properties(),
+				chain_name: $config.chain_spec.name().into(),
+				impl_name: $config.impl_name.into(),
+				impl_version: $config.impl_version.into(),
+				properties: $config.chain_spec.properties(),
 			};
-			Components::RuntimeServices::start_rpc(
+			$start_rpc(
 				client.clone(),
 				system_rpc_tx.clone(),
 				system_info.clone(),
 				Arc::new(SpawnTaskHandle { sender: to_spawn_tx.clone() }),
 				transaction_pool.clone(),
-				Components::build_rpc_extensions(client.clone(), transaction_pool.clone()),
+				rpc_extensions.clone(),
 				keystore.clone(),
 			)
 		};
 		let rpc_handlers = gen_handler();
-		let rpc = start_rpc_servers(&config, gen_handler)?;
+		let rpc = start_rpc_servers(&$config, gen_handler)?;
 
 		let _ = to_spawn_tx.unbounded_send(Box::new(build_network_future(
 			network_mut,
@@ -406,17 +374,17 @@ impl<Components: components::Components> Service<Components> {
 		let telemetry_connection_sinks: Arc<Mutex<Vec<mpsc::UnboundedSender<()>>>> = Default::default();
 
 		// Telemetry
-		let telemetry = config.telemetry_endpoints.clone().map(|endpoints| {
-			let is_authority = config.roles.is_authority();
+		let telemetry = $config.telemetry_endpoints.clone().map(|endpoints| {
+			let is_authority = $config.roles.is_authority();
 			let network_id = network.local_peer_id().to_base58();
-			let name = config.name.clone();
-			let impl_name = config.impl_name.to_owned();
+			let name = $config.name.clone();
+			let impl_name = $config.impl_name.to_owned();
 			let version = version.clone();
-			let chain_name = config.chain_spec.name().to_owned();
+			let chain_name = $config.chain_spec.name().to_owned();
 			let telemetry_connection_sinks_ = telemetry_connection_sinks.clone();
 			let telemetry = tel::init_telemetry(tel::TelemetryConfig {
 				endpoints,
-				wasm_external_transport: config.telemetry_external_transport.take(),
+				wasm_external_transport: $config.telemetry_external_transport.take(),
 			});
 			let future = telemetry.clone()
 				.map(|ev| Ok::<_, ()>(ev))
@@ -446,7 +414,7 @@ impl<Components: components::Components> Service<Components> {
 			telemetry
 		});
 
-		Ok(Service {
+		Ok(NewService {
 			client,
 			network,
 			network_status_sinks,
@@ -458,71 +426,65 @@ impl<Components: components::Components> Service<Components> {
 			to_spawn_tx,
 			to_spawn_rx,
 			to_poll: Vec::new(),
-			config,
+			$config,
 			rpc_handlers,
 			_rpc: rpc,
 			_telemetry: telemetry,
 			_offchain_workers: offchain_workers,
 			_telemetry_on_connect_sinks: telemetry_connection_sinks.clone(),
 			keystore,
+			marker: PhantomData::<$block>,
 		})
-	}
+	}}
+}
 
-	/// Returns a reference to the config passed at initialization.
-	pub fn config(&self) -> &FactoryFullConfiguration<Components::Factory> {
-		&self.config
-	}
+mod builder;
 
-	/// Returns a reference to the config passed at initialization.
-	///
-	/// > **Note**: This method is currently necessary because we extract some elements from the
-	/// >			configuration at the end of the service initialization. It is intended to be
-	/// >			removed.
-	pub fn config_mut(&mut self) -> &mut FactoryFullConfiguration<Components::Factory> {
-		&mut self.config
-	}
+/// Abstraction over a Substrate service.
+pub trait AbstractService: 'static + Future<Item = (), Error = Error> +
+	Executor<Box<dyn Future<Item = (), Error = ()> + Send>> + Send {
+	/// Type of block of this chain.
+	type Block: BlockT<Hash = H256>;
+	/// Backend storage for the client.
+	type Backend: 'static + client::backend::Backend<Self::Block, Blake2Hasher>;
+	/// How to execute calls towards the runtime.
+	type CallExecutor: 'static + client::CallExecutor<Self::Block, Blake2Hasher> + Send + Sync + Clone;
+	/// API that the runtime provides.
+	type RuntimeApi: Send + Sync;
+	/// Configuration struct of the service.
+	type Config;
+	/// Chain selection algorithm.
+	type SelectChain;
+	/// API of the transaction pool.
+	type TransactionPoolApi: ChainApi<Block = Self::Block>;
+	/// Network specialization.
+	type NetworkSpecialization: NetworkSpecialization<Self::Block>;
 
 	/// Get event stream for telemetry connection established events.
-	pub fn telemetry_on_connect_stream(&self) -> TelemetryOnConnectNotifications {
-		let (sink, stream) = mpsc::unbounded();
-		self._telemetry_on_connect_sinks.lock().push(sink);
-		stream
-	}
+	fn telemetry_on_connect_stream(&self) -> mpsc::UnboundedReceiver<()>;
 
-	/// Return a shared instance of Telemetry (if enabled)
-	pub fn telemetry(&self) -> Option<tel::Telemetry> {
-		self._telemetry.as_ref().map(|t| t.clone())
-	}
+	/// Returns the configuration passed on construction.
+	fn config(&self) -> &Self::Config;
 
-	/// Returns the keystore instance.
-	pub fn keystore(&self) -> keystore::KeyStorePtr {
-		self.keystore.clone()
-	}
+	/// Returns the configuration passed on construction.
+	fn config_mut(&mut self) -> &mut Self::Config;
+
+	/// return a shared instance of Telemetry (if enabled)
+	fn telemetry(&self) -> Option<tel::Telemetry>;
 
 	/// Spawns a task in the background that runs the future passed as parameter.
-	pub fn spawn_task(&self, task: impl Future<Item = (), Error = ()> + Send + 'static) {
-		let _ = self.to_spawn_tx.unbounded_send(Box::new(task));
-	}
+	fn spawn_task(&self, task: impl Future<Item = (), Error = ()> + Send + 'static);
 
 	/// Spawns a task in the background that runs the future passed as
 	/// parameter. The given task is considered essential, i.e. if it errors we
 	/// trigger a service exit.
-	pub fn spawn_essential_task(&self, task: impl Future<Item = (), Error = ()> + Send + 'static) {
-		let essential_failed = self.essential_failed.clone();
-		let essential_task = Box::new(task.map_err(move |_| {
-			error!("Essential task failed. Shutting down service.");
-			essential_failed.store(true, Ordering::Relaxed);
-		}));
-
-		let _ = self.to_spawn_tx.unbounded_send(essential_task);
-	}
+	fn spawn_essential_task(&self, task: impl Future<Item = (), Error = ()> + Send + 'static);
 
 	/// Returns a handle for spawning tasks.
-	pub fn spawn_task_handle(&self) -> SpawnTaskHandle {
-		SpawnTaskHandle {
-			sender: self.to_spawn_tx.clone(),
-		}
-	}
+	fn spawn_task_handle(&self) -> SpawnTaskHandle;
+
+	/// Returns the keystore that stores keys.
+	fn keystore(&self) -> keystore::KeyStorePtr;
 
 	/// Starts an RPC query.
 	///
@@ -533,46 +495,124 @@ impl<Components: components::Components> Service<Components> {
 	///
 	/// If the request subscribes you to events, the `Sender` in the `RpcSession` object is used to
 	/// send back spontaneous events.
-	pub fn rpc_query(&self, mem: &RpcSession, request: &str)
-		-> impl Future<Item = Option<String>, Error = ()>
-	{
-		self.rpc_handlers.handle_request(request, mem.metadata.clone())
-	}
+	fn rpc_query(&self, mem: &RpcSession, request: &str) -> Box<dyn Future<Item = Option<String>, Error = ()> + Send>;
 
 	/// Get shared client instance.
-	pub fn client(&self) -> Arc<ComponentClient<Components>> {
+	fn client(&self) -> Arc<client::Client<Self::Backend, Self::CallExecutor, Self::Block, Self::RuntimeApi>>;
+
+	/// Get clone of select chain.
+	fn select_chain(&self) -> Option<Self::SelectChain>;
+
+	/// Get shared network instance.
+	fn network(&self) -> Arc<NetworkService<Self::Block, Self::NetworkSpecialization, H256>>;
+
+	/// Returns a receiver that periodically receives a status of the network.
+	fn network_status(&self) -> mpsc::UnboundedReceiver<(NetworkStatus<Self::Block>, NetworkState)>;
+
+	/// Get shared transaction pool instance.
+	fn transaction_pool(&self) -> Arc<TransactionPool<Self::TransactionPoolApi>>;
+
+	/// Get a handle to a future that will resolve on exit.
+	fn on_exit(&self) -> ::exit_future::Exit;
+}
+
+impl<TCfg, TBl, TBackend, TExec, TRtApi, TSc, TNetSpec, TExPoolApi, TOc> AbstractService for
+	NewService<TCfg, TBl, Client<TBackend, TExec, TBl, TRtApi>, TSc, NetworkStatus<TBl>,
+		NetworkService<TBl, TNetSpec, H256>, TransactionPool<TExPoolApi>, TOc>
+where TCfg: 'static + Send,
+	TBl: BlockT<Hash = H256>,
+	TBackend: 'static + client::backend::Backend<TBl, Blake2Hasher>,
+	TExec: 'static + client::CallExecutor<TBl, Blake2Hasher> + Send + Sync + Clone,
+	TRtApi: 'static + Send + Sync,
+	TSc: 'static + Clone + Send,
+	TExPoolApi: 'static + ChainApi<Block = TBl>,
+	TOc: 'static + Send + Sync,
+	TNetSpec: NetworkSpecialization<TBl>,
+{
+	type Block = TBl;
+	type Backend = TBackend;
+	type CallExecutor = TExec;
+	type RuntimeApi = TRtApi;
+	type Config = TCfg;
+	type SelectChain = TSc;
+	type TransactionPoolApi = TExPoolApi;
+	type NetworkSpecialization = TNetSpec;
+
+	fn config(&self) -> &Self::Config {
+		&self.config
+	}
+
+	fn config_mut(&mut self) -> &mut Self::Config {
+		&mut self.config
+	}
+
+	fn telemetry_on_connect_stream(&self) -> mpsc::UnboundedReceiver<()> {
+		let (sink, stream) = mpsc::unbounded();
+		self._telemetry_on_connect_sinks.lock().push(sink);
+		stream
+	}
+
+	fn telemetry(&self) -> Option<tel::Telemetry> {
+		self._telemetry.as_ref().map(|t| t.clone())
+	}
+
+	fn keystore(&self) -> keystore::KeyStorePtr {
+		self.keystore.clone()
+	}
+
+	fn spawn_task(&self, task: impl Future<Item = (), Error = ()> + Send + 'static) {
+		let _ = self.to_spawn_tx.unbounded_send(Box::new(task));
+	}
+
+	fn spawn_essential_task(&self, task: impl Future<Item = (), Error = ()> + Send + 'static) {
+		let essential_failed = self.essential_failed.clone();
+		let essential_task = Box::new(task.map_err(move |_| {
+			error!("Essential task failed. Shutting down service.");
+			essential_failed.store(true, Ordering::Relaxed);
+		}));
+
+		let _ = self.to_spawn_tx.unbounded_send(essential_task);
+	}
+
+	fn spawn_task_handle(&self) -> SpawnTaskHandle {
+		SpawnTaskHandle {
+			sender: self.to_spawn_tx.clone(),
+		}
+	}
+
+	fn rpc_query(&self, mem: &RpcSession, request: &str) -> Box<dyn Future<Item = Option<String>, Error = ()> + Send> {
+		Box::new(self.rpc_handlers.handle_request(request, mem.metadata.clone()))
+	}
+
+	fn client(&self) -> Arc<client::Client<Self::Backend, Self::CallExecutor, Self::Block, Self::RuntimeApi>> {
 		self.client.clone()
 	}
 
-	/// Get clone of select chain.
-	pub fn select_chain(&self) -> Option<<Components as components::Components>::SelectChain> {
+	fn select_chain(&self) -> Option<Self::SelectChain> {
 		self.select_chain.clone()
 	}
 
-	/// Get shared network instance.
-	pub fn network(&self) -> Arc<components::NetworkService<Components>> {
+	fn network(&self) -> Arc<NetworkService<Self::Block, Self::NetworkSpecialization, H256>> {
 		self.network.clone()
 	}
 
-	/// Returns a receiver that periodically receives a status of the network.
-	pub fn network_status(&self) -> mpsc::UnboundedReceiver<(NetworkStatus<ComponentBlock<Components>>, NetworkState)> {
+	fn network_status(&self) -> mpsc::UnboundedReceiver<(NetworkStatus<Self::Block>, NetworkState)> {
 		let (sink, stream) = mpsc::unbounded();
 		self.network_status_sinks.lock().push(sink);
 		stream
 	}
 
-	/// Get shared transaction pool instance.
-	pub fn transaction_pool(&self) -> Arc<TransactionPool<Components::TransactionPoolApi>> {
+	fn transaction_pool(&self) -> Arc<TransactionPool<Self::TransactionPoolApi>> {
 		self.transaction_pool.clone()
 	}
 
-	/// Get a handle to a future that will resolve on exit.
-	pub fn on_exit(&self) -> ::exit_future::Exit {
+	fn on_exit(&self) -> ::exit_future::Exit {
 		self.exit.clone()
 	}
 }
 
-impl<Components> Future for Service<Components> where Components: components::Components {
+impl<TCfg, TBl, TCl, TSc, TNetStatus, TNet, TTxPool, TOc> Future for
+NewService<TCfg, TBl, TCl, TSc, TNetStatus, TNet, TTxPool, TOc> {
 	type Item = ();
 	type Error = Error;
 
@@ -603,9 +643,8 @@ impl<Components> Future for Service<Components> where Components: components::Co
 	}
 }
 
-impl<Components> Executor<Box<dyn Future<Item = (), Error = ()> + Send>>
-	for Service<Components> where Components: components::Components
-{
+impl<TCfg, TBl, TCl, TSc, TNetStatus, TNet, TTxPool, TOc> Executor<Box<dyn Future<Item = (), Error = ()> + Send>> for
+NewService<TCfg, TBl, TCl, TSc, TNetStatus, TNet, TTxPool, TOc> {
 	fn execute(
 		&self,
 		future: Box<dyn Future<Item = (), Error = ()> + Send>
@@ -746,7 +785,8 @@ pub struct NetworkStatus<B: BlockT> {
 	pub average_upload_per_sec: u64,
 }
 
-impl<Components> Drop for Service<Components> where Components: components::Components {
+impl<TCfg, TBl, TCl, TSc, TNetStatus, TNet, TTxPool, TOc> Drop for
+NewService<TCfg, TBl, TCl, TSc, TNetStatus, TNet, TTxPool, TOc> {
 	fn drop(&mut self) {
 		debug!(target: "service", "Substrate service shutdown");
 		if let Some(signal) = self.signal.take() {
@@ -757,7 +797,7 @@ impl<Components> Drop for Service<Components> where Components: components::Comp
 
 /// Starts RPC servers that run in their own thread, and returns an opaque object that keeps them alive.
 #[cfg(not(target_os = "unknown"))]
-fn start_rpc_servers<C, G, H: FnMut() -> components::RpcHandler>(
+fn start_rpc_servers<C, G, H: FnMut() -> rpc_servers::RpcHandler<rpc::Metadata>>(
 	config: &Configuration<C, G>,
 	mut gen_handler: H
 ) -> Result<Box<dyn std::any::Any + Send + Sync>, error::Error> {
@@ -906,225 +946,6 @@ where
 	}
 }
 
-/// Constructs a service factory with the given name that implements the `ServiceFactory` trait.
-/// The required parameters are required to be given in the exact order. Some parameters are followed
-/// by `{}` blocks. These blocks are required and used to initialize the given parameter.
-/// In these block it is required to write a closure that takes the same number of arguments,
-/// the corresponding function in the `ServiceFactory` trait provides.
-///
-/// # Example
-///
-/// ```
-/// # use substrate_service::{
-/// # 	construct_service_factory, Service, FullBackend, FullExecutor, LightBackend, LightExecutor,
-/// # 	FullComponents, LightComponents, FactoryFullConfiguration, FullClient
-/// # };
-/// # use transaction_pool::{self, txpool::{Pool as TransactionPool}};
-/// # use network::{config::DummyFinalityProofRequestBuilder, construct_simple_protocol};
-/// # use client::{self, LongestChain};
-/// # use consensus_common::import_queue::{BasicQueue, Verifier};
-/// # use consensus_common::{BlockOrigin, BlockImportParams, well_known_cache_keys::Id as CacheKeyId};
-/// # use node_runtime::{GenesisConfig, RuntimeApi};
-/// # use std::sync::Arc;
-/// # use node_primitives::Block;
-/// # use babe_primitives::AuthorityPair as BabePair;
-/// # use grandpa_primitives::AuthorityPair as GrandpaPair;
-/// # use sr_primitives::Justification;
-/// # use sr_primitives::traits::Block as BlockT;
-/// # use grandpa;
-/// # construct_simple_protocol! {
-/// # 	pub struct NodeProtocol where Block = Block { }
-/// # }
-/// # struct MyVerifier;
-/// # impl<B: BlockT> Verifier<B> for MyVerifier {
-/// # 	fn verify(
-/// # 		&mut self,
-/// # 		origin: BlockOrigin,
-/// # 		header: B::Header,
-/// # 		justification: Option<Justification>,
-/// # 		body: Option<Vec<B::Extrinsic>>,
-/// # 	) -> Result<(BlockImportParams<B>, Option<Vec<(CacheKeyId, Vec<u8>)>>), String> {
-/// # 		unimplemented!();
-/// # 	}
-/// # }
-/// type FullChainApi<T> = transaction_pool::ChainApi<
-/// 	client::Client<FullBackend<T>, FullExecutor<T>, Block, RuntimeApi>, Block>;
-/// type LightChainApi<T> = transaction_pool::ChainApi<
-/// 	client::Client<LightBackend<T>, LightExecutor<T>, Block, RuntimeApi>, Block>;
-///
-/// construct_service_factory! {
-/// 	struct Factory {
-/// 		// Declare the block type
-/// 		Block = Block,
-/// 		RuntimeApi = RuntimeApi,
-/// 		// Declare the network protocol and give an initializer.
-/// 		NetworkProtocol = NodeProtocol { |config| Ok(NodeProtocol::new()) },
-/// 		RuntimeDispatch = node_executor::Executor,
-/// 		FullTransactionPoolApi = FullChainApi<Self>
-/// 			{ |config, client| Ok(TransactionPool::new(config, transaction_pool::ChainApi::new(client))) },
-/// 		LightTransactionPoolApi = LightChainApi<Self>
-/// 			{ |config, client| Ok(TransactionPool::new(config, transaction_pool::ChainApi::new(client))) },
-/// 		Genesis = GenesisConfig,
-/// 		Configuration = (),
-/// 		FullService = FullComponents<Self>
-/// 			{ |config| <FullComponents<Factory>>::new(config) },
-/// 		// Setup as Consensus Authority (if the role and key are given)
-/// 		AuthoritySetup = {
-/// 			|service: Self::FullService| {
-/// 				Ok(service)
-/// 			}},
-/// 		LightService = LightComponents<Self>
-/// 			{ |config| <LightComponents<Factory>>::new(config) },
-/// 		FullImportQueue = BasicQueue<Block>
-/// 			{ |_, client, _, _| Ok(BasicQueue::new(MyVerifier, Box::new(client), None, None)) },
-/// 		LightImportQueue = BasicQueue<Block>
-/// 			{ |_, client| {
-/// 				let fprb = Box::new(DummyFinalityProofRequestBuilder::default()) as Box<_>;
-/// 				Ok((BasicQueue::new(MyVerifier, Box::new(client), None, None), fprb))
-/// 			}},
-/// 		SelectChain = LongestChain<FullBackend<Self>, Self::Block>
-/// 			{ |config: &FactoryFullConfiguration<Self>, client: Arc<FullClient<Self>>| {
-/// 				#[allow(deprecated)]
-/// 				Ok(LongestChain::new(client.backend().clone()))
-/// 			}},
-/// 		FinalityProofProvider = { |client: Arc<FullClient<Self>>| {
-/// 				Ok(Some(Arc::new(grandpa::FinalityProofProvider::new(client.clone(), client)) as _))
-/// 			}},
-/// 		RpcExtensions = (),
-/// 	}
-/// }
-/// ```
-#[macro_export]
-macro_rules! construct_service_factory {
-	(
-		$(#[$attr:meta])*
-		struct $name:ident {
-			Block = $block:ty,
-			RuntimeApi = $runtime_api:ty,
-			NetworkProtocol = $protocol:ty { $( $protocol_init:tt )* },
-			RuntimeDispatch = $dispatch:ty,
-			FullTransactionPoolApi = $full_transaction:ty { $( $full_transaction_init:tt )* },
-			LightTransactionPoolApi = $light_transaction:ty { $( $light_transaction_init:tt )* },
-			Genesis = $genesis:ty,
-			Configuration = $config:ty,
-			FullService = $full_service:ty { $( $full_service_init:tt )* },
-			AuthoritySetup = { $( $authority_setup:tt )* },
-			LightService = $light_service:ty { $( $light_service_init:tt )* },
-			FullImportQueue = $full_import_queue:ty
-				{ $( $full_import_queue_init:tt )* },
-			LightImportQueue = $light_import_queue:ty
-				{ $( $light_import_queue_init:tt )* },
-			SelectChain = $select_chain:ty
-				{ $( $select_chain_init:tt )* },
-			FinalityProofProvider = { $( $finality_proof_provider_init:tt )* },
-			RpcExtensions = $rpc_extensions_ty:ty
-				$( { $( $rpc_extensions:tt )* } )?,
-		}
-	) => {
-		$( #[$attr] )*
-		pub struct $name {}
-
-		#[allow(unused_variables)]
-		impl $crate::ServiceFactory for $name {
-			type Block = $block;
-			type RuntimeApi = $runtime_api;
-			type NetworkProtocol = $protocol;
-			type RuntimeDispatch = $dispatch;
-			type FullTransactionPoolApi = $full_transaction;
-			type LightTransactionPoolApi = $light_transaction;
-			type Genesis = $genesis;
-			type Configuration = $config;
-			type FullService = $full_service;
-			type LightService = $light_service;
-			type FullImportQueue = $full_import_queue;
-			type LightImportQueue = $light_import_queue;
-			type SelectChain = $select_chain;
-			type RpcExtensions = $rpc_extensions_ty;
-
-			fn build_full_transaction_pool(
-				config: $crate::TransactionPoolOptions,
-				client: $crate::Arc<$crate::FullClient<Self>>
-			) -> $crate::Result<$crate::TransactionPool<Self::FullTransactionPoolApi>, $crate::Error>
-			{
-				( $( $full_transaction_init )* ) (config, client)
-			}
-
-			fn build_light_transaction_pool(
-				config: $crate::TransactionPoolOptions,
-				client: $crate::Arc<$crate::LightClient<Self>>
-			) -> $crate::Result<$crate::TransactionPool<Self::LightTransactionPoolApi>, $crate::Error>
-			{
-				( $( $light_transaction_init )* ) (config, client)
-			}
-
-			fn build_network_protocol(config: &$crate::FactoryFullConfiguration<Self>)
-				-> $crate::Result<Self::NetworkProtocol, $crate::Error>
-			{
-				( $( $protocol_init )* ) (config)
-			}
-
-			fn build_select_chain(
-				config: &mut $crate::FactoryFullConfiguration<Self>,
-				client: Arc<$crate::FullClient<Self>>
-			) -> $crate::Result<Self::SelectChain, $crate::Error> {
-				( $( $select_chain_init )* ) (config, client)
-			}
-
-			fn build_full_import_queue(
-				config: &mut $crate::FactoryFullConfiguration<Self>,
-				client: $crate::Arc<$crate::FullClient<Self>>,
-				select_chain: Self::SelectChain,
-				transaction_pool: Option<Arc<$crate::TransactionPool<Self::FullTransactionPoolApi>>>,
-			) -> $crate::Result<Self::FullImportQueue, $crate::Error> {
-				( $( $full_import_queue_init )* ) (config, client, select_chain, transaction_pool)
-			}
-
-			fn build_light_import_queue(
-				config: &mut FactoryFullConfiguration<Self>,
-				client: Arc<$crate::LightClient<Self>>,
-			) -> Result<(Self::LightImportQueue, $crate::BoxFinalityProofRequestBuilder<$block>), $crate::Error> {
-				( $( $light_import_queue_init )* ) (config, client)
-			}
-
-			fn build_finality_proof_provider(
-				client: Arc<$crate::FullClient<Self>>
-			) -> Result<Option<Arc<$crate::FinalityProofProvider<Self::Block>>>, $crate::Error> {
-				( $( $finality_proof_provider_init )* ) (client)
-			}
-
-			fn new_light(
-				config: $crate::FactoryFullConfiguration<Self>
-			) -> $crate::Result<Self::LightService, $crate::Error>
-			{
-				( $( $light_service_init )* ) (config)
-			}
-
-			fn new_full(
-				config: $crate::FactoryFullConfiguration<Self>
-			) -> Result<Self::FullService, $crate::Error>
-			{
-				( $( $full_service_init )* ) (config).and_then(|service| {
-					($( $authority_setup )*)(service)
-				})
-			}
-
-			fn build_full_rpc_extensions(
-				client: Arc<$crate::FullClient<Self>>,
-				transaction_pool: Arc<$crate::TransactionPool<Self::FullTransactionPoolApi>>,
-			) -> Self::RpcExtensions {
-				$( ( $( $rpc_extensions )* ) (client, transaction_pool) )?
-			}
-
-			fn build_light_rpc_extensions(
-				client: Arc<$crate::LightClient<Self>>,
-				transaction_pool: Arc<$crate::TransactionPool<Self::LightTransactionPoolApi>>,
-			) -> Self::RpcExtensions {
-				$( ( $( $rpc_extensions )* ) (client, transaction_pool) )?
-			}
-		}
-	}
-}
-
 #[cfg(test)]
 mod tests {
 	use super::*;