raft 0.7.0

The rust language implementation of Raft algorithm.
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

use std::fmt::Write;

use crate::{default_logger, Changer, ProgressTracker};
use datadriven::{run_test, walk};
use itertools::Itertools;
use raft_proto::parse_conf_change;

#[test]
fn test_conf_change_data_driven() -> anyhow::Result<()> {
    walk("src/confchange/testdata", |path| -> anyhow::Result<()> {
        let logger = default_logger();

        let mut tr = ProgressTracker::new(10);
        let mut idx = 0;

        run_test(
            path.to_str().unwrap(),
            |data| -> String {
                let ccs = parse_conf_change(&data.input).unwrap();

                let res = match data.cmd.as_str() {
                    "simple" => Changer::new(&tr).simple(&ccs),
                    "enter-joint" => {
                        let mut auto_leave = false;
                        for arg in &data.cmd_args {
                            match arg.key.as_str() {
                                "autoleave" => {
                                    for val in &arg.vals {
                                        auto_leave = val
                                            .parse()
                                            .expect("type of autoleave should be boolean")
                                    }
                                }
                                _ => {
                                    panic!("unknown arg: {}", arg.key);
                                }
                            }
                        }
                        Changer::new(&tr).enter_joint(auto_leave, &ccs)
                    }
                    "leave-joint" => {
                        assert!(data.cmd_args.is_empty());
                        Changer::new(&tr).leave_joint()
                    }
                    _ => {
                        panic!("unknown arg: {}", data.cmd);
                    }
                };
                match res {
                    Ok((conf, changes)) => {
                        tr.apply_conf(conf, changes, idx);
                        idx += 1;
                    }
                    Err(e) => {
                        idx += 1;
                        return e.to_string();
                    }
                }

                let mut buffer = String::new();

                let conf = tr.conf();
                writeln!(buffer, "{}", conf).unwrap();

                let prs = tr.progress();

                // output with peer_id sorted
                for (k, v) in prs.iter().sorted_by(|&(k1, _), &(k2, _)| k1.cmp(k2)) {
                    write!(
                        buffer,
                        "{}: {} match={} next={}",
                        k, v.state, v.matched, v.next_idx
                    )
                    .unwrap();
                    if conf.learners.contains(k) {
                        buffer.push_str(" learner");
                    }
                    buffer.push('\n');
                }
                buffer
            },
            false,
            &logger,
        )
    })
}