1
2
3

	When we began to build TiKV, we researched and investigated many Raft implementations. We eventually decided to go with etcd’s Raft implementation and built our own [Raft](https://github.com/pingcap/raft-rs) using [Rust](https://www.rust-lang.org/),
	
	Although etcd’s Raft implementation is written in Go, it has a simple API with no specific Go feature, thus can be easily ported to Rust.

1
2
3
4
5
6
7
8
9

curl https://sh.rustup.rs -sSf | sh
export PATH="/workspace/.cargo/bin:$PATH"
source  ~/.bashrc
rustc -V

//02--Rust toolchain
rustup toolchain install nightly

rustc 1.80.0 (051478957 2024-07-21)

1
2

rustup component add clippy
rustup component add rustfmt

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

cargo run  //首先对项目进行编译， 然后再运行 cargo build
cargo run --release 提高运行速度  
./target/release/world_hello

当项目大了后，cargo run 和 cargo build 不可避免的会变慢，那么有没有更快的方式来验证代码的正确性呢？
cargo check //快速的检查一下代码能否编译通过

cargo test --all && \  
cargo clippy --all --all-targets -- -D clippy::all   && \ 
//用于捕捉常见错误和改进 Rust 代码
// Clippy 是一个 Rust 代码的静态分析工具，
//用于检测代码中的潜在错误、不规范的代码风格以及其他问题

//`--all`：这个选项告诉 Clippy 检查所有的包，包括依赖的包
//`--all-targets`：这个选项指示 Clippy 不仅检查库代码，还会检查所有的二进制目标（

// 并禁用 Clippy 的所有默认 lints，例如当开发者想要使用 Clippy 检查代码，但又不想受到 Clippy 默认 lints 的限制时
cargo fmt --all -- --check    //通过 rustfmt 自动格式化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

cargo watch -s "cargo check"

gitpod /workspace/raft-rs (master) $ cargo watch -s "cargo check"
[Running 'cargo check']
    Checking crossbeam-utils v0.8.20
   Compiling raft-proto v0.7.0 (/workspace/raft-rs/proto)
    Checking crossbeam-channel v0.5.13
    Checking slog-async v2.8.0
    Checking slog-envlogger v2.2.0
    Checking raft v0.7.0 (/workspace/raft-rs)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 2.76s
[Finished running. Exit status: 0]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

let (mut tx_vec, mut rx_vec) = (Vec::new(), Vec::new());

impl<T> Vec<T> {

    /// Constructs a new, empty `Vec<T>`.

    ///

    /// The vector will not allocate until elements are pushed onto it.

    ///

    /// # Examples

    // 方法的参数并没有 &self
    pub const fn new() -> Self {

        Vec { buf: RawVec::NEW, len: 0 }

    }

1
2
3
4
5

 let (tx_stop, rx_stop) = mpsc::channel();
 
 pub fn channel<T>() -> (Sender<T>, Receiver<T>)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

 let proposals: Arc<Mutex<VecDeque<Proposal>>> = Arc::clone(&proposals);

  
  Stack                    Heap
  -----                    ----


  annas:
+--------+               +------------+
| ptr: o-|-------------->| count: 3   |
+--------+    ^          | data: 🐢   |
              |          +------------+
 peters:      |
+--------+    |
| ptr: o-|----+
+--------+    ^
              |
  bobs:       |
+--------+    |
| ptr: o-|----+
+--------+

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

pub enum Result<T, E> {

    /// Contains the success value

    #[lang = "Ok"]

    #[stable(feature = "rust1", since = "1.0.0")]

    Ok(#[stable(feature = "rust1", since = "1.0.0")] T),

  

    /// Contains the error value

    #[lang = "Err"]

    #[stable(feature = "rust1", since = "1.0.0")]

    Err(#[stable(feature = "rust1", since = "1.0.0")] E),

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

struct Proposal {

    normal: Option<(u16, String)>, // key is an u16 integer, and value is a string.

    conf_change: Option<ConfChange>, // conf change.

    transfer_leader: Option<u64>,

    // If it's proposed, it will be set to the index of the entry.

    proposed: u64,

    propose_success: SyncSender<bool>,

}