Grcov report - command.rs

1

// Copyright (C) Moondance Labs Ltd.

2

// This file is part of Tanssi.

3

4

// Tanssi is free software: you can redistribute it and/or modify

5

// it under the terms of the GNU General Public License as published by

6

// the Free Software Foundation, either version 3 of the License, or

7

// (at your option) any later version.

8

9

// Tanssi is distributed in the hope that it will be useful,

10

// but WITHOUT ANY WARRANTY; without even the implied warranty of

11

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

12

// GNU General Public License for more details.

13

14

// You should have received a copy of the GNU General Public License

15

// along with Tanssi.  If not, see <http://www.gnu.org/licenses/>.

16

17

use {

18

    crate::{

19

        chain_spec,

20

        cli::{BaseSubcommand, Cli, Subcommand},

21

        service::{self, NodeConfig},

22

},

23

    clap::Parser,

24

    container_chain_template_simple_runtime::Block,

25

    cumulus_client_service::storage_proof_size::HostFunctions as ReclaimHostFunctions,

26

    cumulus_primitives_core::ParaId,

27

    frame_benchmarking_cli::{BenchmarkCmd, SUBSTRATE_REFERENCE_HARDWARE},

28

    log::{info, warn},

29

    node_common::{

30

        chain_spec as node_common_chain_spec, cli::ContainerNodeRelayChainCli,

31

        command::generate_genesis_block, service::node_builder::NodeBuilderConfig as _,

32

},

33

    parity_scale_codec::Encode,

34

    polkadot_service::IdentifyVariant as _,

35

    sc_cli::{ChainSpec, Result, SubstrateCli},

36

    sp_core::hexdisplay::HexDisplay,

37

    sp_runtime::traits::{AccountIdConversion, Block as BlockT, Get},

38

    std::marker::PhantomData,

39

    tc_service_container_chain_data_preserver::{DataPreserverCmd, DataPreserverMode},

40

    tc_service_container_chain_spawner::cli::ContainerChainCli,

41

};

42

43

pub struct NodeName;

44

45

impl Get<&'static str> for NodeName {

46

    fn get() -> &'static str {

47

        "Simple"

48

49

50

51

86

