ckb-bin 1.1.0

CKB executable
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use std::thread::available_parallelism;

use crate::helper::deadlock_detection;
use crate::setup_guard::CKB_LOG_ENV;
use ckb_app_config::{ExitCode, RunArgs};
use ckb_async_runtime::{Handle, new_global_runtime};
use ckb_build_info::Version;
use ckb_launcher::Launcher;
use ckb_logger::info;
use ckb_logger::warn;
use ckb_resource::{Resource, TemplateContext};

use ckb_stop_handler::{broadcast_exit_signals, wait_all_ckb_services_exit};

use ckb_types::core::cell::setup_system_cell_cache;

pub fn run(
    args: RunArgs,
    version: Version,
    async_handle: Handle,
    log_config: ckb_logger_config::Config,
) -> Result<(), ExitCode> {
    check_default_db_options_exists(&args)?;
    deadlock_detection();

    let rpc_threads_num = calc_rpc_threads_num(&args);
    let (mut rpc_handle, _rpc_stop_rx, _runtime) = new_global_runtime(Some(rpc_threads_num));
    let launcher = Launcher::new(args, version.clone(), async_handle, rpc_handle.clone());

    let block_assembler_config = launcher.sanitize_block_assembler_config()?;
    let miner_enable = block_assembler_config.is_some();

    launcher.check_indexer_config()?;

    let (shared, mut pack) = launcher.build_shared(block_assembler_config)?;
    let _logger_guard = ckb_logger_service::init(
        Some(CKB_LOG_ENV),
        log_config,
        Some(shared.notify_controller().clone()),
    )?;

    info!("ckb version: {}", version);
    info!("run rpc server with {} threads", rpc_threads_num);

    // spawn freezer background process
    let _freezer = shared.spawn_freeze();

    setup_system_cell_cache(
        shared.consensus().genesis_block(),
        shared.snapshot().as_ref(),
    )
    .expect("SYSTEM_CELL cache init once");

    rayon::ThreadPoolBuilder::new()
        .thread_name(|i| format!("RayonGlobal-{i}"))
        .build_global()
        .expect("Init the global thread pool for rayon failed");

    ckb_memory_tracker::track_current_process(
        launcher.args.config.memory_tracker.interval,
        Some(shared.store().db().inner()),
    );

    let chain_controller =
        launcher.start_chain_service(&shared, pack.take_chain_services_builder());

    launcher.start_block_filter(&shared);

    let network_controller = launcher.start_network_and_rpc(
        &shared,
        chain_controller,
        miner_enable,
        pack.take_relay_tx_receiver(),
    );

    let tx_pool_builder = pack.take_tx_pool_builder();
    tx_pool_builder.start(network_controller);

    info!("CKB service started ...");
    ctrlc::set_handler(|| {
        info!("Trapped exit signal, exiting...");
        broadcast_exit_signals();
    })
    .expect("Error setting Ctrl-C handler");

    rpc_handle.drop_guard();
    wait_all_ckb_services_exit();

    Ok(())
}

fn calc_rpc_threads_num(args: &RunArgs) -> usize {
    let system_parallelism: usize = available_parallelism().unwrap().into();
    let default_num = usize::max(system_parallelism, 1);
    args.config.rpc.threads.unwrap_or(default_num)
}

fn check_default_db_options_exists(args: &RunArgs) -> Result<(), ExitCode> {
    // check is there a default.db-options file exist in args.config.root_dir, if not, create one.
    let db_options_path = args.config.root_dir.join("default.db-options");

    // Check if the default.db-options file exists, if not, create one.
    if !db_options_path.exists() {
        warn!(
            "default.db-options file does not exist in {}, creating one.",
            args.config.root_dir.display()
        );
        // context_for_db_options is used to generate a default default.db-options file.
        let context_for_db_options = TemplateContext::new("", vec![]);

        // Attempt to export the bundled DB options to the specified path.
        Resource::bundled_db_options()
            .export(&context_for_db_options, &args.config.root_dir)
            .map_err(|_| ExitCode::Config)?;
    }
    Ok(())
}