Remove service, migrate all to service-new (#1630)

* import rococo into chain-spec * make a few stabs at moving forward * wip: rococo readme * remove /service crate - Move the chain-spec files to node-service - update sufficient cargo files that polkadot-service-new builds - not everything else builds yet * wip: chase down some build errors in polkadot-cli There's a lot more to go, but some progress has happened. * make more progress getting polkadot-cli to build * don't ignore polkadot.json within the res directory * don't recreate pathbufs * Prepare Polkadot to be used by Cumulus This begins to make Polkadot usable from Cumulus. * Remove old test * migrate new_chain_ops fix from /service * partially remove node/test-service * Reset some changes * Revert "partially remove node/test-service" This reverts commit 7b8f9ba5bfc286a309df89853ae11facf3277ffb. * WIP: replace v0 ParachainHost impl with v1 for test runtime This is necessary because one of the current errors when building the test service boils down to: the trait bound `polkadot_test_runtime::RuntimeApiImpl<...>`: `polkadot_primitives::v1::ParachainHost<...>` is not satisfied This is WIP because it appears to be causing some std leakage into the wasm environment, or something; the compiler is currently complaining about duplicate definitions of `panic_handler` and `oom`. Presumably I have to identify all std types (Vec etc) and replace them with sp_std equivalents. * fix test runtime build it wasn't std leakage, after all * bump westend spec version * use service-new as service within cli * to revert: demo that forwarding the test runtime to the real impl blows up * Revert "to revert: demo that forwarding the test runtime to the real impl blows up" This reverts commit 68d2f385f378721c7433e3e39133434610cd2a51. * Revert "Revert "to revert: demo that forwarding the test runtime to the real impl blows up"" This reverts commit 04cb1cbf8873b4429cb9c9fdccb7f4bb137dc720. Might have just forgotten to disable default features * More reverts * MOARE * plug in the runtime as the generic instantiation This feels closer to a solution, but it still has problems: in particular, it's assumed that Runtime implements all appropriate Trait traits, which this one apparently does not. * implement necessary traits to get the test runtime compiling This is almost certainly not correct in some way; it really looks like I need to mess with the construct_runtime! macro somehow, to inject the inclusion trait's event type as a Event variant. Still, better lock down this changeset while it all compiles. * add inclusion::Event as variant into Event enum * implement unimplemented bits in kusama * implement unimplemented bits in polkadot runtime * implement unimplemented bits in westend runtime * migrate client upgrades from master * update test service with new node changes * package metadata--that wasn't intended to be removed * add parachains v1 modules to each runtime It's not clear what precisely this does, but it's probably the right thing to do. * enable cli to opt out of full node features * adjust rococo chainspec per example https://github.com/paritytech/polkadot/blob/26f1fa47f7836ab4bee5d4aad127ebce748320dd/service/src/chain_spec.rs#L362 * try to fix Cargo.lock Co-authored-by: Bastian Köcher <git@kchr.de> Co-authored-by: Andronik Ordian <write@reusable.software>
2026-06-24 07:51:07 +00:00 · 2020-09-18 10:27:54 +02:00
parent 23c1760b48
commit d531ba561c
31 changed files with 1293 additions and 3145 deletions
@@ -16,45 +16,49 @@

 //! Polkadot service. Specialized wrapper over substrate service.

-pub mod chain_spec;
 mod grandpa_support;
 mod client;

-use std::sync::Arc;
-use std::time::Duration;
-use service::{error::Error as ServiceError, RpcHandlers};
+pub mod chain_spec;
+
 use grandpa::{self, FinalityProofProvider as GrandpaFinalityProofProvider};
-use sc_executor::native_executor_instance;
 use log::info;
-use sp_blockchain::HeaderBackend;
+use polkadot_node_core_proposer::ProposerFactory;
 use polkadot_overseer::{AllSubsystems, BlockInfo, Overseer, OverseerHandler};
 use polkadot_subsystem::DummySubsystem;
-use polkadot_node_core_proposer::ProposerFactory;
-use sp_trie::PrefixedMemoryDB;
-use sp_core::traits::SpawnNamed;
+use prometheus_endpoint::Registry;
 use sc_client_api::ExecutorProvider;
+use sc_executor::native_executor_instance;
+use service::{error::Error as ServiceError, RpcHandlers};
+use sp_blockchain::HeaderBackend;
+use sp_core::traits::SpawnNamed;
+use sp_trie::PrefixedMemoryDB;
+use std::sync::Arc;
+use std::time::Duration;
+
+pub use self::client::{AbstractClient, Client, ClientHandle, ExecuteWithClient, RuntimeApiCollection};
+pub use chain_spec::{PolkadotChainSpec, KusamaChainSpec, WestendChainSpec, RococoChainSpec};
+#[cfg(feature = "full-node")]
+pub use codec::Codec;
+pub use consensus_common::{Proposal, SelectChain, BlockImport, RecordProof, block_validation::Chain};
+pub use polkadot_parachain::wasm_executor::run_worker as run_validation_worker;
+pub use polkadot_primitives::v1::{Block, BlockId, CollatorId, Id as ParaId};
+pub use sc_client_api::{Backend, ExecutionStrategy, CallExecutor};
+pub use sc_consensus::LongestChain;
+pub use sc_executor::NativeExecutionDispatch;
 pub use service::{
 	Role, PruningMode, TransactionPoolOptions, Error, RuntimeGenesis,
 	TFullClient, TLightClient, TFullBackend, TLightBackend, TFullCallExecutor, TLightCallExecutor,
 	Configuration, ChainSpec, TaskManager,
 };
 pub use service::config::{DatabaseConfig, PrometheusConfig};
-pub use sc_executor::NativeExecutionDispatch;
-pub use sc_client_api::{Backend, ExecutionStrategy, CallExecutor};
-pub use sc_consensus::LongestChain;
 pub use sp_api::{ApiRef, Core as CoreApi, ConstructRuntimeApi, ProvideRuntimeApi, StateBackend};
-pub use sp_runtime::traits::{DigestFor, HashFor, NumberFor};
-pub use consensus_common::{Proposal, SelectChain, BlockImport, RecordProof, block_validation::Chain};
-pub use polkadot_primitives::v1::{Block, BlockId, CollatorId, Id as ParaId};
-pub use sp_runtime::traits::{Block as BlockT, self as runtime_traits, BlakeTwo256};
-pub use chain_spec::{PolkadotChainSpec, KusamaChainSpec, WestendChainSpec};
-#[cfg(feature = "full-node")]
-pub use codec::Codec;
-pub use polkadot_runtime;
+pub use sp_runtime::traits::{DigestFor, HashFor, NumberFor, Block as BlockT, self as runtime_traits, BlakeTwo256};
+
 pub use kusama_runtime;
+pub use polkadot_runtime;
+pub use rococo_runtime;
 pub use westend_runtime;
-use prometheus_endpoint::Registry;
-pub use self::client::{AbstractClient, Client, RuntimeApiCollection};

 native_executor_instance!(
 	pub PolkadotExecutor,
@@ -77,6 +81,13 @@ native_executor_instance!(
 	frame_benchmarking::benchmarking::HostFunctions,
 );

+native_executor_instance!(
+	pub RococoExecutor,
+	rococo_runtime::api::dispatch,
+	rococo_runtime::native_version,
+	frame_benchmarking::benchmarking::HostFunctions,
+);
+
 /// Can be called for a `Configuration` to check if it is a configuration for the `Kusama` network.
 pub trait IdentifyVariant {
 	/// Returns if this is a configuration for the `Kusama` network.
@@ -84,6 +95,9 @@ pub trait IdentifyVariant {

 	/// Returns if this is a configuration for the `Westend` network.
 	fn is_westend(&self) -> bool;
+
+	/// Returns if this is a configuration for the `Rococo` network.
+	fn is_rococo(&self) -> bool;
 }

 impl IdentifyVariant for Box<dyn ChainSpec> {
@@ -93,6 +107,9 @@ impl IdentifyVariant for Box<dyn ChainSpec> {
 	fn is_westend(&self) -> bool {
 		self.id().starts_with("westend") || self.id().starts_with("wnd")
 	}
+	fn is_rococo(&self) -> bool {
+		self.id().starts_with("rococo") || self.id().starts_with("rco")
+	}
 }

 // If we're using prometheus, use a registry with a prefix of `polkadot`.
@@ -104,9 +121,9 @@ fn set_prometheus_registry(config: &mut Configuration) -> Result<(), ServiceErro
 	Ok(())
 }

-type FullBackend = service::TFullBackend<Block>;
+pub type FullBackend = service::TFullBackend<Block>;
 type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;
-type FullClient<RuntimeApi, Executor> = service::TFullClient<Block, RuntimeApi, Executor>;
+pub type FullClient<RuntimeApi, Executor> = service::TFullClient<Block, RuntimeApi, Executor>;
 type FullGrandpaBlockImport<RuntimeApi, Executor> = grandpa::GrandpaBlockImport<
 	FullBackend, Block, FullClient<RuntimeApi, Executor>, FullSelectChain
 >;
@@ -275,18 +292,40 @@ fn real_overseer<S: SpawnNamed>(
 }

 #[cfg(feature = "full-node")]
-fn new_full<RuntimeApi, Executor>(
+pub struct NewFull<C> {
+	pub task_manager: TaskManager,
+	pub client: C,
+	pub node_handles: OverseerHandler,
+	pub network: Arc<sc_network::NetworkService<Block, <Block as BlockT>::Hash>>,
+	pub network_status_sinks: service::NetworkStatusSinks<Block>,
+	pub rpc_handlers: RpcHandlers,
+}
+
+#[cfg(feature = "full-node")]
+impl<C> NewFull<C> {
+	fn with_client(self, func: impl FnOnce(C) -> Client) -> NewFull<Client> {
+		NewFull {
+			client: func(self.client),
+			task_manager: self.task_manager,
+			node_handles: self.node_handles,
+			network: self.network,
+			network_status_sinks: self.network_status_sinks,
+			rpc_handlers: self.rpc_handlers,
+		}
+	}
+}
+
+/// Create a new full node of arbitrary runtime and executor.
+///
+/// This is an advanced feature and not recommended for general use. Generally, `build_full` is
+/// a better choice.
+#[cfg(feature = "full-node")]
+pub fn new_full<RuntimeApi, Executor>(
 	mut config: Configuration,
 	collating_for: Option<(CollatorId, ParaId)>,
 	authority_discovery_enabled: bool,
 	grandpa_pause: Option<(u32, u32)>,
-) -> Result<(
-	TaskManager,
-	Arc<FullClient<RuntimeApi, Executor>>,
-	Arc<sc_network::NetworkService<Block, <Block as BlockT>::Hash>>,
-	RpcHandlers,
-	OverseerHandler,
-), Error>
+) -> Result<NewFull<Arc<FullClient<RuntimeApi, Executor>>>, Error>
 	where
 		RuntimeApi: ConstructRuntimeApi<Block, FullClient<RuntimeApi, Executor>> + Send + Sync + 'static,
 		RuntimeApi::RuntimeApi:
@@ -352,7 +391,8 @@ fn new_full<RuntimeApi, Executor>(
 		on_demand: None,
 		remote_blockchain: None,
 		telemetry_connection_sinks: telemetry_connection_sinks.clone(),
-		network_status_sinks, system_rpc_tx,
+		network_status_sinks: network_status_sinks.clone(),
+		system_rpc_tx,
 	})?;

 	let (block_import, link_half, babe_link) = import_setup;
@@ -467,10 +507,8 @@ fn new_full<RuntimeApi, Executor>(
 				grandpa::VotingRulesBuilder::default()
 					.add(grandpa_support::PauseAfterBlockFor(block, delay))
 					.build()
-			},
-			None =>
-				grandpa::VotingRulesBuilder::default()
-					.build(),
+			}
+			None => grandpa::VotingRulesBuilder::default().build(),
 		};

 		let grandpa_config = grandpa::GrandpaParams {
@@ -536,7 +574,14 @@ fn new_full<RuntimeApi, Executor>(

 	network_starter.start_network();

-	Ok((task_manager, client, network, rpc_handlers, handler))
+	Ok(NewFull {
+		task_manager,
+		client,
+		node_handles: handler,
+		network,
+		network_status_sinks,
+		rpc_handlers,
+	})
 }

 /// Builds a new service for a light client.
@@ -564,7 +609,9 @@ fn new_light<Runtime, Dispatch>(mut config: Configuration) -> Result<(TaskManage
 	));

 	let grandpa_block_import = grandpa::light_block_import(
-		client.clone(), backend.clone(), &(client.clone() as Arc<_>),
+		client.clone(),
+		backend.clone(),
+		&(client.clone() as Arc<_>),
 		Arc::new(on_demand.checker().clone()),
 	)?;