fn load_spec(id: &str, para_id: ParaId) -> std::result::Result<Box<dyn ChainSpec>, String> {

52

86

    Ok(match id {

53

86

        "dev" => Box::new(chain_spec::development_config(para_id, vec![])),

54

84

        "template-rococo" => Box::new(chain_spec::local_testnet_config(para_id, vec![])),

55

84

        "" | "local" => Box::new(chain_spec::local_testnet_config(para_id, vec![])),

56

57

        // dummy container chain spec, it will not be used to actually spawn a chain

58

84

        "container-chain-unknown" => Box::new(

59

            sc_service::GenericChainSpec::<node_common_chain_spec::Extensions, ()>::builder(

60

                b"",

61

                node_common_chain_spec::Extensions {

62

                    relay_chain: "westend-local".into(),

63

                    para_id: 2000,

64

},

65

66

            .build(),

67

),

68

69

84

        path => Box::new(chain_spec::ChainSpec::from_json_file(

70

84

            std::path::PathBuf::from(path),

71

        )?),

72

})

73

86

74

75

impl SubstrateCli for Cli {

76

244

    fn impl_name() -> String {

77

244

        "Container Chain Simple Node".into()

78

244

79

80

413

    fn impl_version() -> String {

81

413

        env!("SUBSTRATE_CLI_IMPL_VERSION").into()

82

413

83

84

172

    fn description() -> String {

85

172

        format!(

86

172

            "Container Chain Simple Node\n\nThe command-line arguments provided first will be \

87

172

        passed to the parachain node, while the arguments provided after -- will be passed \

88

172

        to the relay chain node.\n\n\

89

172

        {} <parachain-args> -- <relay-chain-args>",

90

172

            Self::executable_name()

91

92

172

93

94

166

    fn author() -> String {

95

166

        env!("CARGO_PKG_AUTHORS").into()

96

166

97

98

168

    fn support_url() -> String {

99

168

        "https://github.com/moondance-labs/tanssi/issues/new".into()

100

168

101

102

80

    fn copyright_start_year() -> i32 {

103

80

104

80

105

106

86

    fn load_spec(&self, id: &str) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {

107

86

        load_spec(id, self.para_id.unwrap_or(2000).into())

108

86

109

110

111

macro_rules! construct_async_run {

112

    (|$components:ident, $cli:ident, $cmd:ident, $config:ident| $( $code:tt )* ) => {{

113

        let runner = $cli.create_runner($cmd)?;

114

        runner.async_run(|$config| {

115

            let $components = NodeConfig::new_builder(&$config, None)?;

116

            let inner = { $( $code )* };

117

118

            let task_manager = $components.task_manager;

119

            inner.map(|v| (v, task_manager))

120

})

121

}}

122

123

124

/// Parse command line arguments into service configuration.

125

86

pub fn run() -> Result<()> {

126

86

    let cli = Cli::from_args();

127

128

    // Match rpc provider subcommand in wrapper

129

86

    let subcommand = match &cli.subcommand {

130

        Some(Subcommand::DataPreserver(cmd)) => {

131

            return data_preserver_mode(&cli, cmd);

132

133

6

        Some(Subcommand::Base(cmd)) => Some(cmd),

134

80

        None => None,

135

};

136

137

    #[allow(deprecated)]

138

6

    match subcommand {

139

        Some(BaseSubcommand::BuildSpec(cmd)) => {

140

            let runner = cli.create_runner(cmd)?;

141

            runner.sync_run(|config| {

142

                let chain_spec = if let Some(para_id) = cmd.extra.parachain_id {

143

                    if cmd.base.shared_params.dev {

144

                        Box::new(chain_spec::development_config(

145

                            para_id.into(),

146

                            cmd.extra.add_bootnode.clone(),

147

))

148

                    } else {

149

                        Box::new(chain_spec::local_testnet_config(

150

                            para_id.into(),

151

                            cmd.extra.add_bootnode.clone(),

152

))

153

154

                } else {

155

                    config.chain_spec

156

};

157

                cmd.base.run(chain_spec, config.network)

158

})

159

160

4

        Some(BaseSubcommand::ExportChainSpec(cmd)) => {

161

4

            let chain_spec: Box<dyn sc_service::ChainSpec> =

162

4

                if let Some(para_id) = cmd.extra.parachain_id {

163

                    Box::new(chain_spec::local_testnet_config(

164

                        para_id.into(),

165

                        cmd.extra.add_bootnode.clone(),

166

))

167

                } else {

168

4

                    cli.load_spec(&cmd.base.chain)?

169

};

170

171

4

            cmd.base.run(chain_spec)

172

173

        Some(BaseSubcommand::CheckBlock(cmd)) => {

174

            construct_async_run!(|components, cli, cmd, config| {

175

                let (_, import_queue) = service::import_queue(&config, &components);

176

                Ok(cmd.run(components.client, import_queue))

177

})

178

179

        Some(BaseSubcommand::ExportBlocks(cmd)) => {

180

            construct_async_run!(|components, cli, cmd, config| {

181

                Ok(cmd.run(components.client, config.database))

182

})

183

184

        Some(BaseSubcommand::ExportState(cmd)) => {

185

            construct_async_run!(|components, cli, cmd, config| {

186

                Ok(cmd.run(components.client, config.chain_spec))

187

})

188

189

        Some(BaseSubcommand::ImportBlocks(cmd)) => {

190

            construct_async_run!(|components, cli, cmd, config| {

191

                let (_, import_queue) = service::import_queue(&config, &components);

192

                Ok(cmd.run(components.client, import_queue))

193

})

194

195

        Some(BaseSubcommand::Revert(cmd)) => {

196

            construct_async_run!(|components, cli, cmd, config| {

197

                Ok(cmd.run(components.client, components.backend, None))

198

})

199

200

        Some(BaseSubcommand::PurgeChain(cmd)) => {

201

            let runner = cli.create_runner(cmd)?;

202

203

            runner.sync_run(|config| {

204

                let polkadot_cli = ContainerNodeRelayChainCli::<NodeName>::new(

205

                    &config,

206

                    [ContainerNodeRelayChainCli::<NodeName>::executable_name()]

207

                        .iter()

208

                        .chain(cli.relay_chain_args.iter()),

209

);

210

211

                let polkadot_config = SubstrateCli::create_configuration(

212

                    &polkadot_cli,

213

                    &polkadot_cli,

214

                    config.tokio_handle.clone(),

215

216

                .map_err(|err| format!("Relay chain argument error: {}", err))?;

217

218

                cmd.run(config, polkadot_config)

219

})

220

221

        Some(BaseSubcommand::ExportGenesisHead(cmd)) => {

222

            let runner = cli.create_runner(cmd)?;

223

            runner.sync_run(|config| {

224

                let partials = NodeConfig::new_builder(&config, None)?;

225

                cmd.run(partials.client)

226

})

227

228

        Some(BaseSubcommand::ExportGenesisWasm(cmd)) => {

229

            let runner = cli.create_runner(cmd)?;

230

            runner.sync_run(|_config| {

231

                let spec = cli.load_spec(&cmd.shared_params.chain.clone().unwrap_or_default())?;

232

                cmd.run(&*spec)

233

})

234

235

        Some(BaseSubcommand::Benchmark(cmd)) => {

236

            let runner = cli.create_runner(cmd)?;

237

238

            // Switch on the concrete benchmark sub-command-

239

            match cmd {

240

                BenchmarkCmd::Pallet(cmd) => {

241

                    if cfg!(feature = "runtime-benchmarks") {

242

                        runner.sync_run(|config| {

243

                            cmd.run_with_spec::<sp_runtime::traits::HashingFor<Block>, ReclaimHostFunctions>(Some(

244

                                config.chain_spec,

245

))

246

})

247

                    } else {

248

                        Err("Benchmarking wasn't enabled when building the node. \

249

			  You can enable it with `--features runtime-benchmarks`."

250

                            .into())

251

252

253

                BenchmarkCmd::Block(cmd) => runner.sync_run(|config| {

254

                    let partials = NodeConfig::new_builder(&config, None)?;

255

                    cmd.run(partials.client)

256

}),

257

                #[cfg(not(feature = "runtime-benchmarks"))]

258

                BenchmarkCmd::Storage(_) => Err(sc_cli::Error::Input(

259

                    "Compile with --features=runtime-benchmarks \

260

                        to enable storage benchmarks."

261

                        .into(),

262

)),

263

                #[cfg(feature = "runtime-benchmarks")]

264

                BenchmarkCmd::Storage(cmd) => runner.sync_run(|config| {

265

                    let partials = NodeConfig::new_builder(&config, None)?;

266

                    let db = partials.backend.expose_db();

267

                    let storage = partials.backend.expose_storage();

268

                    let shared_trie_cache = partials.backend.expose_shared_trie_cache();

269

                    cmd.run(

270

                        config,

271

                        partials.client.clone(),

272

db,

273

                        storage,

274

                        shared_trie_cache,

275

276

}),

277

                BenchmarkCmd::Machine(cmd) => {

278

                    runner.sync_run(|config| cmd.run(&config, SUBSTRATE_REFERENCE_HARDWARE.clone()))

279

280

                // NOTE: this allows the Client to leniently implement

281

                // new benchmark commands without requiring a companion MR.

282

                #[allow(unreachable_patterns)]

283

                _ => Err("Benchmarking sub-command unsupported".into()),

284

285

286

2

        Some(BaseSubcommand::PrecompileWasm(cmd)) => {

287

2

            let runner = cli.create_runner(cmd)?;

288

2

            runner.async_run(|config| {

289

2

                let partials = NodeConfig::new_builder(&config, None)?;

290

2

                Ok((

291

2

                    cmd.run(partials.backend, config.chain_spec),

292

2

                    partials.task_manager,

293

2

))

294

2

})

295

296

        None => {

297

80

            let runner = cli.create_runner(&cli.run.normalize())?;

298

80

            let collator_options = cli.run.collator_options();

299

300

80

            runner.run_node_until_exit(|config| async move {

301

80

                let hwbench = (!cli.no_hardware_benchmarks).then(||

302

                    config.database.path().map(|database_path| {

303

                        let _ = std::fs::create_dir_all(database_path);

304

                        sc_sysinfo::gather_hwbench(Some(database_path), &SUBSTRATE_REFERENCE_HARDWARE)

305

80

                    })).flatten();

306

307

80

                let para_id = node_common_chain_spec::Extensions::try_get(&*config.chain_spec)

308

80

                    .map(|e| e.para_id)

309

80

                    .ok_or("Could not find parachain ID in chain-spec.")?;

310

311

80

                let polkadot_cli = ContainerNodeRelayChainCli::<NodeName>::new(

312

80

                    &config,

313

80

                    [ContainerNodeRelayChainCli::<NodeName>::executable_name()].iter().chain(cli.relay_chain_args.iter()),

314

);

315

316

80

                let extension = node_common_chain_spec::Extensions::try_get(&*config.chain_spec);

317

80

                let relay_chain_id = extension.map(|e| e.relay_chain.clone());

318

319

80

                let dev_service =

320

80

                    config.chain_spec.is_dev() || relay_chain_id == Some("dev-service".to_string());

321

322

80

                let id = ParaId::from(para_id);

323

324

80

                if dev_service {

325

80

                    return crate::service::start_dev_node(config, cli.run.sealing, id, hwbench).await

326

80

                        .map_err(Into::into);

327

328

329

330

                let parachain_account =

331

                    AccountIdConversion::<polkadot_primitives::AccountId>::into_account_truncating(&id);

332

333

                // We log both genesis states for reference, as fetching it from runtime would take significant time

334

                let block_state_v0: Block = generate_genesis_block(&*config.chain_spec, sp_runtime::StateVersion::V0)

335

                    .map_err(|e| format!("{:?}", e))?;

336

                let block_state_v1: Block = generate_genesis_block(&*config.chain_spec, sp_runtime::StateVersion::V1)

337

                    .map_err(|e| format!("{:?}", e))?;

338

339

                let genesis_state_v0 = format!("0x{:?}", HexDisplay::from(&block_state_v0.header().encode()));

340

                let genesis_state_v1 = format!("0x{:?}", HexDisplay::from(&block_state_v1.header().encode()));

341

342

                let tokio_handle = config.tokio_handle.clone();

343

                let polkadot_config =

344

                    SubstrateCli::create_configuration(&polkadot_cli, &polkadot_cli, tokio_handle)

345

                        .map_err(|err| format!("Relay chain argument error: {}", err))?;

346

347

                info!("Parachain id: {:?}", id);

348

                info!("Parachain Account: {}", parachain_account);

349

                info!("Parachain genesis state V0: {}", genesis_state_v0);

350

                info!("Parachain genesis state V1: {}", genesis_state_v1);

351

                info!("Is collating: {}", if config.role.is_authority() { "yes" } else { "no" });

352

353

                if let cumulus_client_cli::RelayChainMode::ExternalRpc(rpc_target_urls) =

354

                    collator_options.clone().relay_chain_mode {

355

                    if !rpc_target_urls.is_empty() && !cli.relay_chain_args.is_empty() {

356

                        warn!("Detected relay chain node arguments together with --relay-chain-rpc-url. This command starts a minimal Polkadot node that only uses a network-related subset of all relay chain CLI options.");

357

358

359

360

361

                match config.network.network_backend {

362

                    sc_network::config::NetworkBackendType::Libp2p => {

363

                        crate::service::start_parachain_node::<sc_network::NetworkWorker<_, _>>(

364

                            config,

365

                            polkadot_config,

366

                            collator_options,

367

id,

368

                            hwbench,

369

370

                            .await

371

                            .map(|r| r.0)

372

                            .map_err(Into::into)

373

374

                    sc_network::config::NetworkBackendType::Litep2p => {

375

                        crate::service::start_parachain_node::<sc_network::Litep2pNetworkBackend>(

376

                            config,

377

                            polkadot_config,

378

                            collator_options,

379

id,

380

                            hwbench,

381

382

                            .await

383

                            .map(|r| r.0)

384

                            .map_err(Into::into)

385

386

387

388

389

160

})

390

391

392

86

393

394

fn data_preserver_mode(cli: &Cli, cmd: &DataPreserverCmd) -> Result<()> {

395

    let runner = cli.create_runner(&cmd.container_run.normalize())?;

396

397

    runner.run_node_until_exit(|config| async move {

398

        log::info!("Starting in RPC provider mode!");

399

400

        let container_chain_cli = ContainerChainCli {

401

            base: cmd.container_run.clone(),

402

            preloaded_chain_spec: None,

403

};

404

405

        let polkadot_cli = ContainerNodeRelayChainCli::<NodeName>::new(

406

            &config,

407

            [ContainerNodeRelayChainCli::<NodeName>::executable_name()]

408

                .iter()

409

                .chain(cmd.relaychain_args().iter()),

410

);

411

412

        let mut orchestrator_cli = None;

413

        if !cmd.solochain {

414

            orchestrator_cli = Some(cumulus_client_cli::RunCmd::parse_from(

415

                [String::from("orchestrator")]

416

                    .iter()

417

                    .chain(cmd.orchestrator_chain_args().iter()),

418

));

419

420

421

        let generate_rpc_builder =

422

            tc_service_container_chain_spawner::rpc::GenerateSubstrateRpcBuilder::<

423

                container_chain_template_simple_runtime::RuntimeApi,

424

            >::new();

425

426

        DataPreserverMode {

427

            config,

428

            provider_profile_id: cmd.profile_id,

429

            orchestrator_endpoints: cmd.orchestrator_endpoints.clone(),

430

            collator_options: cmd.container_run.collator_options(),

431

            polkadot_cli,

432

            orchestrator_cli,

433

            container_chain_cli,

434

            generate_rpc_builder,

435

            phantom: PhantomData,

436

437

        .run()

438

        .await

439

})

440

441

442

#[cfg(test)]

443

mod tests {

444

    use super::*;

445

446

    #[test]

447

1

    fn same_impl_version() {

448

        // Impl version depends on version in Cargo.toml

449

        // This is to verify we didn't forget to change one of them

450

1

        let v1 = ContainerChainCli::impl_version();

451

1

        let v2 = Cli::impl_version();

452

        // Container chain nodes report the same version for relay chain side as the parachain side

453

1

        let v3 = ContainerNodeRelayChainCli::<NodeName>::impl_version();

454

455

1

        assert_eq!(v1, v2);

456

1

        assert_eq!(v1, v3);

457

1

458