Rc5 (#143)

* Update to rc6.

* Update runtime.

* Update node to rc6.

* Update client.

* Fix node.

* Add option to enable telemetry.

test-node/src/service.rs

@@ -16,8 +16,10 @@
 
 //! Service and ServiceFactory implementation. Specialized wrapper over substrate service.
 
-use sc_client_api::ExecutorProvider;
-use sc_consensus::LongestChain;
+use sc_client_api::{
+    ExecutorProvider,
+    RemoteBackend,
+};
 use sc_executor::native_executor_instance;
 pub use sc_executor::NativeExecutor;
 use sc_finality_grandpa::{
@@ -27,9 +29,10 @@ use sc_finality_grandpa::{
 };
 use sc_service::{
     error::Error as ServiceError,
-    AbstractService,
     Configuration,
-    ServiceBuilder,
+    RpcHandlers,
+    ServiceComponents,
+    TaskManager,
 };
 use sp_consensus_aura::sr25519::AuthorityPair as AuraPair;
 use sp_inherents::InherentDataProviders;
@@ -50,142 +53,184 @@ native_executor_instance!(
     test_node_runtime::native_version,
 );
 
-/// Starts a `ServiceBuilder` for a full service.
-///
-/// Use this macro if you don't actually need the full service, but just the builder in order to
-/// be able to perform chain operations.
-macro_rules! new_full_start {
-    ($config:expr) => {{
-        use sp_consensus_aura::sr25519::AuthorityPair as AuraPair;
-        use std::sync::Arc;
+type FullClient = sc_service::TFullClient<Block, RuntimeApi, Executor>;
+type FullBackend = sc_service::TFullBackend<Block>;
+type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;
 
-        let mut import_setup = None;
-        let inherent_data_providers = sp_inherents::InherentDataProviders::new();
+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();
 
-        let builder =
-            sc_service::ServiceBuilder::new_full::<
-                test_node_runtime::opaque::Block,
-                test_node_runtime::RuntimeApi,
-                crate::service::Executor,
-            >($config)?
-            .with_select_chain(|_config, backend| {
-                Ok(sc_consensus::LongestChain::new(backend.clone()))
-            })?
-            .with_transaction_pool(|builder| {
-                let pool_api =
-                    sc_transaction_pool::FullChainApi::new(builder.client().clone());
-                Ok(sc_transaction_pool::BasicPool::new(
-                    builder.config().transaction_pool.clone(),
-                    std::sync::Arc::new(pool_api),
-                    builder.prometheus_registry(),
-                ))
-            })?
-            .with_import_queue(
-                |_config,
-                 client,
-                 mut select_chain,
-                 _transaction_pool,
-                 spawn_task_handle,
-                 registry| {
-                    let select_chain = select_chain
-                        .take()
-                        .ok_or_else(|| sc_service::Error::SelectChainRequired)?;
+    let (client, backend, keystore, task_manager) =
+        sc_service::new_full_parts::<Block, RuntimeApi, Executor>(&config)?;
+    let client = Arc::new(client);
 
-                    let (grandpa_block_import, grandpa_link) =
-                        sc_finality_grandpa::block_import(
-                            client.clone(),
-                            &(client.clone() as Arc<_>),
-                            select_chain,
-                        )?;
+    let select_chain = sc_consensus::LongestChain::new(backend.clone());
 
-                    let aura_block_import =
-                        sc_consensus_aura::AuraBlockImport::<_, _, _, AuraPair>::new(
-                            grandpa_block_import.clone(),
-                            client.clone(),
-                        );
+    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(),
+    );
 
-                    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,
-                            inherent_data_providers.clone(),
-                            spawn_task_handle,
-                            registry,
-                        )?;
+    let (grandpa_block_import, grandpa_link) = sc_finality_grandpa::block_import(
+        client.clone(),
+        &(client.clone() as Arc<_>),
+        select_chain.clone(),
+    )?;
 
-                    import_setup = Some((grandpa_block_import, grandpa_link));
+    let aura_block_import = sc_consensus_aura::AuraBlockImport::<_, _, _, AuraPair>::new(
+        grandpa_block_import.clone(),
+        client.clone(),
+    );
 
-                    Ok(import_queue)
-                },
-            )?;
+    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(),
+    )?;
 
-        (builder, import_setup, inherent_data_providers)
-    }};
+    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,
+    ))
 }
 
 /// Builds a new service for a full client.
