Update serde, so TiKV can update time crate

.github/workflows/rust.yml

@@ -30,7 +30,7 @@ jobs:
         uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: nightly-2025-04-03
+          toolchain: nightly-2026-01-30
           override: true
           components: rustfmt, clippy, rust-src
       - uses: Swatinem/rust-cache@v1
@@ -92,7 +92,7 @@ jobs:
         uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: nightly-2025-04-03
+          toolchain: nightly-2026-01-30
           override: true
           components: llvm-tools-preview
       - uses: Swatinem/rust-cache@v1

Cargo.toml

@@ -2,7 +2,7 @@
 name = "raft-engine"
 version = "0.4.2"
 authors = ["The TiKV Project Developers"]
-edition = "2018"
+edition = "2024"
 rust-version = "1.85.0"
 description = "A persistent storage engine for Multi-Raft logs"
 readme = "README.md"
@@ -58,7 +58,7 @@ protobuf = "2"
 rayon = "1.5"
 rhai = { version = "1.7", features = ["sync"], optional = true }
 scopeguard = "1.1"
-serde = { version = "=1.0.194", features = ["derive"] }
+serde = { version = "1.0", features = ["derive"] }
 serde_repr = "0.1"
 strum = { version = "0.26.2", features = ["derive"] }
 thiserror = "1.0"

examples/fork.rs

@@ -1,9 +1,9 @@
 use std::path::Path;
 use std::sync::Arc;
 
-use raft_engine::env::DefaultFileSystem;
 use raft_engine::Config;
 use raft_engine::Engine;
