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};
|
2020-05-06 20:25:03 +00:00
|
|
|
use sc_finality_grandpa::{
|
2020-05-16 13:32:11 +00:00
|
|
|
FinalityProofProvider as GrandpaFinalityProofProvider, StorageAndProofProvider, SharedVoterState,
|
2020-05-06 20:25:03 +00:00
|
|
|
};
|
2019-08-29 15:44:46 +00:00
|
|
|
|
|
|
|
// Our native executor instance.
|
|
|
|
native_executor_instance!(
|
|
|
|
pub Executor,
|
|
|
|
node_template_runtime::api::dispatch,
|
2019-10-04 13:32:53 +00:00
|
|
|
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-05-16 13:32:11 +00:00
|
|
|
|
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());
|
2019-10-04 13:32:53 +00:00
|
|
|
|
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)?;
|
2019-10-04 13:32:53 +00:00
|
|
|
|
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, ..
|
|
|
|
} = ¶ms;
|
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,
|
2019-10-04 13:32:53 +00:00
|
|
|
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(),
|
2019-10-04 13:32:53 +00:00
|
|
|
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),
|
2019-10-04 13:32:53 +00:00
|
|
|
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,
|
2020-05-16 13:32:11 +00:00
|
|
|
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
|
|
|
}
|