atomr_cluster/
sbr.rs

1//! Split-brain resolvers.
2//!
3//! Five strategies are implemented matching :
4//! * KeepMajority
5//! * StaticQuorum
6//! * KeepOldest
7//! * KeepReferee
8//! * LeaseMajority
9
10use crate::member::{Member, MemberStatus};
11
12/// What the resolver recommends the cluster do with the given side.
13#[derive(Debug, Clone, PartialEq, Eq)]
14#[non_exhaustive]
15pub enum DowningDecision {
16    DownUnreachable,
17    DownAll,
18    DownSelf,
19    Stay,
20}
21
22pub trait DowningStrategy: Send + Sync {
23    fn decide(&self, reachable: &[&Member], unreachable: &[&Member]) -> DowningDecision;
24}
25
26/// KeepMajority: the side with strictly more up members survives.
27#[derive(Debug, Clone, Copy, Default)]
28pub struct KeepMajorityStrategy;
29
30impl DowningStrategy for KeepMajorityStrategy {
31    fn decide(&self, r: &[&Member], u: &[&Member]) -> DowningDecision {
32        let up = |ms: &[&Member]| ms.iter().filter(|m| m.status == MemberStatus::Up).count();
33        let rn = up(r);
34        let un = up(u);
35        if rn > un {
36            DowningDecision::DownUnreachable
37        } else if rn < un {
38            DowningDecision::DownSelf
39        } else {
40            DowningDecision::DownAll
41        }
42    }
43}
44
45/// StaticQuorum: requires at least `quorum_size` reachable members to survive.
46#[derive(Debug, Clone, Copy)]
47pub struct StaticQuorumStrategy {
48    pub quorum_size: usize,
49}
50
51impl DowningStrategy for StaticQuorumStrategy {
52    fn decide(&self, r: &[&Member], _: &[&Member]) -> DowningDecision {
53        if r.len() >= self.quorum_size {
54            DowningDecision::DownUnreachable
55        } else {
56            DowningDecision::DownSelf
57        }
58    }
59}
60
61/// KeepOldest: the side containing the oldest (lowest `up_number`) up member survives.
62#[derive(Debug, Clone, Copy, Default)]
63pub struct KeepOldestStrategy {
64    pub down_if_alone: bool,
65}
66
67impl DowningStrategy for KeepOldestStrategy {
68    fn decide(&self, r: &[&Member], u: &[&Member]) -> DowningDecision {
69        fn oldest<'a>(ms: &[&'a Member]) -> Option<&'a Member> {
70            ms.iter().min_by_key(|m| m.up_number).copied()
71        }
72        let rolds = oldest(r);
73        let uolds = oldest(u);
74        match (rolds, uolds) {
75            (Some(ro), Some(uo)) => {
76                if ro.up_number <= uo.up_number {
77                    if r.len() == 1 && self.down_if_alone {
78                        DowningDecision::DownAll
79                    } else {
80                        DowningDecision::DownUnreachable
81                    }
82                } else {
83                    DowningDecision::DownSelf
84                }
85            }
86            (Some(_), None) => DowningDecision::DownUnreachable,
87            (None, Some(_)) => DowningDecision::DownSelf,
88            (None, None) => DowningDecision::Stay,
89        }
90    }
91}
92
93/// KeepReferee: the side containing the designated `referee` member survives.
94#[derive(Debug, Clone)]
95pub struct KeepReferee {
96    pub referee: String,
97    pub down_all_if_less_than: usize,
98}
99
100impl DowningStrategy for KeepReferee {
101    fn decide(&self, r: &[&Member], _u: &[&Member]) -> DowningDecision {
102        let has_referee = r.iter().any(|m| m.address.to_string() == self.referee);
103        if !has_referee {
104            return DowningDecision::DownSelf;
105        }
106        if r.len() < self.down_all_if_less_than {
107            DowningDecision::DownAll
108        } else {
109            DowningDecision::DownUnreachable
110        }
111    }
112}
113
114/// LeaseMajority: majority decision gated by an external lease. In-memory
115/// simulation of whether a lease was acquired.
116#[derive(Debug, Clone, Copy, Default)]
117pub struct LeaseMajorityStrategy {
118    pub lease_acquired: bool,
119}
120
121impl DowningStrategy for LeaseMajorityStrategy {
122    fn decide(&self, r: &[&Member], u: &[&Member]) -> DowningDecision {
123        let m = KeepMajorityStrategy.decide(r, u);
124        match m {
125            DowningDecision::DownAll if self.lease_acquired => DowningDecision::DownUnreachable,
126            other => other,
127        }
128    }
129}
130
131/// Facade that holds any of the strategies behind a trait object.
132pub struct SplitBrainResolver {
133    pub strategy: Box<dyn DowningStrategy>,
134}
135
136impl SplitBrainResolver {
137    pub fn new(strategy: Box<dyn DowningStrategy>) -> Self {
138        Self { strategy }
139    }
140    pub fn decide(&self, r: &[&Member], u: &[&Member]) -> DowningDecision {
141        self.strategy.decide(r, u)
142    }
143}
144
145#[cfg(test)]
146mod tests {
147    use super::*;
148    use atomr_core::actor::Address;
149
150    fn up(n: i32) -> Member {
151        let mut m = Member::new(Address::local(format!("N{n}")), vec![]);
152        m.status = MemberStatus::Up;
153        m.up_number = n;
154        m
155    }
156
157    #[test]
158    fn keep_majority_prefers_larger_side() {
159        let r = [up(1), up(2), up(3)];
160        let u = [up(4)];
161        let r_ref: Vec<&Member> = r.iter().collect();
162        let u_ref: Vec<&Member> = u.iter().collect();
163        assert_eq!(KeepMajorityStrategy.decide(&r_ref, &u_ref), DowningDecision::DownUnreachable);
164    }
165
166    #[test]
167    fn static_quorum_enforces_size() {
168        let r = [up(1)];
169        let u = [up(2)];
170        let r_ref: Vec<&Member> = r.iter().collect();
171        let u_ref: Vec<&Member> = u.iter().collect();
172        assert_eq!(StaticQuorumStrategy { quorum_size: 2 }.decide(&r_ref, &u_ref), DowningDecision::DownSelf);
173    }
174
175    #[test]
176    fn keep_oldest_picks_lowest_up_number() {
177        let r = [up(1)];
178        let u = [up(2), up(3)];
179        let r_ref: Vec<&Member> = r.iter().collect();
180        let u_ref: Vec<&Member> = u.iter().collect();
181        assert_eq!(KeepOldestStrategy::default().decide(&r_ref, &u_ref), DowningDecision::DownUnreachable);
182    }
183}
atomr_cluster/sbr.rs

atomr_cluster/
sbr.rs
