*: Update rust toolchain to nightly-2025-04-03 (#18416)

ref #17465

Following #17605, another attempt to update rust toolchain

Changes:

- Language
  - After rust-lang/rust#134258, we can't manually impl both `ToString` and `fmt::Display`, so this PR add a new trait `ToStringValue` to work around types type produces different result between ToString and Display.
- Clippy
  - `Option::map_or(false, ...)` --> `Option::is_some_and(...)`
  - `Option::map_or(true, ...)` --> `Option::is_none_or(...)`
  - `(a + b - 1 )/ b` --> `a.div_ceil(b)`
  - `io::Error::new(ErrorKind::Other, ...)` --> ` io::Error::other(...)`
  - `Slice::group_by` --> `Slice::chunk_by`
  - `Result::map_err(|e| {...; e})` --> `Result::inspect_err(|e| { ... })`
  - `Map::get(&key).is_{some, none}()` --> `Map::contains_key()`
- Formatter
  - The import order now follows ascii order, e.g. before is "use crate::{a, b, c, A, B, C}", after is "use crate::{A, B, C, a, b, c}". Most changes are due to this.
  - List in rust doc should be properly aligned.
- cargo-deny
  - `vulnerability`, `notice` and `unsound` can't be config in version 2, and `unmaintained` can't be allowed anymore(but support setting `workspace` to allow indirected pkgs). So replacing some unmaintained packages with suggested alternatives.  (See: #18416)

Signed-off-by: glorv <[email protected]>

Author: glorv

Cargo.lock

@@ -1,9 +1,9 @@
 // Copyright 2021 TiKV Project Authors. Licensed under Apache-2.0.
 
-use std::{borrow::ToOwned, str, string::ToString, sync::LazyLock, u64};
+use std::{borrow::ToOwned, str, string::ToString, sync::LazyLock};
 
-use clap::{crate_authors, AppSettings};
-use engine_traits::{SstCompressionType, CF_DEFAULT};
+use clap::{AppSettings, crate_authors};
+use engine_traits::{CF_DEFAULT, SstCompressionType};
 use raft_engine::ReadableSize;
 use structopt::StructOpt;
 

cmd/tikv-ctl/src/cmd.rs

@@ -9,15 +9,15 @@ use api_version::{ApiV1, KvFormat};
 use encryption_export::data_key_manager_from_config;
 use engine_rocks::util::{db_exist, new_engine_opt};
 use engine_traits::{
-    Engines, Error as EngineError, RaftEngine, TabletRegistry, ALL_CFS, CF_DEFAULT, CF_LOCK,
-    CF_WRITE, DATA_CFS,
+    ALL_CFS, CF_DEFAULT, CF_LOCK, CF_WRITE, DATA_CFS, Engines, Error as EngineError, RaftEngine,
+    TabletRegistry,
 };
 use file_system::read_dir;
 use futures::{
+    StreamExt, TryStreamExt,
     executor::block_on,
     future,
     stream::{self, BoxStream},
-    StreamExt, TryStreamExt,
 };
 use grpcio::{ChannelBuilder, Environment};
 use kvproto::{
@@ -31,23 +31,23 @@ use pd_client::{Config as PdConfig, PdClient, RpcClient};
 use protobuf::Message;
 use raft::eraftpb::{ConfChange, ConfChangeV2, Entry, EntryType};
 use raft_log_engine::RaftLogEngine;
-use raftstore::store::{util::build_key_range, INIT_EPOCH_CONF_VER};
+use raftstore::store::{INIT_EPOCH_CONF_VER, util::build_key_range};
 use security::SecurityManager;
 use serde_json::json;
 use server::fatal;
 use slog_global::crit;
 use tikv::{
     config::{ConfigController, TikvConfig},
     server::{
+        KvEngineFactoryBuilder,
         debug::{BottommostLevelCompaction, Debugger, DebuggerImpl, RegionInfo},
         debug2::DebuggerImplV2,
-        KvEngineFactoryBuilder,
     },
     storage::{
+        Engine,
         config::EngineType,
         kv::MockEngine,
         lock_manager::{LockManager, MockLockManager},
-        Engine,
     },
 };
 use tikv_util::escape;
@@ -223,7 +223,7 @@ pub trait DebugExecutor {
             let r = self.get_region_info(region_id);
             if skip_tombstone {
                 let region_state = r.region_local_state.as_ref();
-                if region_state.map_or(false, |s| s.get_state() == PeerState::Tombstone) {
+                if region_state.is_some_and(|s| s.get_state() == PeerState::Tombstone) {
                     continue;
                 }
             }
@@ -386,21 +386,21 @@ pub trait DebugExecutor {
                     println!("key: {}", escape(&key));
                     if cfs.contains(&CF_LOCK) && mvcc.has_lock() {
                         let lock_info = mvcc.get_lock();
-                        if start_ts.map_or(true, |ts| lock_info.get_start_ts() == ts) {
+                        if start_ts.is_none_or(|ts| lock_info.get_start_ts() == ts) {
                             println!("\tlock cf value: {:?}", lock_info);
                         }
                     }
                     if cfs.contains(&CF_DEFAULT) {
                         for value_info in mvcc.get_values() {
-                            if commit_ts.map_or(true, |ts| value_info.get_start_ts() == ts) {
+                            if commit_ts.is_none_or(|ts| value_info.get_start_ts() == ts) {
                                 println!("\tdefault cf value: {:?}", value_info);
                             }
                         }
                     }
                     if cfs.contains(&CF_WRITE) {
                         for write_info in mvcc.get_writes() {
-                            if start_ts.map_or(true, |ts| write_info.get_start_ts() == ts)
-                                && commit_ts.map_or(true, |ts| write_info.get_commit_ts() == ts)
+                            if start_ts.is_none_or(|ts| write_info.get_start_ts() == ts)
+                                && commit_ts.is_none_or(|ts| write_info.get_commit_ts() == ts)
                             {
                                 println!("\t write cf value: {:?}", write_info);
                             }

cmd/tikv-ctl/src/executor.rs

@@ -8,7 +8,7 @@ use std::{
 };
 
 use encryption_export::data_key_manager_from_config;
-use raft_engine::{env::DefaultFileSystem, Engine as RaftEngine};
+use raft_engine::{Engine as RaftEngine, env::DefaultFileSystem};
 use regex::Regex;
 use tikv::config::TikvConfig;
 

cmd/tikv-ctl/src/fork_readonly_tikv.rs

@@ -1,6 +1,5 @@
 // Copyright 2016 TiKV Project Authors. Licensed under Apache-2.0.
 
-#![feature(lazy_cell)]
 #![feature(let_chains)]
 
 #[macro_use]
@@ -16,19 +15,19 @@ use std::{
     sync::{Arc, Mutex, RwLock},
     thread,
     time::Duration,
-    u64,
 };
 
 use collections::HashMap;
 use compact_log_backup::{
+    TraceResultExt,
     exec_hooks::{self as compact_log_hooks, skip_small_compaction::SkipSmallCompaction},
-    execute as compact_log, TraceResultExt,
+    execute as compact_log,
 };
 use crypto::fips;
 use encryption_export::{
-    create_backend, data_key_manager_from_config, DataKeyManager, DecrypterReader, Iv,
+    DataKeyManager, DecrypterReader, Iv, create_backend, data_key_manager_from_config,
 };
-use engine_rocks::{get_env, util::new_engine_opt, RocksEngine};
+use engine_rocks::{RocksEngine, get_env, util::new_engine_opt};
 use engine_traits::Peekable;
 use file_system::calc_crc32;
 use futures::{executor::block_on, future::try_join_all};
@@ -49,16 +48,16 @@ use raft_log_engine::ManagedFileSystem;
 use raftstore::store::util::build_key_range;
 use regex::Regex;
 use security::{SecurityConfig, SecurityManager};
-use structopt::{clap::ErrorKind, StructOpt};
+use structopt::{StructOpt, clap::ErrorKind};
 use tempfile::TempDir;
 use tikv::{
     config::TikvConfig,
-    server::{debug::BottommostLevelCompaction, KvEngineFactoryBuilder},
+    server::{KvEngineFactoryBuilder, debug::BottommostLevelCompaction},
     storage::config::EngineType,
 };
 use tikv_util::{
     escape,
-    logger::{get_log_level, Level},
+    logger::{Level, get_log_level},
     run_and_wait_child_process,
     sys::thread::StdThreadBuildWrapper,
     unescape, warn,
@@ -1292,6 +1291,9 @@ fn print_bad_ssts(data_dir: &str, manifest: Option<&str>, pd_client: RpcClient,
     stderr_buf.read_to_end(&mut buffer).unwrap();
     let corruptions = unsafe { String::from_utf8_unchecked(buffer) };
 
+    let r = Regex::new(r"/\w*\.sst").unwrap();
+    let column_r = Regex::new(r"--------------- (.*) --------------\n(.*)").unwrap();
+    let sst_stat_r = Regex::new(r".*\n\d+:\d+\[\d+ .. \d+\]\['(\w*)' seq:\d+, type:\d+ .. '(\w*)' seq:\d+, type:\d+\] at level \d+").unwrap();
     for line in corruptions.lines() {
         println!("--------------------------------------------------------");
         // The corruption format may like this:
@@ -1300,7 +1302,6 @@ fn print_bad_ssts(data_dir: &str, manifest: Option<&str>, pd_client: RpcClient,
         // ```
         println!("corruption info:\n{}", line);
 
-        let r = Regex::new(r"/\w*\.sst").unwrap();
         let sst_file_number = match r.captures(line) {
             None => {
                 println!("skip bad line format");
@@ -1361,15 +1362,13 @@ fn print_bad_ssts(data_dir: &str, manifest: Option<&str>, pd_client: RpcClient,
         // --------------- Column family "write"  (ID 2) --------------
         // 63:132906243[3555338 .. 3555338]['7A311B40EFCC2CB4C5911ECF3937D728DED26AE53FA5E61BE04F23F2BE54EACC73' seq:3555338, type:1 .. '7A313030302E25CD5F57252E' seq:3555338, type:1] at level 0
         // ```
-        let column_r = Regex::new(r"--------------- (.*) --------------\n(.*)").unwrap();
         if let Some(m) = column_r.captures(&output) {
             println!(
                 "{} for {}",
                 m.get(2).unwrap().as_str(),
                 m.get(1).unwrap().as_str()
             );
-            let r = Regex::new(r".*\n\d+:\d+\[\d+ .. \d+\]\['(\w*)' seq:\d+, type:\d+ .. '(\w*)' seq:\d+, type:\d+\] at level \d+").unwrap();
-            let matches = match r.captures(&output) {
+            let matches = match sst_stat_r.captures(&output) {
                 None => {
                     println!("sst start key format is not correct: {}", output);
                     continue;

cmd/tikv-ctl/src/main.rs

@@ -1,6 +1,6 @@
 // Copyright 2021 TiKV Project Authors. Licensed under Apache-2.0.
 
-use std::{borrow::ToOwned, error::Error, str, str::FromStr, u64};
+use std::{borrow::ToOwned, error::Error, str, str::FromStr};
 
 use kvproto::kvrpcpb::KeyRange;
 use server::setup::initial_logger;

cmd/tikv-ctl/src/util.rs

@@ -4,12 +4,12 @@
 
 use std::{path::Path, process};
 
-use clap::{crate_authors, App, Arg};
+use clap::{App, Arg, crate_authors};
 use crypto::fips;
 use serde_json::{Map, Value};
 use server::setup::{ensure_no_unrecognized_config, validate_and_persist_config};
 use tikv::{
-    config::{to_flatten_config_info, TikvConfig},
+    config::{TikvConfig, to_flatten_config_info},
     storage::config::EngineType,
 };
 

cmd/tikv-server/src/main.rs

@@ -4,8 +4,8 @@ use engine_traits::Result;
 use tikv_util::{
     box_err,
     codec::{
-        number::{self, NumberEncoder},
         Error,
+        number::{self, NumberEncoder},
     },
 };
 

components/api_version/src/api_v1ttl.rs

@@ -3,9 +3,8 @@
 use codec::byte::MemComparableByteCodec;
 use engine_traits::Result;
 use tikv_util::codec::{
-    bytes,
+    Error, bytes,
     number::{self, NumberEncoder},
-    Error,
 };
 use txn_types::{Key, TimeStamp};
 

components/api_version/src/api_v2.rs

@@ -259,7 +259,7 @@ impl<T: AsRef<[u8]>> RawValue<T> {
     #[inline]
     pub fn is_ttl_expired(&self, current_ts: u64) -> bool {
         self.expire_ts
-            .map_or(false, |expire_ts| expire_ts <= current_ts)
+            .is_some_and(|expire_ts| expire_ts <= current_ts)
     }
 }