Merge branch 'develop' into zhangsoledad/fix-txpool-proposal

Author: zhangsoledad

.github/workflows/release-plz.yml

@@ -14,6 +14,15 @@ jobs:
       contents: write
       id-token: write
     steps:
+      - &free-up-disk-space
+        name: Free up disk space
+        if: github.repository_owner != 'nervosnetwork'
+        run: |
+          sudo rm -rf /usr/share/dotnet
+          sudo rm -rf /usr/local/lib/android
+          sudo rm -rf /opt/ghc
+          sudo rm -rf /opt/hostedtoolcache/CodeQL
+          sudo docker image prune --all --force
       - &checkout
         name: Checkout repository
         uses: actions/checkout@v6
@@ -51,6 +60,7 @@ jobs:
       group: release-plz-${{ github.ref }}
       cancel-in-progress: false
     steps:
+      - *free-up-disk-space
       - *checkout
       - *install-rust
       - *generate-token

Cargo.lock

@@ -11,6 +11,9 @@ repository = "https://github.com/nervosnetwork/ckb"
 rust-version = "1.92.0"
 default-run = "ckb"
 
+[package.metadata.binstall]
+bin-dir = "{ name }_v{ version }_{ target }/{ bin }{ binary-ext }"
+
 [[bin]]
 name = "ckb"
 path = "src/main.rs"
@@ -134,7 +137,7 @@ blake2b-ref = "0.3"
 bloom-filters = "0.1"
 bs58 = "0.5.0"
 byteorder = "1.3.1"
-bytes = "1"
+bytes = "1.11.1"
 cfg-if = "1.0"
 ckb-app-config = { path = "util/app-config", version = "1" }
 ckb-async-runtime = { path = "util/runtime", version = "1" }

Cargo.toml

@@ -40,6 +40,7 @@ ckb-async-runtime.workspace = true
 ckb-migrate.workspace = true
 ckb-launcher.workspace = true
 ckb-constant.workspace = true
+ckb-logger-config.workspace = true
 base64.workspace = true
 tempfile.workspace = true
 rayon.workspace = true
@@ -48,6 +49,7 @@ is-terminal.workspace = true
 fdlimit.workspace = true
 ckb-stop-handler.workspace = true
 tokio = { workspace = true, features = ["sync"] }
+time = { workspace = true }
 
 [target.'cfg(not(target_os="windows"))'.dependencies]
 daemonize-me = { version = "2" }

ckb-bin/Cargo.toml

@@ -12,12 +12,13 @@ mod tests;
 use ckb_app_config::ExitCode;
 use ckb_async_runtime::new_global_runtime;
 use ckb_build_info::Version;
-use ckb_logger::{debug, info};
+use ckb_logger::debug;
 use ckb_network::tokio;
 use clap::ArgMatches;
 use helper::raise_fd_limit;
 use setup::Setup;
 use setup_guard::SetupGuard;
+use time::OffsetDateTime;
 
 #[cfg(not(target_os = "windows"))]
 use colored::Colorize;
@@ -28,6 +29,26 @@ use subcommand::check_process;
 #[cfg(feature = "with_sentry")]
 pub(crate) const LOG_TARGET_SENTRY: &str = "sentry";
 
+/// Print a log-like message to stderr.
+/// Format: `YYYY-MM-DD HH:MM:SS.mmm +00:00 thread_name INFO module  message`
+fn log_println(message: &str) {
+    let now = OffsetDateTime::now_utc();
+    let thread = std::thread::current();
+    let thread_name = thread.name().unwrap_or("main");
+    eprintln!(
+        "{:04}-{:02}-{:02} {:02}:{:02}:{:02}.{:03} +00:00 {} INFO ckb_bin  {}",
+        now.year(),
+        now.month() as u8,
+        now.day(),
+        now.hour(),
+        now.minute(),
+        now.second(),
+        now.millisecond(),
+        thread_name,
+        message
+    );
+}
+
 /// The executable main entry.
 ///
 /// It returns `Ok` when the process exist normally, otherwise the `ExitCode` is converted to the