-pub fn new_full(config: Configuration) -> Result<impl AbstractService, ServiceError> {
-    let role = config.role.clone();
-    let force_authoring = config.force_authoring;
-    let name = config.network.node_name.clone();
-    let disable_grandpa = config.disable_grandpa;
+pub fn new_full(
+    config: Configuration,
+) -> Result<(TaskManager, Arc<RpcHandlers>), ServiceError> {
+    let (params, select_chain, inherent_data_providers, block_import, grandpa_link) =
+        new_full_params(config)?;
 
-    let (builder, mut import_setup, inherent_data_providers) = new_full_start!(config);
+    let (
+        role,
+        force_authoring,
+        name,
+        enable_grandpa,
+        prometheus_registry,
+        client,
+        transaction_pool,
+        keystore,
+    ) = {
+        let sc_service::ServiceParams {
+            config,
+            client,
+            transaction_pool,
+            keystore,
+            ..
+        } = &params;
 
-    let (block_import, grandpa_link) =
-		import_setup.take()
-			.expect("Link Half and Block Import are present for Full Services or setup failed before. qed");
+        (
+            config.role.clone(),
+            config.force_authoring,
+            config.network.node_name.clone(),
+            !config.disable_grandpa,
+            config.prometheus_registry().cloned(),
+            client.clone(),
+            transaction_pool.clone(),
+            keystore.clone(),
+        )
+    };
 
-    let service = builder
-        .with_finality_proof_provider(|client, backend| {
-            // GenesisAuthoritySetProvider is implemented for StorageAndProofProvider
-            let provider = client as Arc<dyn StorageAndProofProvider<_, _>>;
-            Ok(Arc::new(GrandpaFinalityProofProvider::new(backend, provider)) as _)
-        })?
-        .build_full()?;
+    let ServiceComponents {
+        task_manager,
+        rpc_handlers,
+        network,
+        telemetry_on_connect_sinks,
+        ..
+    } = sc_service::build(params)?;
 
     if role.is_authority() {
         let proposer = sc_basic_authorship::ProposerFactory::new(
-            service.client(),
-            service.transaction_pool(),
-            service.prometheus_registry().as_ref(),
+            client.clone(),
+            transaction_pool,
+            prometheus_registry.as_ref(),
         );
 
-        let client = service.client();
-        let select_chain = service
-            .select_chain()
-            .ok_or(ServiceError::SelectChainRequired)?;
-
         let can_author_with =
             sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone());
 
         let aura = sc_consensus_aura::start_aura::<_, _, _, _, _, AuraPair, _, _, _>(
             sc_consensus_aura::slot_duration(&*client)?,
-            client,
+            client.clone(),
             select_chain,
             block_import,
             proposer,
-            service.network(),
+            network.clone(),
             inherent_data_providers.clone(),
             force_authoring,
-            service.keystore(),
+            keystore.clone(),
             can_author_with,
         )?;
 
         // the AURA authoring task is considered essential, i.e. if it
         // fails we take down the service with it.
-        service
-            .spawn_essential_task_handle()
+        task_manager
+            .spawn_essential_handle()
             .spawn_blocking("aura", aura);
     }
 
     // if the node isn't actively participating in consensus then it doesn't
     // need a keystore, regardless of which protocol we use below.
     let keystore = if role.is_authority() {
-        Some(service.keystore() as sp_core::traits::BareCryptoStorePtr)
+        Some(keystore as sp_core::traits::BareCryptoStorePtr)
     } else {
         None
     };
@@ -199,7 +244,6 @@ pub fn new_full(config: Configuration) -> Result<impl AbstractService, ServiceEr
         is_authority: role.is_network_authority(),
     };
 