+use raft_engine::env::DefaultFileSystem;
 
 fn main() {
     let mut args = std::env::args();

src/config.rs

@@ -4,7 +4,7 @@ use log::{info, warn};
 use serde::{Deserialize, Serialize};
 
 use crate::pipe_log::Version;
-use crate::{util::ReadableSize, Result};
+use crate::{Result, util::ReadableSize};
 
 const MIN_RECOVERY_READ_BLOCK_SIZE: usize = 512;
 const MIN_RECOVERY_THREADS: usize = 1;
@@ -343,9 +343,11 @@ mod tests {
         let mut load: Config = toml::from_str(old).unwrap();
         load.sanitize().unwrap();
         // Downgrade to older version.
-        assert!(toml::to_string(&load)
-            .unwrap()
-            .contains("tolerate-corrupted-tail-records"));
+        assert!(
+            toml::to_string(&load)
+                .unwrap()
+                .contains("tolerate-corrupted-tail-records")
+        );
     }
 
     #[test]

src/consistency.rs

@@ -2,10 +2,10 @@
 
 use hashbrown::HashMap;
 
+use crate::Result;
 use crate::file_pipe_log::ReplayMachine;
 use crate::log_batch::{LogItemBatch, LogItemContent};
 use crate::pipe_log::{FileId, LogQueue};
-use crate::Result;
 
 /// A `ConsistencyChecker` scans for log entry holes in a log queue. It will
 /// return a list of corrupted raft groups along with their last valid log

src/engine.rs

@@ -3,12 +3,12 @@
 use std::cell::{Cell, RefCell};
 use std::marker::PhantomData;
 use std::path::Path;
-use std::sync::{mpsc, Arc, Mutex};
+use std::sync::{Arc, Mutex, mpsc};
 use std::thread::{Builder as ThreadBuilder, JoinHandle};
 use std::time::{Duration, Instant};
 
 use log::{error, info};
-use protobuf::{parse_from_bytes, Message};
+use protobuf::{Message, parse_from_bytes};
 
 use crate::config::{Config, RecoveryMode};
 use crate::consistency::ConsistencyChecker;
@@ -22,7 +22,7 @@ use crate::metrics::*;
 use crate::pipe_log::{FileBlockHandle, FileId, LogQueue, PipeLog};
 use crate::purge::{PurgeHook, PurgeManager};
 use crate::write_barrier::{WriteBarrier, Writer};
-use crate::{perf_context, Error, GlobalStats, Result};
+use crate::{Error, GlobalStats, Result, perf_context};
 
 const METRICS_FLUSH_INTERVAL: Duration = Duration::from_secs(30);
 /// Max times for `write`.
@@ -106,11 +106,13 @@ where
         let memtables_clone = memtables.clone();
         let metrics_flusher = ThreadBuilder::new()
             .name("re-metrics".into())
-            .spawn(move || loop {
-                stats_clone.flush_metrics();
-                memtables_clone.flush_metrics();
-                if rx.recv_timeout(METRICS_FLUSH_INTERVAL).is_ok() {
-                    break;
+            .spawn(move || {
+                loop {
+                    stats_clone.flush_metrics();
+                    memtables_clone.flush_metrics();
+                    if rx.recv_timeout(METRICS_FLUSH_INTERVAL).is_ok() {
+                        break;
+                    }
                 }
             })?;
 
@@ -648,14 +650,14 @@ where
 pub(crate) mod tests {
     use super::*;
     use crate::env::{ObfuscatedFileSystem, Permission};
-    use crate::file_pipe_log::{parse_reserved_file_name, FileNameExt};
+    use crate::file_pipe_log::{FileNameExt, parse_reserved_file_name};
     use crate::log_batch::AtomicGroupBuilder;
     use crate::pipe_log::Version;
-    use crate::test_util::{generate_entries, PanicGuard};
+    use crate::test_util::{PanicGuard, generate_entries};
     use crate::util::ReadableSize;
     use kvproto::raft_serverpb::RaftLocalState;
     use raft::eraftpb::Entry;
-    use rand::{thread_rng, Rng};
+    use rand::{Rng, thread_rng};
     use std::collections::{BTreeSet, HashSet};
     use std::fs::OpenOptions;
     use std::path::PathBuf;
@@ -1231,9 +1233,11 @@ pub(crate) mod tests {
         // GC all log entries. Won't trigger purge because total size is not enough.
         let count = engine.compact_to(1, 100);
         assert_eq!(count, 100);
-        assert!(!engine
-            .purge_manager
-            .needs_rewrite_log_files(LogQueue::Append));
+        assert!(
+            !engine
+                .purge_manager
+                .needs_rewrite_log_files(LogQueue::Append)
+        );
 
         // Append more logs to make total size greater than `purge_threshold`.
         for index in 100..250 {
@@ -1243,9 +1247,11 @@ pub(crate) mod tests {
         // GC first 101 log entries.
         assert_eq!(engine.compact_to(1, 101), 1);
         // Needs to purge because the total size is greater than `purge_threshold`.
-        assert!(engine
-            .purge_manager
-            .needs_rewrite_log_files(LogQueue::Append));
+        assert!(
+            engine
+                .purge_manager
+                .needs_rewrite_log_files(LogQueue::Append)
+        );
 
         let old_min_file_seq = engine.file_span(LogQueue::Append).0;
         let will_force_compact = engine.purge_expired_files().unwrap();
@@ -1259,9 +1265,11 @@ pub(crate) mod tests {
 
         assert_eq!(engine.compact_to(1, 102), 1);
         // Needs to purge because the total size is greater than `purge_threshold`.
-        assert!(engine
-            .purge_manager
-            .needs_rewrite_log_files(LogQueue::Append));
+        assert!(
+            engine
+                .purge_manager
+                .needs_rewrite_log_files(LogQueue::Append)
+        );
         let will_force_compact = engine.purge_expired_files().unwrap();
         // The region needs to be force compacted because the threshold is reached.
         assert!(!will_force_compact.is_empty());
@@ -1350,9 +1358,11 @@ pub(crate) mod tests {
         engine.append(11, 1, 11, Some(&data));
 
         // The engine needs purge, and all old entries should be rewritten.
-        assert!(engine
-            .purge_manager
-            .needs_rewrite_log_files(LogQueue::Append));
+        assert!(
+            engine
+                .purge_manager
+                .needs_rewrite_log_files(LogQueue::Append)
+        );
         assert!(engine.purge_expired_files().unwrap().is_empty());
         assert!(engine.file_span(LogQueue::Append).0 > 1);
 
@@ -1386,9 +1396,11 @@ pub(crate) mod tests {
             }
         }
 
-        assert!(engine
-            .purge_manager
-            .needs_rewrite_log_files(LogQueue::Append));
+        assert!(
+            engine
+                .purge_manager
+                .needs_rewrite_log_files(LogQueue::Append)
+        );
         assert!(engine.purge_expired_files().unwrap().is_empty());
     }
 

src/env/log_fd/unix.rs

@@ -8,12 +8,12 @@ use log::error;
 use std::io::Result as IoResult;
 use std::os::unix::io::RawFd;
 
+use nix::NixPath;
 use nix::errno::Errno;
 use nix::fcntl::{self, OFlag};
 use nix::sys::stat::Mode;
 use nix::sys::uio::{pread, pwrite};
-use nix::unistd::{close, ftruncate, lseek, Whence};
-use nix::NixPath;
+use nix::unistd::{Whence, close, ftruncate, lseek};
 
 fn from_nix_error(e: nix::Error, custom: &'static str) -> std::io::Error {
     let kind = std::io::Error::from(e).kind();

src/env/obfuscated.rs

@@ -2,8 +2,8 @@
 
 use std::io::{Read, Result as IoResult, Seek, SeekFrom, Write};
 use std::path::Path;
-use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
 
 use crate::env::{DefaultFileSystem, FileSystem, Permission, WriteExt};
 

src/file_pipe_log/mod.rs

@@ -10,7 +10,7 @@ mod pipe;
 mod pipe_builder;
 mod reader;
 
-pub use format::{parse_reserved_file_name, FileNameExt};
+pub use format::{FileNameExt, parse_reserved_file_name};
 pub use pipe::DualPipes as FilePipeLog;
 pub use pipe_builder::{
     DefaultMachineFactory, DualPipesBuilder as FilePipeLogBuilder, RecoveryConfig, ReplayMachine,
@@ -173,7 +173,7 @@ pub mod debug {
         use crate::env::DefaultFileSystem;
         use crate::log_batch::{Command, LogBatch};
         use crate::pipe_log::{FileBlockHandle, LogFileContext, LogQueue, Version};
-        use crate::test_util::{generate_entries, PanicGuard};
+        use crate::test_util::{PanicGuard, generate_entries};
         use raft::eraftpb::Entry;
 
         #[test]

src/file_pipe_log/pipe.rs

@@ -19,11 +19,11 @@ use crate::metrics::*;
 use crate::pipe_log::{
     FileBlockHandle, FileId, FileSeq, LogFileContext, LogQueue, PipeLog, ReactiveBytes,
 };
-use crate::{perf_context, Error, Result};
+use crate::{Error, Result, perf_context};
 
-use super::format::{build_reserved_file_name, FileNameExt, LogFileFormat};
+use super::format::{FileNameExt, LogFileFormat, build_reserved_file_name};
 use super::log_file::build_file_reader;
-use super::log_file::{build_file_writer, LogFileWriter};
+use super::log_file::{LogFileWriter, build_file_writer};
 
 pub type PathId = usize;
 pub type Paths = Vec<PathBuf>;
@@ -614,8 +614,10 @@ mod tests {
         // Only one thread can hold file lock
         let r2 = new_test_pipes(&cfg);
 
-        assert!(format!("{}", r2.err().unwrap())
-            .contains("maybe another instance is using this directory"));
+        assert!(
+            format!("{}", r2.err().unwrap())
+                .contains("maybe another instance is using this directory")
+        );
     }
 
     #[test]

src/file_pipe_log/pipe_builder.rs

@@ -17,17 +17,17 @@ use crate::config::{Config, RecoveryMode};
 use crate::env::{FileSystem, Handle, Permission};
 use crate::errors::is_no_space_err;
 use crate::event_listener::EventListener;
-use crate::log_batch::{LogItemBatch, LOG_BATCH_HEADER_LEN};
+use crate::log_batch::{LOG_BATCH_HEADER_LEN, LogItemBatch};
 use crate::pipe_log::{FileId, FileSeq, LogQueue};
 use crate::util::{Factory, ReadableSize};
 use crate::{Error, Result};
 
 use super::format::{
-    build_reserved_file_name, lock_file_path, parse_reserved_file_name, FileNameExt, LogFileFormat,
+    FileNameExt, LogFileFormat, build_reserved_file_name, lock_file_path, parse_reserved_file_name,
 };
 use super::log_file::build_file_reader;
 use super::pipe::{
-    find_available_dir, DualPipes, File, PathId, Paths, SinglePipe, DEFAULT_FIRST_FILE_SEQ,
+    DEFAULT_FIRST_FILE_SEQ, DualPipes, File, PathId, Paths, SinglePipe, find_available_dir,
 };
 use super::reader::LogItemBatchFileReader;
 

src/file_pipe_log/reader.rs

@@ -1,12 +1,12 @@
 // Copyright 2021 TiKV Project Authors. Licensed under Apache-2.0.
 
 use crate::env::FileSystem;
-use crate::log_batch::{LogBatch, LogItemBatch, LOG_BATCH_HEADER_LEN};
+use crate::log_batch::{LOG_BATCH_HEADER_LEN, LogBatch, LogItemBatch};
 use crate::pipe_log::{FileBlockHandle, FileId, LogFileContext};
 use crate::util::round_up;
 use crate::{Error, Result};
 
-use super::format::{is_zero_padded, LogFileFormat};
+use super::format::{LogFileFormat, is_zero_padded};
 use super::log_file::LogFileReader;
 
 /// A reusable reader over [`LogItemBatch`]s in a log file.

src/filter.rs

@@ -4,8 +4,8 @@ use std::path::Path;
 use std::sync::Arc;
 
 use hashbrown::HashMap;
-use rhai::{Engine, Scope, AST};
-use scopeguard::{guard, ScopeGuard};
+use rhai::{AST, Engine, Scope};
+use scopeguard::{ScopeGuard, guard};
 
 use crate::env::FileSystem;
 use crate::file_pipe_log::debug::{build_file_reader, build_file_writer};

src/fork.rs

@@ -9,11 +9,11 @@ use std::os::unix::fs::symlink;
 #[cfg(windows)]
 use std::os::windows::fs::symlink_file as symlink;
 
+use crate::Engine;
 use crate::config::{Config, RecoveryMode};
 use crate::env::FileSystem;
 use crate::file_pipe_log::{FileNameExt, FilePipeLog, FilePipeLogBuilder};
 use crate::pipe_log::{FileId, LogQueue};
-use crate::Engine;
 
 /// Returned by `Engine::fork`.
 #[derive(Default)]

src/lib.rs

@@ -69,7 +69,7 @@ pub use config::{Config, RecoveryMode};
 pub use engine::Engine;
 pub use errors::{Error, Result};
 pub use log_batch::{Command, LogBatch, MessageExt};
-pub use metrics::{get_perf_context, set_perf_context, take_perf_context, PerfContext};
+pub use metrics::{PerfContext, get_perf_context, set_perf_context, take_perf_context};
 pub use pipe_log::Version;
 pub use util::ReadableSize;