sorock 0.12.0

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

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

pub async fn join(quorum: usize, futs: Vec<impl Future<Output = bool> + Send + 'static>) -> bool {
    let n = futs.len();

    if n < quorum {
        return false;
    }

    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;
        }
        // FIXME Do we need this check?
        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 = 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 = join(2, futs).await;
        assert!(!ok);
    }
}