viewstamped-replication 0.6.0

A Rust-based implementation of the Viewstamped Replication consensus protocol.
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
87
88
89

use crate::identifiers::ReplicaIdentifier;
use crate::stamps::View;
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;

#[derive(Copy, Clone, Debug, Default, Ord, PartialOrd, Eq, PartialEq)]
pub enum HealthStatus {
    #[default]
    Normal,
    Suspect,
    Unhealthy,
}

pub trait HealthDetector {
    fn detect(&mut self, view: View, replica: ReplicaIdentifier) -> HealthStatus;
}

impl HealthDetector for HealthStatus {
    fn detect(&mut self, _: View, _: ReplicaIdentifier) -> HealthStatus {
        *self
    }
}

#[derive(Debug, Default)]
pub struct Suspect;

impl HealthDetector for Suspect {
    fn detect(&mut self, _: View, _: ReplicaIdentifier) -> HealthStatus {
        HealthStatus::Suspect
    }
}

#[derive(Debug, Default)]
pub struct Unhealthy;

impl HealthDetector for Unhealthy {
    fn detect(&mut self, _: View, _: ReplicaIdentifier) -> HealthStatus {
        HealthStatus::Unhealthy
    }
}

#[derive(Clone, Debug, Default)]
pub struct LocalHealthDetector {
    status: Rc<RefCell<HashMap<ReplicaIdentifier, HealthStatus>>>,
}

impl LocalHealthDetector {
    pub fn set_status(&mut self, replica: ReplicaIdentifier, status: HealthStatus) {
        self.status.borrow_mut().insert(replica, status);
    }
}

impl HealthDetector for LocalHealthDetector {
    fn detect(&mut self, view: View, replica: ReplicaIdentifier) -> HealthStatus {
        self.status
            .borrow()
            .get(&replica.primary(view))
            .copied()
            .unwrap_or(HealthStatus::Normal)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::identifiers::GroupIdentifier;

    #[test]
    fn order() {
        assert!(HealthStatus::Normal < HealthStatus::Suspect);
        assert!(HealthStatus::Suspect < HealthStatus::Unhealthy);
        assert!(HealthStatus::Normal < HealthStatus::Unhealthy);
    }

    #[test]
    fn local() {
        let group = GroupIdentifier::new(3);
        let view = View::default();
        let replica = group.replicas(view).next().unwrap();
        let mut detector = LocalHealthDetector::default();
        let mut clone = detector.clone();

        clone.set_status(group.primary(view), HealthStatus::Unhealthy);

        assert_eq!(detector.detect(view, replica), HealthStatus::Unhealthy);
        assert_eq!(detector.detect(view.next(), replica), HealthStatus::Normal);
    }
}