minerva 0.2.0

Causal ordering for distributed systems
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

use super::quorum::Quorum;
use crate::kairos::Kairos;
use crate::metis::{And, AndProgress, Causal, Event, Ideal, VersionVector};
use core::cmp::Ordering;

fn vv(entries: impl IntoIterator<Item = (u32, u64)>) -> VersionVector {
    let mut vector = VersionVector::new();
    for (station, counter) in entries {
        vector.observe(station, counter);
    }
    vector
}

#[test]
fn test_and_progress_uses_the_product_order() {
    let bottom = AndProgress::new(1, 2);
    let equal = AndProgress::new(1, 2);
    let above_left = AndProgress::new(2, 2);
    let above_both = AndProgress::new(2, 3);
    let crossed = AndProgress::new(0, 3);

    assert_eq!(bottom.partial_cmp(&equal), Some(Ordering::Equal));
    assert_eq!(bottom.partial_cmp(&above_left), Some(Ordering::Less));
    assert_eq!(bottom.partial_cmp(&above_both), Some(Ordering::Less));
    assert_eq!(bottom.partial_cmp(&crossed), None);
    assert_eq!(bottom.into_parts(), (1, 2));
}

#[test]
fn test_and_holds_back_until_both_gates_admit() {
    let mut buffer: Ideal<&str, And<Causal, Quorum>> = Ideal::default();
    buffer.insert(Event {
        stamp: Kairos::new(10, 0, 1, 0u16),
        deps: (vv([(1, 1)]), 2),
        payload: "held",
    });
    buffer.insert(Event {
        stamp: Kairos::new(20, 0, 2, 0u16),
        deps: (vv([(2, 1)]), 0),
        payload: "first",
    });
    buffer.insert(Event {
        stamp: Kairos::new(30, 0, 3, 0u16),
        deps: (vv([(3, 1)]), 0),
        payload: "second",
    });

    assert_eq!(buffer.pop_ready(), Some("first"));
    assert_eq!(buffer.pop_ready(), Some("second"));
    assert_eq!(buffer.pop_ready(), Some("held"));
    assert_eq!(buffer.pop_ready(), None);

    let (causal, quorum) = buffer.progress().clone().into_parts();
    assert_eq!(causal, vv([(1, 1), (2, 1), (3, 1)]));
    assert_eq!(quorum, vv([(1, 1), (2, 1), (3, 1)]));
}