`e4dd4c0eeff5`

source

node/src/service.rs10.2 KiBsource history
1//! Service and ServiceFactory implementation. Specialized wrapper over substrate service.23//4// This file is subject to the terms and conditions defined in5// file 'LICENSE', which is part of this source code package.6//78use std::sync::Arc;9use std::time::Duration;10use sc_client_api::{ExecutorProvider, RemoteBackend};11use nft_runtime::{self, opaque::Block, RuntimeApi};12use sc_service::{error::Error as ServiceError, Configuration, TaskManager};13use sp_inherents::InherentDataProviders;14use sc_executor::native_executor_instance;15pub use sc_executor::NativeExecutor;16use sp_consensus_aura::sr25519::{AuthorityPair as AuraPair};17use sc_finality_grandpa::SharedVoterState;18use sc_keystore::LocalKeystore;1920// Our native executor instance.21native_executor_instance!(22	pub Executor,23	nft_runtime::api::dispatch,24	nft_runtime::native_version,25	frame_benchmarking::benchmarking::HostFunctions,26);2728type FullClient = sc_service::TFullClient<Block, RuntimeApi, Executor>;29type FullBackend = sc_service::TFullBackend<Block>;30type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;3132pub fn new_partial(config: &Configuration) -> Result<sc_service::PartialComponents<33	FullClient, FullBackend, FullSelectChain,34	sp_consensus::DefaultImportQueue<Block, FullClient>,35	sc_transaction_pool::FullPool<Block, FullClient>,36	(37		sc_consensus_aura::AuraBlockImport<38			Block,39			FullClient,40			sc_finality_grandpa::GrandpaBlockImport<FullBackend, Block, FullClient, FullSelectChain>,41			AuraPair42		>,43		sc_finality_grandpa::LinkHalf<Block, FullClient, FullSelectChain>,44	)45>, ServiceError> {46	if config.keystore_remote.is_some() {47		return Err(ServiceError::Other(48			format!("Remote Keystores are not supported.")))49	}50	let inherent_data_providers = sp_inherents::InherentDataProviders::new();5152	let (client, backend, keystore_container, task_manager) =53		sc_service::new_full_parts::<Block, RuntimeApi, Executor>(&config)?;54	let client = Arc::new(client);5556	let select_chain = sc_consensus::LongestChain::new(backend.clone());5758	let transaction_pool = sc_transaction_pool::BasicPool::new_full(59		config.transaction_pool.clone(),60		config.role.is_authority().into(),61		config.prometheus_registry(),62		task_manager.spawn_handle(),63		client.clone(),64	);6566	let (grandpa_block_import, grandpa_link) = sc_finality_grandpa::block_import(67		client.clone(), &(client.clone() as Arc<_>), select_chain.clone(),68	)?;6970	let aura_block_import = sc_consensus_aura::AuraBlockImport::<_, _, _, AuraPair>::new(71		grandpa_block_import.clone(), client.clone(),72	);7374	let import_queue = sc_consensus_aura::import_queue::<_, _, _, AuraPair, _, _>(75		sc_consensus_aura::slot_duration(&*client)?,76		aura_block_import.clone(),77		Some(Box::new(grandpa_block_import.clone())),78		client.clone(),79		inherent_data_providers.clone(),80		&task_manager.spawn_handle(),81		config.prometheus_registry(),82		sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone()),83	)?;8485	Ok(sc_service::PartialComponents {86		client, backend, task_manager, import_queue, keystore_container, select_chain, transaction_pool,87		inherent_data_providers,88		other: (aura_block_import, grandpa_link),89	})90}9192fn remote_keystore(_url: &String) -> Result<Arc<LocalKeystore>, &'static str> {93	// FIXME: here would the concrete keystore be built,94	//        must return a concrete type (NOT `LocalKeystore`) that95	//        implements `CryptoStore` and `SyncCryptoStore`96	Err("Remote Keystore not supported.")97}9899/// Builds a new service for a full client.100pub fn new_full(mut config: Configuration) -> Result<TaskManager, ServiceError> {101	let sc_service::PartialComponents {102		client, backend, mut task_manager, import_queue, mut keystore_container, select_chain, transaction_pool,103		inherent_data_providers,104		other: (block_import, grandpa_link),105	} = new_partial(&config)?;106107	if let Some(url) = &config.keystore_remote {108		match remote_keystore(url) {109			Ok(k) => keystore_container.set_remote_keystore(k),110			Err(e) => {111				return Err(ServiceError::Other(112					format!("Error hooking up remote keystore for {}: {}", url, e)))113			}114		};115	}116117	config.network.extra_sets.push(sc_finality_grandpa::grandpa_peers_set_config());118119	let (network, network_status_sinks, system_rpc_tx, network_starter) =120		sc_service::build_network(sc_service::BuildNetworkParams {121			config: &config,122			client: client.clone(),123			transaction_pool: transaction_pool.clone(),124			spawn_handle: task_manager.spawn_handle(),125			import_queue,126			on_demand: None,127			block_announce_validator_builder: None,128		})?;129130	if config.offchain_worker.enabled {131		sc_service::build_offchain_workers(132			&config, backend.clone(), task_manager.spawn_handle(), client.clone(), network.clone(),133		);134	}135136	let role = config.role.clone();137	let force_authoring = config.force_authoring;138	let backoff_authoring_blocks: Option<()> = None;139	let name = config.network.node_name.clone();140	let enable_grandpa = !config.disable_grandpa;141	let prometheus_registry = config.prometheus_registry().cloned();142143	let rpc_extensions_builder = {144		let client = client.clone();145		let pool = transaction_pool.clone();146147		Box::new(move |deny_unsafe, _| {148			let deps = crate::rpc::FullDeps {149				client: client.clone(),150				pool: pool.clone(),151				deny_unsafe,152			};153154			crate::rpc::create_full(deps)155		})156	};157158	let (_rpc_handlers, telemetry_connection_notifier) = sc_service::spawn_tasks(159		sc_service::SpawnTasksParams {160			network: network.clone(),161			client: client.clone(),162			keystore: keystore_container.sync_keystore(),163			task_manager: &mut task_manager,164			transaction_pool: transaction_pool.clone(),165			rpc_extensions_builder,166			on_demand: None,167			remote_blockchain: None,168			backend,169			network_status_sinks,170			system_rpc_tx,171			config,172		},173	)?;174175	if role.is_authority() {176		let proposer = sc_basic_authorship::ProposerFactory::new(177			task_manager.spawn_handle(),178			client.clone(),179			transaction_pool,180			prometheus_registry.as_ref(),181		);182183		let can_author_with =184			sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone());185186		let aura = sc_consensus_aura::start_aura::<_, _, _, _, _, AuraPair, _, _, _, _>(187			sc_consensus_aura::slot_duration(&*client)?,188			client.clone(),189			select_chain,190			block_import,191			proposer,192			network.clone(),193			inherent_data_providers.clone(),194			force_authoring,195			backoff_authoring_blocks,196			keystore_container.sync_keystore(),197			can_author_with,198		)?;199200		// the AURA authoring task is considered essential, i.e. if it201		// fails we take down the service with it.202		task_manager.spawn_essential_handle().spawn_blocking("aura", aura);203	}204205	// if the node isn't actively participating in consensus then it doesn't206	// need a keystore, regardless of which protocol we use below.207	let keystore = if role.is_authority() {208		Some(keystore_container.sync_keystore())209	} else {210		None211	};212213	let grandpa_config = sc_finality_grandpa::Config {214		// FIXME #1578 make this available through chainspec215		gossip_duration: Duration::from_millis(333),216		justification_period: 512,217		name: Some(name),218		observer_enabled: false,219		keystore,220		is_authority: role.is_network_authority(),221	};222223	if enable_grandpa {224		// start the full GRANDPA voter225		// NOTE: non-authorities could run the GRANDPA observer protocol, but at226		// this point the full voter should provide better guarantees of block227		// and vote data availability than the observer. The observer has not228		// been tested extensively yet and having most nodes in a network run it229		// could lead to finality stalls.230		let grandpa_config = sc_finality_grandpa::GrandpaParams {231			config: grandpa_config,232			link: grandpa_link,233			network,234			telemetry_on_connect: telemetry_connection_notifier.map(|x| x.on_connect_stream()),235			voting_rule: sc_finality_grandpa::VotingRulesBuilder::default().build(),236			prometheus_registry,237			shared_voter_state: SharedVoterState::empty(),238		};239240		// the GRANDPA voter task is considered infallible, i.e.241		// if it fails we take down the service with it.242		task_manager.spawn_essential_handle().spawn_blocking(243			"grandpa-voter",244			sc_finality_grandpa::run_grandpa_voter(grandpa_config)?245		);246	}247248	network_starter.start_network();249	Ok(task_manager)250}251/// Builds a new service for a light client.252pub fn new_light(mut config: Configuration) -> Result<TaskManager, ServiceError> {253	let (client, backend, keystore_container, mut task_manager, on_demand) =254		sc_service::new_light_parts::<Block, RuntimeApi, Executor>(&config)?;255256	config.network.extra_sets.push(sc_finality_grandpa::grandpa_peers_set_config());257258	let select_chain = sc_consensus::LongestChain::new(backend.clone());259260	let transaction_pool = Arc::new(sc_transaction_pool::BasicPool::new_light(261		config.transaction_pool.clone(),262		config.prometheus_registry(),263		task_manager.spawn_handle(),264		client.clone(),265		on_demand.clone(),266	));267268	let (grandpa_block_import, _) = sc_finality_grandpa::block_import(269		client.clone(),270		&(client.clone() as Arc<_>),271		select_chain.clone(),272	)?;273274	let aura_block_import = sc_consensus_aura::AuraBlockImport::<_, _, _, AuraPair>::new(275		grandpa_block_import.clone(),276		client.clone(),277	);278279	let import_queue = sc_consensus_aura::import_queue::<_, _, _, AuraPair, _, _>(280		sc_consensus_aura::slot_duration(&*client)?,281		aura_block_import,282		Some(Box::new(grandpa_block_import)),283		client.clone(),284		InherentDataProviders::new(),285		&task_manager.spawn_handle(),286		config.prometheus_registry(),287		sp_consensus::NeverCanAuthor,288	)?;289290	let (network, network_status_sinks, system_rpc_tx, network_starter) =291		sc_service::build_network(sc_service::BuildNetworkParams {292			config: &config,293			client: client.clone(),294			transaction_pool: transaction_pool.clone(),295			spawn_handle: task_manager.spawn_handle(),296			import_queue,297			on_demand: Some(on_demand.clone()),298			block_announce_validator_builder: None,299		})?;300301	if config.offchain_worker.enabled {302		sc_service::build_offchain_workers(303			&config, backend.clone(), task_manager.spawn_handle(), client.clone(), network.clone(),304		);305	}306307	sc_service::spawn_tasks(sc_service::SpawnTasksParams {308		remote_blockchain: Some(backend.remote_blockchain()),309		transaction_pool,310		task_manager: &mut task_manager,311		on_demand: Some(on_demand),312		rpc_extensions_builder: Box::new(|_, _| ()),313		config,314		client,315		keystore: keystore_container.sync_keystore(),316		backend,317		network,318		network_status_sinks,319		system_rpc_tx,320	})?;321322	network_starter.start_network();323324	Ok(task_manager)325}