@@ -612,7 +659,11 @@ fn new_light<Runtime, Dispatch>(mut config: Configuration) -> Result<(TaskManage

 	if config.offchain_worker.enabled {
 		service::build_offchain_workers(
-			&config, backend.clone(), task_manager.spawn_handle(), client.clone(), network.clone(),
+			&config,
+			backend.clone(),
+			task_manager.spawn_handle(),
+			client.clone(),
+			network.clone(),
 		);
 	}

@@ -648,30 +699,41 @@ fn new_light<Runtime, Dispatch>(mut config: Configuration) -> Result<(TaskManage

 /// Builds a new object suitable for chain operations.
 #[cfg(feature = "full-node")]
-pub fn new_chain_ops<Runtime, Dispatch>(mut config: &mut Configuration) -> Result<
+pub fn new_chain_ops(mut config: &mut Configuration) -> Result<
 	(
-		Arc<FullClient<Runtime, Dispatch>>,
+		Arc<Client>,
 		Arc<FullBackend>,
 		consensus_common::import_queue::BasicQueue<Block, PrefixedMemoryDB<BlakeTwo256>>,
 		TaskManager,
 	),
 	ServiceError
 >
-where
-	Runtime: ConstructRuntimeApi<Block, FullClient<Runtime, Dispatch>> + Send + Sync + 'static,
-	Runtime::RuntimeApi:
-	RuntimeApiCollection<StateBackend = sc_client_api::StateBackendFor<FullBackend, Block>>,
-	Dispatch: NativeExecutionDispatch + 'static,
 {
 	config.keystore = service::config::KeystoreConfig::InMemory;
-	let service::PartialComponents { client, backend, import_queue, task_manager, .. }
-		= new_partial::<Runtime, Dispatch>(config)?;
-	Ok((client, backend, import_queue, task_manager))
+	if config.chain_spec.is_rococo() {
+		let service::PartialComponents { client, backend, import_queue, task_manager, .. }
+			= new_partial::<rococo_runtime::RuntimeApi, RococoExecutor>(config)?;
+		Ok((Arc::new(Client::Rococo(client)), backend, import_queue, task_manager))
+	} else if config.chain_spec.is_kusama() {
+		let service::PartialComponents { client, backend, import_queue, task_manager, .. }
+			= new_partial::<kusama_runtime::RuntimeApi, KusamaExecutor>(config)?;
+		Ok((Arc::new(Client::Kusama(client)), backend, import_queue, task_manager))
+	} else if config.chain_spec.is_westend() {
+		let service::PartialComponents { client, backend, import_queue, task_manager, .. }
+			= new_partial::<westend_runtime::RuntimeApi, WestendExecutor>(config)?;
+		Ok((Arc::new(Client::Westend(client)), backend, import_queue, task_manager))
+	} else {
+		let service::PartialComponents { client, backend, import_queue, task_manager, .. }
+			= new_partial::<polkadot_runtime::RuntimeApi, PolkadotExecutor>(config)?;
+		Ok((Arc::new(Client::Polkadot(client)), backend, import_queue, task_manager))
+	}
 }

 /// Build a new light node.
 pub fn build_light(config: Configuration) -> Result<(TaskManager, RpcHandlers), ServiceError> {
-	if config.chain_spec.is_kusama() {
+	if config.chain_spec.is_rococo() {
+		new_light::<rococo_runtime::RuntimeApi, RococoExecutor>(config)
+	} else if config.chain_spec.is_kusama() {
 		new_light::<kusama_runtime::RuntimeApi, KusamaExecutor>(config)
 	} else if config.chain_spec.is_westend() {
 		new_light::<westend_runtime::RuntimeApi, WestendExecutor>(config)
@@ -686,27 +748,34 @@ pub fn build_full(
 	collating_for: Option<(CollatorId, ParaId)>,
 	authority_discovery_enabled: bool,
 	grandpa_pause: Option<(u32, u32)>,
-) -> Result<(TaskManager, Client, OverseerHandler), ServiceError> {
-	if config.chain_spec.is_kusama() {
+) -> Result<NewFull<Client>, ServiceError> {
+	if config.chain_spec.is_rococo() {
+		new_full::<rococo_runtime::RuntimeApi, RococoExecutor>(
+			config,
+			collating_for,
+			authority_discovery_enabled,
+			grandpa_pause,
+		).map(|full| full.with_client(Client::Rococo))
+	} else if config.chain_spec.is_kusama() {
 		new_full::<kusama_runtime::RuntimeApi, KusamaExecutor>(
 			config,
 			collating_for,
 			authority_discovery_enabled,
 			grandpa_pause,
-		).map(|(task_manager, client, _, _, handler)| (task_manager, Client::Kusama(client), handler))
+		).map(|full| full.with_client(Client::Kusama))
 	} else if config.chain_spec.is_westend() {
 		new_full::<westend_runtime::RuntimeApi, WestendExecutor>(
 			config,
 			collating_for,
 			authority_discovery_enabled,
 			grandpa_pause,
-		).map(|(task_manager, client, _, _, handler)| (task_manager, Client::Westend(client), handler))
+		).map(|full| full.with_client(Client::Westend))
 	} else {
 		new_full::<polkadot_runtime::RuntimeApi, PolkadotExecutor>(
 			config,
 			collating_for,
 			authority_discovery_enabled,
 			grandpa_pause,
-		).map(|(task_manager, client, _, _, handler)| (task_manager, Client::Polkadot(client), handler))
+		).map(|full| full.with_client(Client::Polkadot))
 	}
 }