fn print_node_infos(&self) {

        info!("{}", C::impl_name());

        info!("✌️  version {}", C::impl_version());

        info!(

            "❤️  by {}, {}-{}",

            C::author(),

            C::copyright_start_year(),

            Local::now().year()

        info!("🏷  Node name: {}", self.config.network_node_name);

        info!("👤 Role: {}", self.config.role);

        info!(

            "💾 Database: {} at {}",

            // Container chains only support paritydb

            "ParityDb",

            // Print base path instead of db path because each container will have its own db in a

            // different subdirectory.

            self.config.base_path.path().display(),

    }

    pub fn run_node_until_exit<F, E>(

        self,

        initialize: impl FnOnce(SolochainConfig) -> F,

    ) -> std::result::Result<(), E>

    where

        F: Future<Output = std::result::Result<TaskManager, E>>,

        E: std::error::Error + Send + Sync + 'static + From<sc_service::Error>,

    {

        self.print_node_infos();

        let mut task_manager = self.tokio_runtime.block_on(initialize(self.config))?;

        let res = self

            .tokio_runtime

            .block_on(self.signals.run_until_signal(task_manager.future().fuse()));

        // We need to drop the task manager here to inform all tasks that they should shut down.

        //

        // This is important to be done before we instruct the tokio runtime to shutdown. Otherwise

        // the tokio runtime will wait the full 60 seconds for all tasks to stop.

        let task_registry = task_manager.into_task_registry();

        // Give all futures 60 seconds to shutdown, before tokio "leaks" them.

        let shutdown_timeout = Duration::from_secs(60);

        self.tokio_runtime.shutdown_timeout(shutdown_timeout);

        let running_tasks = task_registry.running_tasks();

        if !running_tasks.is_empty() {

            log::error!("Detected running(potentially stalled) tasks on shutdown:");

            running_tasks.iter().for_each(|(task, count)| {

                let instances_desc = if *count > 1 {

                    format!("with {} instances ", count)

                    "".to_string()

                if task.is_default_group() {

                    log::error!(

                        "Task \"{}\" was still running {}after waiting {} seconds to finish.",

                        task.name,

                        instances_desc,

                        shutdown_timeout.as_secs(),

                    log::error!(

						"Task \"{}\" (Group: {}) was still running {}after waiting {} seconds to finish.",

						task.name,

						task.group,

						instances_desc,

						shutdown_timeout.as_secs(),

            });

        }

        res.map_err(Into::into)

    }

pub fn create_runner<T: CliConfiguration<DVC>, DVC: DefaultConfigurationValues>(

    command: &T,

) -> sc_cli::Result<SolochainRunner> {

    let tokio_runtime = sc_cli::build_runtime()?;

    let signals = tokio_runtime.block_on(async { Signals::capture() })?;

    init_cmd(command, &Cli::support_url(), &Cli::impl_version())?;

    let base_path = command.base_path()?.unwrap();

    let network_node_name = command.node_name()?;

    let is_dev = command.is_dev()?;

    let role = command.role(is_dev)?;

    let relay_chain_id = "dancelight_local_testnet".to_string();

    let config = SolochainConfig {

        tokio_handle: tokio_runtime.handle().clone(),

        base_path,

        network_node_name,

        role,

        relay_chain: relay_chain_id,

    };

    Ok(SolochainRunner {

        config,

        tokio_runtime,

        signals,

    })

}

fn init_cmd<T: CliConfiguration<DVC>, DVC: DefaultConfigurationValues>(

    this: &T,

    support_url: &String,

    impl_version: &String,

) -> sc_cli::Result<()> {

    sp_panic_handler::set(support_url, impl_version);

    let mut logger = LoggerBuilder::new(this.log_filters()?);

    logger

        .with_log_reloading(this.enable_log_reloading()?)

        .with_detailed_output(this.detailed_log_output()?);

    if let Some(tracing_targets) = this.tracing_targets()? {

        let tracing_receiver = this.tracing_receiver()?;

        logger.with_profiling(tracing_receiver, tracing_targets);

    }

    if this.disable_log_color()? {

        logger.with_colors(false);

    }

    logger.init()?;

    match fdlimit::raise_fd_limit() {

        Ok(fdlimit::Outcome::LimitRaised { to, .. }) => {

            if to < RECOMMENDED_OPEN_FILE_DESCRIPTOR_LIMIT {

                warn!(

                    "Low open file descriptor limit configured for the process. \

                        Current value: {:?}, recommended value: {:?}.",

            }

        Ok(fdlimit::Outcome::Unsupported) => {

            // Unsupported platform (non-Linux)

        }

        Err(error) => {

            warn!(

                "Failed to configure file descriptor limit for the process: \

                    {}, recommended value: {:?}.",

    Ok(())

}

pub fn relay_chain_cli_new<'a>(

    config: &SolochainConfig,

    relay_chain_args: impl Iterator<Item = &'a String>,

) -> RelayChainCli {

    let base_path = config.base_path.path().join("polkadot");

    RelayChainCli {

        base_path,

        chain_id: Some(config.relay_chain.clone()),

        base: clap::Parser::parse_from(relay_chain_args),

    }

}

pub fn dummy_config(tokio_handle: tokio::runtime::Handle, base_path: BasePath) -> Configuration {

    Configuration {

        impl_name: "".to_string(),

        impl_version: "".to_string(),

        role: Role::Full,

        tokio_handle,

        transaction_pool: Default::default(),

        network: NetworkConfiguration {

            net_config_path: None,

            listen_addresses: vec![],

            public_addresses: vec![],

            boot_nodes: vec![],

            node_key: Default::default(),

            default_peers_set: Default::default(),

            default_peers_set_num_full: 0,

            client_version: "".to_string(),

            node_name: "".to_string(),

            transport: TransportConfig::MemoryOnly,

            max_parallel_downloads: 0,

            max_blocks_per_request: 0,

            sync_mode: Default::default(),

            enable_dht_random_walk: false,

            allow_non_globals_in_dht: false,

            kademlia_disjoint_query_paths: false,

            kademlia_replication_factor: NonZeroUsize::new(20).unwrap(),

            ipfs_server: false,

            network_backend: Some(NetworkBackendType::Libp2p),

        },

        keystore: KeystoreConfig::InMemory,

        database: DatabaseSource::ParityDb {

            path: Default::default(),

        },

        trie_cache_maximum_size: None,

        state_pruning: None,

        blocks_pruning: BlocksPruning::KeepAll,

        chain_spec: Box::new(

            GenericChainSpec::<NoExtension, ()>::builder(Default::default(), NoExtension::None)

                .with_name("test")

                .with_id("test_id")

                .with_chain_type(ChainType::Development)

                .with_genesis_config_patch(Default::default())

                .build(),

        ),

        executor: ExecutorConfiguration {

            wasm_method: Default::default(),

            wasmtime_precompiled: None,

            default_heap_pages: None,

            max_runtime_instances: 0,

            runtime_cache_size: 0,

        },

        wasm_runtime_overrides: None,

        rpc: sc_service::config::RpcConfiguration {

            addr: None,

            max_connections: 0,

            cors: None,

            methods: Default::default(),

            max_request_size: 0,

            max_response_size: 0,

            id_provider: None,

            max_subs_per_conn: 0,

            port: 0,

            message_buffer_capacity: 0,

            batch_config: BatchRequestConfig::Disabled,

            rate_limit: None,

            rate_limit_whitelisted_ips: vec![],

            rate_limit_trust_proxy_headers: false,

        },

        prometheus_config: None,

        telemetry_endpoints: None,

        offchain_worker: Default::default(),

        force_authoring: false,

        disable_grandpa: false,

        dev_key_seed: None,

        tracing_targets: None,

        tracing_receiver: Default::default(),

        announce_block: false,

        data_path: Default::default(),

        base_path,

    }

}

pub(crate) fn build_solochain_config_dir(base_path: &PathBuf) -> PathBuf {

    // base_path:  Collator1000-01/data/containers

    // config_dir: Collator1000-01/data/config

    let mut base_path = base_path.clone();

    base_path.pop();

    base_path.join("config")

}

pub fn keystore_config(

    keystore_params: Option<&sc_cli::KeystoreParams>,

    config_dir: &PathBuf,

) -> sc_cli::Result<KeystoreConfig> {

    keystore_params

        .map(|x| x.keystore_config(config_dir))

        .unwrap_or_else(|| Ok(KeystoreConfig::InMemory))

}

fn zombienet_keystore_path(keystore: &KeystoreConfig) -> PathBuf {

    let keystore_path = keystore.path().unwrap();

    let mut zombienet_path = keystore_path.to_owned();

    // Collator1000-01/data/config/keystore/

    zombienet_path.pop();

    // Collator1000-01/data/config/

    zombienet_path.pop();

    // Collator1000-01/data/

    zombienet_path.push("chains/simple_container_2000/keystore/");

    // Collator1000-01/data/chains/simple_container_2000/keystore/

    zombienet_path

}

pub fn copy_zombienet_keystore(keystore: &KeystoreConfig) -> std::io::Result<()> {

    let keystore_path = keystore.path().unwrap();

    let zombienet_path = zombienet_keystore_path(keystore);

    if zombienet_path.exists() {

        let mut files_copied = 0;

        copy_dir_all(zombienet_path, keystore_path, &mut files_copied)?;

        log::info!("Copied {} keys from zombienet keystore", files_copied);

        Ok(())

        Ok(())

}

fn copy_dir_all(

    src: impl AsRef<Path>,

    dst: impl AsRef<Path>,

    files_copied: &mut u32,

) -> std::io::Result<()> {

    fs::create_dir_all(&dst)?;

    for entry in fs::read_dir(src)? {

        let entry = entry?;

        let ty = entry.file_type()?;

        if ty.is_dir() {

            copy_dir_all(

                entry.path(),

                dst.as_ref().join(entry.file_name()),

                files_copied,

            )?;

            fs::copy(entry.path(), dst.as_ref().join(entry.file_name()))?;

            *files_copied += 1;

    Ok(())

}