-    let enable_grandpa = !disable_grandpa;
     if enable_grandpa {
         // start the full GRANDPA voter
         // NOTE: non-authorities could run the GRANDPA observer protocol, but at
@@ -210,95 +254,95 @@ pub fn new_full(config: Configuration) -> Result<impl AbstractService, ServiceEr
         let grandpa_config = sc_finality_grandpa::GrandpaParams {
             config: grandpa_config,
             link: grandpa_link,
-            network: service.network(),
-            inherent_data_providers: inherent_data_providers.clone(),
-            telemetry_on_connect: Some(service.telemetry_on_connect_stream()),
+            network,
+            inherent_data_providers,
+            telemetry_on_connect: Some(telemetry_on_connect_sinks.on_connect_stream()),
             voting_rule: sc_finality_grandpa::VotingRulesBuilder::default().build(),
-            prometheus_registry: service.prometheus_registry(),
+            prometheus_registry,
             shared_voter_state: SharedVoterState::empty(),
         };
 
         // the GRANDPA voter task is considered infallible, i.e.
         // if it fails we take down the service with it.
-        service.spawn_essential_task_handle().spawn_blocking(
+        task_manager.spawn_essential_handle().spawn_blocking(
             "grandpa-voter",
             sc_finality_grandpa::run_grandpa_voter(grandpa_config)?,
         );
     } else {
         sc_finality_grandpa::setup_disabled_grandpa(
-            service.client(),
+            client,
             &inherent_data_providers,
-            service.network(),
+            network,
         )?;
     }
 
-    Ok(service)
+    Ok((task_manager, rpc_handlers))
 }
 
 /// Builds a new service for a light client.
-pub fn new_light(config: Configuration) -> Result<impl AbstractService, ServiceError> {
-    let inherent_data_providers = InherentDataProviders::new();
+pub fn new_light(
+    config: Configuration,
+) -> Result<(TaskManager, Arc<RpcHandlers>), ServiceError> {
+    let (client, backend, keystore, task_manager, on_demand) =
+        sc_service::new_light_parts::<Block, RuntimeApi, Executor>(&config)?;
 
-    ServiceBuilder::new_light::<Block, RuntimeApi, Executor>(config)?
-		.with_select_chain(|_config, backend| {
-			Ok(LongestChain::new(backend.clone()))
-		})?
-		.with_transaction_pool(|builder| {
-			let fetcher = builder.fetcher()
-				.ok_or_else(|| "Trying to start light transaction pool without active fetcher")?;
+    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(),
+    );
 
-			let pool_api = sc_transaction_pool::LightChainApi::new(
-				builder.client().clone(),
-				fetcher.clone(),
-			);
-			let pool = sc_transaction_pool::BasicPool::with_revalidation_type(
-				builder.config().transaction_pool.clone(),
-				Arc::new(pool_api),
-				builder.prometheus_registry(),
-				sc_transaction_pool::RevalidationType::Light,
-			);
-			Ok(pool)
-		})?
-		.with_import_queue_and_fprb(|
-			_config,
-			client,
-			backend,
-			fetcher,
-			_select_chain,
-			_tx_pool,
-			spawn_task_handle,
-			prometheus_registry,
-		| {
-			let fetch_checker = fetcher
-				.map(|fetcher| fetcher.checker().clone())
-				.ok_or_else(|| "Trying to start light import queue without active fetch checker")?;
-			let grandpa_block_import = sc_finality_grandpa::light_block_import(
-				client.clone(),
-				backend,
-				&(client.clone() as Arc<_>),
-				Arc::new(fetch_checker),
-			)?;
-			let finality_proof_import = grandpa_block_import.clone();
-			let finality_proof_request_builder =
-				finality_proof_import.create_finality_proof_request_builder();
+    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();
 
-			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,
-				inherent_data_providers.clone(),
-				spawn_task_handle,
-				prometheus_registry,
-			)?;
+    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(),
+    )?;
 
-			Ok((import_queue, finality_proof_request_builder))
-		})?
-		.with_finality_proof_provider(|client, backend| {
-			// GenesisAuthoritySetProvider is implemented for StorageAndProofProvider
-			let provider = client as Arc<dyn StorageAndProofProvider<_, _>>;
-			Ok(Arc::new(GrandpaFinalityProofProvider::new(backend, provider)) as _)
-		})?
-        .build_light()
+    let finality_proof_provider = Arc::new(GrandpaFinalityProofProvider::new(
+        backend.clone(),
+        client.clone() as Arc<_>,
+    ));
+
+    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,
+             rpc_handlers,
+             ..
+         }| (task_manager, rpc_handlers),
+    )
 }