@@ -109,11 +130,11 @@ fn run_app_in_daemon(
 
     match daemon.start() {
         Ok(_) => {
-            info!("Success, daemonized ...");
+            ckb_logger::info!("Success, daemonized ...");
             run_app_inner(version, bin_name, cmd, matches)
         }
         Err(e) => {
-            info!("daemonize error: {}", e);
+            ckb_logger::info!("daemonize error: {}", e);
             Err(ExitCode::Failure)
         }
     }
@@ -128,12 +149,21 @@ fn run_app_inner(
     let is_silent_logging = is_silent_logging(cmd);
     let (mut handle, mut handle_stop_rx, _runtime) = new_global_runtime(None);
     let setup = Setup::from_matches(bin_name, cmd, matches)?;
-    let _guard = SetupGuard::from_setup(&setup, &version, handle.clone(), is_silent_logging)?;
+    // Disable logging here if the user is executing `ckb run`.
+    // Logs subscription of RPC service requires access to `struct Shared`,
+    // so logger of `ckb run` will be initialized in `subcommand::run`.
+    let (_guard, log_config) = SetupGuard::from_setup(
+        &setup,
+        &version,
+        handle.clone(),
+        is_silent_logging,
+        cmd != cli::CMD_RUN,
+    )?;
 
     raise_fd_limit();
 
     let ret = match cmd {
-        cli::CMD_RUN => subcommand::run(setup.run(matches)?, version, handle.clone()),
+        cli::CMD_RUN => subcommand::run(setup.run(matches)?, version, handle.clone(), log_config),
         cli::CMD_MINER => subcommand::miner(setup.miner(matches)?, handle.clone()),
         cli::CMD_REPLAY => subcommand::replay(setup.replay(matches)?, handle.clone()),
         cli::CMD_EXPORT => subcommand::export(setup.export(matches)?, handle.clone()),
@@ -150,9 +180,18 @@ fn run_app_inner(
         handle.drop_guard();
 
         tokio::task::block_in_place(|| {
-            info!("Waiting for all tokio tasks to exit...");
+            // Here we use `log_println` instead of `info!` because the Logger has already been
+            // shut down when `subcommand::run()` returned (LoggerGuard was dropped there).
+            //
+            // We cannot simply extend the LoggerGuard's lifetime to here because it would cause
+            // a deadlock: NotifyController (held by Logger's background thread) contains a clone
+            // of Handle, which holds a clone of `guard` (Sender). If LoggerGuard is not dropped
+            // before `handle_stop_rx.blocking_recv()`, the Logger thread won't terminate, and
+            // the Sender inside NotifyController won't be dropped, causing blocking_recv() to
+            // wait forever.
+            log_println("Waiting for all tokio tasks to exit...");
             handle_stop_rx.blocking_recv();
-            info!("All tokio tasks and threads have exited. CKB shutdown");
+            log_println("All tokio tasks and threads have exited. CKB shutdown");
         });
     }
 

ckb-bin/src/lib.rs

@@ -6,10 +6,10 @@ use ckb_metrics_service::{self, Guard as MetricsInitGuard};
 
 use crate::setup::Setup;
 
-const CKB_LOG_ENV: &str = "CKB_LOG";
+pub const CKB_LOG_ENV: &str = "CKB_LOG";
 
 pub struct SetupGuard {
-    _logger_guard: LoggerInitGuard,
+    _logger_guard: Option<LoggerInitGuard>,
     #[cfg(feature = "with_sentry")]
     _sentry_guard: Option<sentry::ClientInitGuard>,
     _metrics_guard: MetricsInitGuard,
@@ -22,18 +22,23 @@ impl SetupGuard {
         version: &Version,
         async_handle: Handle,
         silent_logging: bool,
-    ) -> Result<Self, ExitCode> {
+        enable_logging: bool,
+    ) -> Result<(Self, ckb_logger_config::Config), ExitCode> {
         // Initialization of logger must do before sentry, since `logger::init()` and
         // `sentry_config::init()` both registers custom panic hooks, but `logger::init()`
         // replaces all hooks previously registered.
-        let logger_guard = if silent_logging {
-            ckb_logger_service::init_silent()?
+        let logger_guard = if enable_logging {
+            Some(if silent_logging {
+                ckb_logger_service::init_silent()?
+            } else {
+                let mut logger_config = setup.config.logger().to_owned();
+                if logger_config.emit_sentry_breadcrumbs.is_none() {
+                    logger_config.emit_sentry_breadcrumbs = Some(setup.is_sentry_enabled);
+                }
+                ckb_logger_service::init(Some(CKB_LOG_ENV), logger_config, None)?
+            })
         } else {
-            let mut logger_config = setup.config.logger().to_owned();
-            if logger_config.emit_sentry_breadcrumbs.is_none() {
-                logger_config.emit_sentry_breadcrumbs = Some(setup.is_sentry_enabled);
-            }
-            ckb_logger_service::init(Some(CKB_LOG_ENV), logger_config)?
+            None
         };
 
         let sentry_guard = if setup.is_sentry_enabled {
@@ -67,11 +72,14 @@ impl SetupGuard {
                 ExitCode::Config
             })?;
 
-        Ok(Self {
-            _logger_guard: logger_guard,
-            _sentry_guard: sentry_guard,
-            _metrics_guard: metrics_guard,
-        })
+        Ok((
+            Self {
+                _logger_guard: logger_guard,
+                _sentry_guard: sentry_guard,
+                _metrics_guard: metrics_guard,
+            },
+            setup.config.logger().to_owned(),
+        ))
     }
 
     #[cfg(not(feature = "with_sentry"))]
@@ -80,12 +88,18 @@ impl SetupGuard {
         _version: &Version,
         async_handle: Handle,
         silent_logging: bool,
-    ) -> Result<Self, ExitCode> {
-        let logger_guard = if silent_logging {
-            ckb_logger_service::init_silent()?
+        // For ckb run, logging can be disabled here, since it requires `Shared` to create a logger that will be used for `ckb run`
+        enable_logging: bool,
+    ) -> Result<(Self, ckb_logger_config::Config), ExitCode> {
+        let logger_guard = if enable_logging {
+            Some(if silent_logging {
+                ckb_logger_service::init_silent()?
+            } else {
+                let logger_config = setup.config.logger().to_owned();
+                ckb_logger_service::init(Some(CKB_LOG_ENV), logger_config, None)?
+            })
         } else {
-            let logger_config = setup.config.logger().to_owned();
-            ckb_logger_service::init(Some(CKB_LOG_ENV), logger_config)?
+            None
         };
 
         let metrics_config = setup.config.metrics().to_owned();
@@ -95,9 +109,12 @@ impl SetupGuard {
                 ExitCode::Config
             })?;
 
-        Ok(Self {
-            _logger_guard: logger_guard,
-            _metrics_guard: metrics_guard,
-        })
+        Ok((
+            Self {
+                _logger_guard: logger_guard,
+                _metrics_guard: metrics_guard,
+            },
+            setup.config.logger().to_owned(),
+        ))
     }
 }