difftreelog
Typo fixed
in: master
1 file changed
node/cli/src/command.rsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617// Original license18// This file is part of Substrate.1920// Copyright (C) 2017-2021 Parity Technologies (UK) Ltd.21// SPDX-License-Identifier: Apache-2.02223// Licensed under the Apache License, Version 2.0 (the "License");24// you may not use this file except in compliance with the License.25// You may obtain a copy of the License at26//27// http://www.apache.org/licenses/LICENSE-2.028//29// Unless required by applicable law or agreed to in writing, software30// distributed under the License is distributed on an "AS IS" BASIS,31// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.32// See the License for the specific language governing permissions and33// limitations under the License.3435use crate::{36 chain_spec::{37 self, RuntimeId, RuntimeIdentification, ServiceId, ServiceIdentification, default_runtime,38 },39 cli::{Cli, RelayChainCli, Subcommand},40 service::{new_partial, start_node, start_dev_node},41};4243#[cfg(feature = "unique-runtime")]44use crate::service::UniqueRuntimeExecutor;4546#[cfg(feature = "quartz-runtime")]47use crate::service::QuartzRuntimeExecutor;4849use crate::service::{OpalRuntimeExecutor, DefaultRuntimeExecutor};5051use codec::Encode;52use cumulus_primitives_core::ParaId;53use cumulus_client_service::genesis::generate_genesis_block;54use std::{future::Future, pin::Pin};55use log::info;56use sc_cli::{57 ChainSpec, CliConfiguration, DefaultConfigurationValues, ImportParams, KeystoreParams,58 NetworkParams, Result, RuntimeVersion, SharedParams, SubstrateCli,59};60use sc_service::{61 config::{BasePath, PrometheusConfig},62};63use sp_core::hexdisplay::HexDisplay;64use sp_runtime::traits::{AccountIdConversion, Block as BlockT};65use std::{io::Write, net::SocketAddr, time::Duration};6667use unique_runtime_common::types::Block;6869macro_rules! no_runtime_err {70 ($chain_name:expr) => {71 format!(72 "No runtime valid runtime was found for chain {}",73 $chain_name74 )75 };76}7778fn load_spec(id: &str) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {79 Ok(match id {80 "dev" => Box::new(chain_spec::development_config()),81 "" | "local" => Box::new(chain_spec::local_testnet_config()),82 path => {83 let path = std::path::PathBuf::from(path);84 let chain_spec = Box::new(chain_spec::OpalChainSpec::from_json_file(path.clone())?)85 as Box<dyn sc_service::ChainSpec>;8687 match chain_spec.runtime_id() {88 #[cfg(feature = "unique-runtime")]89 RuntimeId::Unique => Box::new(chain_spec::UniqueChainSpec::from_json_file(path)?),9091 #[cfg(feature = "quartz-runtime")]92 RuntimeId::Quartz => Box::new(chain_spec::QuartzChainSpec::from_json_file(path)?),9394 RuntimeId::Opal => chain_spec,95 RuntimeId::Unknown(chain) => return Err(no_runtime_err!(chain)),96 }97 }98 })99}100101impl SubstrateCli for Cli {102 // TODO use args103 fn impl_name() -> String {104 format!("{} Node", Self::node_name())105 }106107 fn impl_version() -> String {108 env!("SUBSTRATE_CLI_IMPL_VERSION").into()109 }110 // TODO use args111 fn description() -> String {112 format!(113 "{} Node\n\nThe command-line arguments provided first will be \114 passed to the parachain node, while the arguments provided after -- will be passed \115 to the relaychain node.\n\n\116 {} [parachain-args] -- [relaychain-args]",117 Self::node_name(),118 Self::executable_name()119 )120 }121122 fn author() -> String {123 env!("CARGO_PKG_AUTHORS").into()124 }125126 //TODO use args127 fn support_url() -> String {128 "support@unique.network".into()129 }130131 fn copyright_start_year() -> i32 {132 2019133 }134135 fn load_spec(&self, id: &str) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {136 load_spec(id)137 }138139 fn native_runtime_version(chain_spec: &Box<dyn ChainSpec>) -> &'static RuntimeVersion {140 match chain_spec.runtime_id() {141 #[cfg(feature = "unique-runtime")]142 RuntimeId::Unique => &unique_runtime::VERSION,143144 #[cfg(feature = "quartz-runtime")]145 RuntimeId::Quartz => &quartz_runtime::VERSION,146147 RuntimeId::Opal => &opal_runtime::VERSION,148 RuntimeId::Unknown(chain) => panic!("{}", no_runtime_err!(chain)),149 }150 }151}152153impl SubstrateCli for RelayChainCli {154 // TODO use args155 fn impl_name() -> String {156 format!("{} Node", Cli::node_name())157 }158159 fn impl_version() -> String {160 env!("SUBSTRATE_CLI_IMPL_VERSION").into()161 }162 // TODO use args163 fn description() -> String {164 format!(165 "{} Node\n\nThe command-line arguments provided first will be \166 passed to the parachain node, while the arguments provided after -- will be passed \167 to the relaychain node.\n\n\168 parachain-collator [parachain-args] -- [relaychain-args]",169 Cli::node_name()170 )171 }172173 fn author() -> String {174 env!("CARGO_PKG_AUTHORS").into()175 }176 // TODO use args177 fn support_url() -> String {178 "support@unique.network".into()179 }180181 fn copyright_start_year() -> i32 {182 2019183 }184185 fn load_spec(&self, id: &str) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {186 polkadot_cli::Cli::from_iter([RelayChainCli::executable_name()].iter()).load_spec(id)187 }188189 fn native_runtime_version(chain_spec: &Box<dyn ChainSpec>) -> &'static RuntimeVersion {190 polkadot_cli::Cli::native_runtime_version(chain_spec)191 }192}193194#[allow(clippy::borrowed_box)]195fn extract_genesis_wasm(chain_spec: &Box<dyn sc_service::ChainSpec>) -> Result<Vec<u8>> {196 let mut storage = chain_spec.build_storage()?;197198 storage199 .top200 .remove(sp_core::storage::well_known_keys::CODE)201 .ok_or_else(|| "Could not find wasm file in genesis state!".into())202}203204macro_rules! async_run_with_runtime {205 (206 $runtime_api:path, $executor:path,207 $runner:ident, $components:ident, $cli:ident, $cmd:ident, $config:ident,208 $( $code:tt )*209 ) => {210 $runner.async_run(|$config| {211 let $components = new_partial::<212 $runtime_api, $executor, _213 >(214 &$config,215 crate::service::parachain_build_import_queue,216 )?;217 let task_manager = $components.task_manager;218219 { $( $code )* }.map(|v| (v, task_manager))220 })221 };222}223224macro_rules! construct_async_run {225 (|$components:ident, $cli:ident, $cmd:ident, $config:ident| $( $code:tt )* ) => {{226 let runner = $cli.create_runner($cmd)?;227228 match runner.config().chain_spec.runtime_id() {229 #[cfg(feature = "unique-runtime")]230 RuntimeId::Unique => async_run_with_runtime!(231 unique_runtime::RuntimeApi, UniqueRuntimeExecutor,232 runner, $components, $cli, $cmd, $config, $( $code )*233 ),234235 #[cfg(feature = "quartz-runtime")]236 RuntimeId::Quartz => async_run_with_runtime!(237 quartz_runtime::RuntimeApi, QuartzRuntimeExecutor,238 runner, $components, $cli, $cmd, $config, $( $code )*239 ),240241 RuntimeId::Opal => async_run_with_runtime!(242 opal_runtime::RuntimeApi, OpalRuntimeExecutor,243 runner, $components, $cli, $cmd, $config, $( $code )*244 ),245246 RuntimeId::Unknown(chain) => Err(no_runtime_err!(chain).into())247 }248 }}249}250251macro_rules! start_node_using_chain_runtime {252 ($start_node_fn:ident($config:expr $(, $($args:expr),+)?) $($code:tt)*) => {253 match $config.chain_spec.runtime_id() {254 #[cfg(feature = "unique-runtime")]255 RuntimeId::Unique => $start_node_fn::<256 unique_runtime::Runtime,257 unique_runtime::RuntimeApi,258 UniqueRuntimeExecutor,259 >($config $(, $($args),+)?) $($code)*,260261 #[cfg(feature = "quartz-runtime")]262 RuntimeId::Quartz => $start_node_fn::<263 quartz_runtime::Runtime,264 quartz_runtime::RuntimeApi,265 QuartzRuntimeExecutor,266 >($config $(, $($args),+)?) $($code)*,267268 RuntimeId::Opal => $start_node_fn::<269 opal_runtime::Runtime,270 opal_runtime::RuntimeApi,271 OpalRuntimeExecutor,272 >($config $(, $($args),+)?) $($code)*,273274 RuntimeId::Unknown(chain) => Err(no_runtime_err!(chain).into()),275 }276 };277}278279/// Parse command line arguments into service configuration.280pub fn run() -> Result<()> {281 let cli = Cli::from_args();282283 match &cli.subcommand {284 Some(Subcommand::BuildSpec(cmd)) => {285 let runner = cli.create_runner(cmd)?;286 runner.sync_run(|config| cmd.run(config.chain_spec, config.network))287 }288 Some(Subcommand::CheckBlock(cmd)) => {289 construct_async_run!(|components, cli, cmd, config| {290 Ok(cmd.run(components.client, components.import_queue))291 })292 }293 Some(Subcommand::ExportBlocks(cmd)) => {294 construct_async_run!(|components, cli, cmd, config| {295 Ok(cmd.run(components.client, config.database))296 })297 }298 Some(Subcommand::ExportState(cmd)) => {299 construct_async_run!(|components, cli, cmd, config| {300 Ok(cmd.run(components.client, config.chain_spec))301 })302 }303 Some(Subcommand::ImportBlocks(cmd)) => {304 construct_async_run!(|components, cli, cmd, config| {305 Ok(cmd.run(components.client, components.import_queue))306 })307 }308 Some(Subcommand::PurgeChain(cmd)) => {309 let runner = cli.create_runner(cmd)?;310311 runner.sync_run(|config| {312 let polkadot_cli = RelayChainCli::new(313 &config,314 [RelayChainCli::executable_name()]315 .iter()316 .chain(cli.relaychain_args.iter()),317 );318319 let polkadot_config = SubstrateCli::create_configuration(320 &polkadot_cli,321 &polkadot_cli,322 config.tokio_handle.clone(),323 )324 .map_err(|err| format!("Relay chain argument error: {}", err))?;325326 cmd.run(config, polkadot_config)327 })328 }329 Some(Subcommand::Revert(cmd)) => construct_async_run!(|components, cli, cmd, config| {330 Ok(cmd.run(components.client, components.backend, None))331 }),332 Some(Subcommand::ExportGenesisState(params)) => {333 let mut builder = sc_cli::LoggerBuilder::new("");334 builder.with_profiling(sc_tracing::TracingReceiver::Log, "");335 let _ = builder.init();336337 let spec = load_spec(¶ms.chain.clone().unwrap_or_default())?;338 let state_version = Cli::native_runtime_version(&spec).state_version();339 let block: Block = generate_genesis_block(&spec, state_version)?;340 let raw_header = block.header().encode();341 let output_buf = if params.raw {342 raw_header343 } else {344 format!("0x{:?}", HexDisplay::from(&block.header().encode())).into_bytes()345 };346347 if let Some(output) = ¶ms.output {348 std::fs::write(output, output_buf)?;349 } else {350 std::io::stdout().write_all(&output_buf)?;351 }352353 Ok(())354 }355 Some(Subcommand::ExportGenesisWasm(params)) => {356 let mut builder = sc_cli::LoggerBuilder::new("");357 builder.with_profiling(sc_tracing::TracingReceiver::Log, "");358 let _ = builder.init();359360 let raw_wasm_blob =361 extract_genesis_wasm(&cli.load_spec(¶ms.chain.clone().unwrap_or_default())?)?;362 let output_buf = if params.raw {363 raw_wasm_blob364 } else {365 format!("0x{:?}", HexDisplay::from(&raw_wasm_blob)).into_bytes()366 };367368 if let Some(output) = ¶ms.output {369 std::fs::write(output, output_buf)?;370 } else {371 std::io::stdout().write_all(&output_buf)?;372 }373374 Ok(())375 }376 Some(Subcommand::Benchmark(cmd)) => {377 use frame_benchmarking_cli::{BenchmarkCmd, SUBSTRATE_REFERENCE_HARDWARE};378 let runner = cli.create_runner(cmd)?;379 // Switch on the concrete benchmark sub-command-380 match cmd {381 BenchmarkCmd::Pallet(cmd) => {382 if cfg!(feature = "runtime-benchmarks") {383 runner.sync_run(|config| cmd.run::<Block, DefaultRuntimeExecutor>(config))384 } else {385 Err("Benchmarking wasn't enabled when building the node. \386 You can enable it with `--features runtime-benchmarks`."387 .into())388 }389 }390 BenchmarkCmd::Block(cmd) => runner.sync_run(|config| {391 let partials = new_partial::<392 default_runtime::RuntimeApi,393 DefaultRuntimeExecutor,394 _,395 >(&config, crate::service::parachain_build_import_queue)?;396 cmd.run(partials.client)397 }),398 BenchmarkCmd::Storage(cmd) => runner.sync_run(|config| {399 let partials = new_partial::<400 default_runtime::RuntimeApi,401 DefaultRuntimeExecutor,402 _,403 >(&config, crate::service::parachain_build_import_queue)?;404 let db = partials.backend.expose_db();405 let storage = partials.backend.expose_storage();406407 cmd.run(config, partials.client.clone(), db, storage)408 }),409 BenchmarkCmd::Machine(cmd) => {410 runner.sync_run(|config| cmd.run(&config, SUBSTRATE_REFERENCE_HARDWARE.clone()))411 }412 BenchmarkCmd::Overhead(_) => Err("Unsupported benchmarking command".into()),413 }414 }415 Some(Subcommand::TryRuntime(cmd)) => {416 if cfg!(feature = "try-runtime") {417 let runner = cli.create_runner(cmd)?;418419 // grab the task manager.420 let registry = &runner421 .config()422 .prometheus_config423 .as_ref()424 .map(|cfg| &cfg.registry);425 let task_manager =426 sc_service::TaskManager::new(runner.config().tokio_handle.clone(), *registry)427 .map_err(|e| format!("Error: {:?}", e))?;428429 runner.async_run(|config| -> Result<(Pin<Box<dyn Future<Output = _>>>, _)> {430 Ok((431 match config.chain_spec.runtime_id() {432 #[cfg(feature = "unique-runtime")]433 RuntimeId::Unique => Box::pin(cmd.run::<Block, UniqueRuntimeExecutor>(config)),434435 #[cfg(feature = "quartz-runtime")]436 RuntimeId::Quartz => Box::pin(cmd.run::<Block, QuartzRuntimeExecutor>(config)),437438 RuntimeId::Opal => {439 Box::pin(cmd.run::<Block, OpalRuntimeExecutor>(config))440 }441 RuntimeId::Unknown(chain) => return Err(no_runtime_err!(chain).into()),442 },443 task_manager,444 ))445 })446 } else {447 Err("Try-runtime must be enabled by `--features try-runtime`.".into())448 }449 }450 None => {451 let runner = cli.create_runner(&cli.run.normalize())?;452 let collator_options = cli.run.collator_options();453454 runner.run_node_until_exit(|config| async move {455 let hwbench = if !cli.no_hardware_benchmarks {456 config.database.path().map(|database_path| {457 let _ = std::fs::create_dir_all(&database_path);458 sc_sysinfo::gather_hwbench(Some(database_path))459 })460 } else {461 None462 };463464 let extensions = chain_spec::Extensions::try_get(&*config.chain_spec);465466 let service_id = config.chain_spec.service_id();467 let relay_chain_id = extensions.map(|e| e.relay_chain.clone());468 let is_dev_service = matches![service_id, ServiceId::Dev]469 || relay_chain_id == Some("dev-service".into());470471 if is_dev_service {472 info!("Running Dev service");473474 let autoseal_interval = Duration::from_millis(cli.idle_autoseal_interval);475476 return start_node_using_chain_runtime! {477 start_dev_node(config, autoseal_interval).map_err(Into::into)478 };479 };480481 let para_id = extensions482 .map(|e| e.para_id)483 .ok_or("Could not find parachain ID in chain-spec.")?;484485 let polkadot_cli = RelayChainCli::new(486 &config,487 [RelayChainCli::executable_name()]488 .iter()489 .chain(cli.relaychain_args.iter()),490 );491492 let para_id = ParaId::from(para_id);493494 let parachain_account = AccountIdConversion::<polkadot_primitives::v2::AccountId>::into_account_truncating(&id);495496 let state_version =497 RelayChainCli::native_runtime_version(&config.chain_spec).state_version();498 let block: Block = generate_genesis_block(&config.chain_spec, state_version)499 .map_err(|e| format!("{:?}", e))?;500 let genesis_state = format!("0x{:?}", HexDisplay::from(&block.header().encode()));501 let genesis_hash = format!("0x{:?}", HexDisplay::from(&block.header().hash().0));502503 let polkadot_config = SubstrateCli::create_configuration(504 &polkadot_cli,505 &polkadot_cli,506 config.tokio_handle.clone(),507 )508 .map_err(|err| format!("Relay chain argument error: {}", err))?;509510 info!("Parachain id: {:?}", para_id);511 info!("Parachain Account: {}", parachain_account);512 info!("Parachain genesis state: {}", genesis_state);513 info!("Parachain genesis hash: {}", genesis_hash);514 info!(515 "Is collating: {}",516 if config.role.is_authority() {517 "yes"518 } else {519 "no"520 }521 );522523 start_node_using_chain_runtime! {524 start_node(config, polkadot_config, collator_options, para_id, hwbench)525 .await526 .map(|r| r.0)527 .map_err(Into::into)528 }529 })530 }531 }532}533534impl DefaultConfigurationValues for RelayChainCli {535 fn p2p_listen_port() -> u16 {536 30334537 }538539 fn rpc_ws_listen_port() -> u16 {540 9945541 }542543 fn rpc_http_listen_port() -> u16 {544 9934545 }546547 fn prometheus_listen_port() -> u16 {548 9616549 }550}551552impl CliConfiguration<Self> for RelayChainCli {553 fn shared_params(&self) -> &SharedParams {554 self.base.base.shared_params()555 }556557 fn import_params(&self) -> Option<&ImportParams> {558 self.base.base.import_params()559 }560561 fn network_params(&self) -> Option<&NetworkParams> {562 self.base.base.network_params()563 }564565 fn keystore_params(&self) -> Option<&KeystoreParams> {566 self.base.base.keystore_params()567 }568569 fn base_path(&self) -> Result<Option<BasePath>> {570 Ok(self571 .shared_params()572 .base_path()573 .or_else(|| self.base_path.clone().map(Into::into)))574 }575576 fn rpc_http(&self, default_listen_port: u16) -> Result<Option<SocketAddr>> {577 self.base.base.rpc_http(default_listen_port)578 }579580 fn rpc_ipc(&self) -> Result<Option<String>> {581 self.base.base.rpc_ipc()582 }583584 fn rpc_ws(&self, default_listen_port: u16) -> Result<Option<SocketAddr>> {585 self.base.base.rpc_ws(default_listen_port)586 }587588 fn prometheus_config(589 &self,590 default_listen_port: u16,591 chain_spec: &Box<dyn ChainSpec>,592 ) -> Result<Option<PrometheusConfig>> {593 self.base594 .base595 .prometheus_config(default_listen_port, chain_spec)596 }597598 fn init<F>(599 &self,600 _support_url: &String,601 _impl_version: &String,602 _logger_hook: F,603 _config: &sc_service::Configuration,604 ) -> Result<()> {605 unreachable!("PolkadotCli is never initialized; qed");606 }607608 fn chain_id(&self, is_dev: bool) -> Result<String> {609 let chain_id = self.base.base.chain_id(is_dev)?;610611 Ok(if chain_id.is_empty() {612 self.chain_id.clone().unwrap_or_default()613 } else {614 chain_id615 })616 }617618 fn role(&self, is_dev: bool) -> Result<sc_service::Role> {619 self.base.base.role(is_dev)620 }621622 fn transaction_pool(&self) -> Result<sc_service::config::TransactionPoolOptions> {623 self.base.base.transaction_pool()624 }625626 fn state_cache_child_ratio(&self) -> Result<Option<usize>> {627 self.base.base.state_cache_child_ratio()628 }629630 fn rpc_methods(&self) -> Result<sc_service::config::RpcMethods> {631 self.base.base.rpc_methods()632 }633634 fn rpc_ws_max_connections(&self) -> Result<Option<usize>> {635 self.base.base.rpc_ws_max_connections()636 }637638 fn rpc_cors(&self, is_dev: bool) -> Result<Option<Vec<String>>> {639 self.base.base.rpc_cors(is_dev)640 }641642 fn default_heap_pages(&self) -> Result<Option<u64>> {643 self.base.base.default_heap_pages()644 }645646 fn force_authoring(&self) -> Result<bool> {647 self.base.base.force_authoring()648 }649650 fn disable_grandpa(&self) -> Result<bool> {651 self.base.base.disable_grandpa()652 }653654 fn max_runtime_instances(&self) -> Result<Option<usize>> {655 self.base.base.max_runtime_instances()656 }657658 fn announce_block(&self) -> Result<bool> {659 self.base.base.announce_block()660 }661662 fn telemetry_endpoints(663 &self,664 chain_spec: &Box<dyn ChainSpec>,665 ) -> Result<Option<sc_telemetry::TelemetryEndpoints>> {666 self.base.base.telemetry_endpoints(chain_spec)667 }668}