solutions/node/src/service.rs

257 lines
8.3 KiB
Rust
Raw Normal View History

2019-08-29 15:44:46 +00:00
//! Service and ServiceFactory implementation. Specialized wrapper over substrate service.
use std::sync::Arc;
use std::time::Duration;
2020-07-25 12:35:30 +00:00
use sc_client_api::{ExecutorProvider, RemoteBackend};
use node_template_runtime::{self, Block, RuntimeApi};
use sc_service::{error::Error as ServiceError, Configuration, ServiceComponents, TaskManager};
2019-12-16 20:46:39 +00:00
use sp_inherents::InherentDataProviders;
use sc_executor::native_executor_instance;
pub use sc_executor::NativeExecutor;
use sp_consensus_aura::sr25519::{AuthorityPair as AuraPair};
use sc_finality_grandpa::{
FinalityProofProvider as GrandpaFinalityProofProvider, StorageAndProofProvider, SharedVoterState,
};
2019-08-29 15:44:46 +00:00
// Our native executor instance.
native_executor_instance!(
pub Executor,
node_template_runtime::api::dispatch,
node_template_runtime::native_version,
2019-08-29 15:44:46 +00:00
);
2020-07-25 12:35:30 +00:00
type FullClient = sc_service::TFullClient<Block, RuntimeApi, Executor>;
type FullBackend = sc_service::TFullBackend<Block>;
type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;
2020-07-25 12:35:30 +00:00
pub fn new_full_params(config: Configuration) -> Result<(
sc_service::ServiceParams<
Block, FullClient,
sc_consensus_aura::AuraImportQueue<Block, FullClient>,
sc_transaction_pool::FullPool<Block, FullClient>,
(), FullBackend,
>,
FullSelectChain,
sp_inherents::InherentDataProviders,
sc_finality_grandpa::GrandpaBlockImport<FullBackend, Block, FullClient, FullSelectChain>,
sc_finality_grandpa::LinkHalf<Block, FullClient, FullSelectChain>
), ServiceError> {
let inherent_data_providers = sp_inherents::InherentDataProviders::new();
2019-08-29 15:44:46 +00:00
2020-07-25 12:35:30 +00:00
let (client, backend, keystore, task_manager) =
sc_service::new_full_parts::<Block, RuntimeApi, Executor>(&config)?;
let client = Arc::new(client);
2019-10-20 12:22:24 +00:00
2020-07-25 12:35:30 +00:00
let select_chain = sc_consensus::LongestChain::new(backend.clone());
2020-07-25 12:35:30 +00:00
let pool_api = sc_transaction_pool::FullChainApi::new(
client.clone(), config.prometheus_registry(),
);
let transaction_pool = sc_transaction_pool::BasicPool::new_full(
config.transaction_pool.clone(),
std::sync::Arc::new(pool_api),
config.prometheus_registry(),
task_manager.spawn_handle(),
client.clone(),
);
2020-01-06 20:58:38 +00:00
2020-07-25 12:35:30 +00:00
let (grandpa_block_import, grandpa_link) = sc_finality_grandpa::block_import(
client.clone(), &(client.clone() as Arc<_>), select_chain.clone(),
)?;
2019-08-29 15:44:46 +00:00
2020-07-25 12:35:30 +00:00
let aura_block_import = sc_consensus_aura::AuraBlockImport::<_, _, _, AuraPair>::new(
grandpa_block_import.clone(), client.clone(),
);
2019-08-29 15:44:46 +00:00
2020-07-25 12:35:30 +00:00
let import_queue = sc_consensus_aura::import_queue::<_, _, _, AuraPair, _>(
sc_consensus_aura::slot_duration(&*client)?,
aura_block_import,
Some(Box::new(grandpa_block_import.clone())),
None,
client.clone(),
inherent_data_providers.clone(),
&task_manager.spawn_handle(),
config.prometheus_registry(),
)?;
2019-08-29 15:44:46 +00:00
2020-07-25 12:35:30 +00:00
let provider = client.clone() as Arc<dyn StorageAndProofProvider<_, _>>;
let finality_proof_provider =
Arc::new(GrandpaFinalityProofProvider::new(backend.clone(), provider));
let params = sc_service::ServiceParams {
backend, client, import_queue, keystore, task_manager, transaction_pool,
config,
block_announce_validator_builder: None,
finality_proof_request_builder: None,
finality_proof_provider: Some(finality_proof_provider),
on_demand: None,
remote_blockchain: None,
rpc_extensions_builder: Box::new(|_| ()),
};
Ok((
params, select_chain, inherent_data_providers,
grandpa_block_import, grandpa_link,
))
2019-08-29 15:44:46 +00:00
}
/// Builds a new service for a full client.
2020-07-25 12:35:30 +00:00
pub fn new_full(config: Configuration) -> Result<TaskManager, ServiceError> {
let (
params, select_chain, inherent_data_providers,
block_import, grandpa_link,
) = new_full_params(config)?;
2020-07-25 12:35:30 +00:00
let (
role, force_authoring, name, enable_grandpa, prometheus_registry,
client, transaction_pool, keystore,
) = {
let sc_service::ServiceParams {
config, client, transaction_pool, keystore, ..
} = &params;
2019-08-29 15:44:46 +00:00
2020-07-25 12:35:30 +00:00
(
config.role.clone(),
config.force_authoring,
config.network.node_name.clone(),
!config.disable_grandpa,
config.prometheus_registry().cloned(),
2019-10-20 12:22:24 +00:00
2020-07-25 12:35:30 +00:00
client.clone(), transaction_pool.clone(), keystore.clone(),
)
};
let ServiceComponents {
task_manager, network, telemetry_on_connect_sinks, ..
} = sc_service::build(params)?;
2019-08-29 15:44:46 +00:00
2020-04-15 11:33:19 +00:00
if role.is_authority() {
2020-05-25 21:48:38 +00:00
let proposer = sc_basic_authorship::ProposerFactory::new(
2020-07-25 12:35:30 +00:00
client.clone(),
transaction_pool,
prometheus_registry.as_ref(),
2020-05-25 21:48:38 +00:00
);
2019-08-29 15:44:46 +00:00
2019-12-16 20:46:39 +00:00
let can_author_with =
sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone());
2020-03-05 16:53:25 +00:00
let aura = sc_consensus_aura::start_aura::<_, _, _, _, _, AuraPair, _, _, _>(
sc_consensus_aura::slot_duration(&*client)?,
2020-07-25 12:35:30 +00:00
client.clone(),
2019-08-29 15:44:46 +00:00
select_chain,
block_import,
2019-10-20 12:22:24 +00:00
proposer,
2020-07-25 12:35:30 +00:00
network.clone(),
2019-10-20 12:22:24 +00:00
inherent_data_providers.clone(),
force_authoring,
2020-07-25 12:35:30 +00:00
keystore.clone(),
2019-12-16 20:46:39 +00:00
can_author_with,
2019-10-20 12:22:24 +00:00
)?;
2019-08-29 15:44:46 +00:00
2019-10-20 12:22:24 +00:00
// the AURA authoring task is considered essential, i.e. if it
2019-08-29 15:44:46 +00:00
// fails we take down the service with it.
2020-07-25 12:35:30 +00:00
task_manager.spawn_essential_handle().spawn_blocking("aura", aura);
2019-08-29 15:44:46 +00:00
}
2019-12-16 20:46:39 +00:00
// if the node isn't actively participating in consensus then it doesn't
// need a keystore, regardless of which protocol we use below.
2020-04-15 11:33:19 +00:00
let keystore = if role.is_authority() {
2020-07-25 12:35:30 +00:00
Some(keystore as sp_core::traits::BareCryptoStorePtr)
2019-12-16 20:46:39 +00:00
} else {
None
};
2020-04-15 11:33:19 +00:00
let grandpa_config = sc_finality_grandpa::Config {
2019-08-29 15:44:46 +00:00
// FIXME #1578 make this available through chainspec
gossip_duration: Duration::from_millis(333),
justification_period: 512,
name: Some(name),
2020-03-05 16:53:25 +00:00
observer_enabled: false,
2019-12-16 20:46:39 +00:00
keystore,
2020-04-15 11:33:19 +00:00
is_authority: role.is_network_authority(),
2019-08-29 15:44:46 +00:00
};
2020-03-05 16:53:25 +00:00
if enable_grandpa {
// start the full GRANDPA voter
// NOTE: non-authorities could run the GRANDPA observer protocol, but at
// this point the full voter should provide better guarantees of block
// and vote data availability than the observer. The observer has not
// been tested extensively yet and having most nodes in a network run it
// could lead to finality stalls.
2020-04-15 11:33:19 +00:00
let grandpa_config = sc_finality_grandpa::GrandpaParams {
2020-03-05 16:53:25 +00:00
config: grandpa_config,
link: grandpa_link,
2020-07-25 12:35:30 +00:00
network,
inherent_data_providers,
telemetry_on_connect: Some(telemetry_on_connect_sinks.on_connect_stream()),
2020-04-15 11:33:19 +00:00
voting_rule: sc_finality_grandpa::VotingRulesBuilder::default().build(),
2020-07-25 12:35:30 +00:00
prometheus_registry,
shared_voter_state: SharedVoterState::empty(),
2020-03-05 16:53:25 +00:00
};
// the GRANDPA voter task is considered infallible, i.e.
// if it fails we take down the service with it.
2020-07-25 12:35:30 +00:00
task_manager.spawn_essential_handle().spawn_blocking(
2020-03-05 16:53:25 +00:00
"grandpa-voter",
2020-04-15 11:33:19 +00:00
sc_finality_grandpa::run_grandpa_voter(grandpa_config)?
2020-03-05 16:53:25 +00:00
);
} else {
2020-04-15 11:33:19 +00:00
sc_finality_grandpa::setup_disabled_grandpa(
2020-07-25 12:35:30 +00:00
client,
2020-03-05 16:53:25 +00:00
&inherent_data_providers,
2020-07-25 12:35:30 +00:00
network,
2020-03-05 16:53:25 +00:00
)?;
2019-08-29 15:44:46 +00:00
}
2020-07-25 12:35:30 +00:00
Ok(task_manager)
2019-08-29 15:44:46 +00:00
}
/// Builds a new service for a light client.
2020-07-25 12:35:30 +00:00
pub fn new_light(config: Configuration) -> Result<TaskManager, ServiceError> {
let (client, backend, keystore, task_manager, on_demand) =
sc_service::new_light_parts::<Block, RuntimeApi, Executor>(&config)?;
let transaction_pool_api = Arc::new(sc_transaction_pool::LightChainApi::new(
client.clone(), on_demand.clone(),
));
let transaction_pool = sc_transaction_pool::BasicPool::new_light(
config.transaction_pool.clone(),
transaction_pool_api,
config.prometheus_registry(),
task_manager.spawn_handle(),
);
2019-08-29 15:44:46 +00:00
2020-07-25 12:35:30 +00:00
let grandpa_block_import = sc_finality_grandpa::light_block_import(
client.clone(), backend.clone(), &(client.clone() as Arc<_>),
Arc::new(on_demand.checker().clone()) as Arc<_>,
)?;
let finality_proof_import = grandpa_block_import.clone();
let finality_proof_request_builder =
finality_proof_import.create_finality_proof_request_builder();
2020-03-05 16:53:25 +00:00
2020-07-25 12:35:30 +00:00
let import_queue = sc_consensus_aura::import_queue::<_, _, _, AuraPair, _>(
sc_consensus_aura::slot_duration(&*client)?,
grandpa_block_import,
None,
Some(Box::new(finality_proof_import)),
client.clone(),
InherentDataProviders::new(),
&task_manager.spawn_handle(),
config.prometheus_registry(),
)?;
2019-08-29 15:44:46 +00:00
2020-07-25 12:35:30 +00:00
let finality_proof_provider =
Arc::new(GrandpaFinalityProofProvider::new(backend.clone(), client.clone() as Arc<_>));
2019-08-29 15:44:46 +00:00
2020-07-25 12:35:30 +00:00
sc_service::build(sc_service::ServiceParams {
block_announce_validator_builder: None,
finality_proof_request_builder: Some(finality_proof_request_builder),
finality_proof_provider: Some(finality_proof_provider),
on_demand: Some(on_demand),
remote_blockchain: Some(backend.remote_blockchain()),
rpc_extensions_builder: Box::new(|_| ()),
transaction_pool: Arc::new(transaction_pool),
config, client, import_queue, keystore, backend, task_manager
}).map(|ServiceComponents { task_manager, .. }| task_manager)
2019-08-29 15:44:46 +00:00
}