lol-core 0.9.5

A Raft implementation in Rust language.
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

use futures::stream::futures_unordered::FuturesUnordered;
use futures::stream::StreamExt;
use std::future::Future;

/// Execute futures and returns ok only when quorum replied ok.
pub async fn quorum_join(
    quorum: usize,
    futs: Vec<impl Future<Output = bool> + Send + 'static>,
) -> bool {
    let n = futs.len();
    if n < quorum {
        return false;
    }
    assert!(n >= quorum);
    if n == 0 && quorum == 0 {
        return true;
    }

    let queue = FuturesUnordered::new();
    for fut in futs {
        queue.push(fut);
    }
    futures::pin_mut!(queue);
    let mut ack = 0;
    let mut ok = 0;
    while let Some(x) = queue.next().await {
        ack += 1;
        if x {
            ok += 1;
        }
        if ok >= quorum {
            return true;
        }
        if ack == n {
            return false;
        }
    }
    false
}

#[cfg(test)]
mod tests {
    use super::*;
    async fn f(b: bool) -> bool {
        b
    }
    #[tokio::test]
    async fn test_quorum_join_ok() {
        let futs = vec![f(true), f(false), f(true)];
        let ok = quorum_join(2, futs).await;
        assert!(ok);
    }
    #[tokio::test]
    async fn test_quorum_join_ng() {
        let futs = vec![f(true), f(false), f(false)];
        let ok = quorum_join(2, futs).await;
        assert!(!ok);
    }
}