hydracache 0.48.0

User-facing HydraCache runtime crate.
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use hydracache::{
    CasResult, ClusterEpoch, ConditionalError, ConsistencyLevel, SingleKeyConditionalStore,
};

fn store() -> SingleKeyConditionalStore {
    SingleKeyConditionalStore::new(ClusterEpoch::new(1), 16)
}

#[test]
fn conditional_writes_compare_and_set_applies_only_on_match() {
    let mut store = store();

    let first = store
        .compare_and_set("job:1", None, b"queued".to_vec(), ConsistencyLevel::Quorum)
        .unwrap();
    let mismatch = store
        .compare_and_set(
            "job:1",
            Some(b"running"),
            b"done".to_vec(),
            ConsistencyLevel::Quorum,
        )
        .unwrap();

    assert_eq!(first, CasResult::Applied { new_version: 1 });
    assert!(matches!(mismatch, CasResult::Mismatch { .. }));
    assert_eq!(store.metrics().cas_applied_total, 1);
    assert_eq!(store.metrics().cas_mismatch_total, 1);
}

#[test]
fn conditional_writes_put_if_absent_is_linearizable_under_contention() {
    let mut store = store();
    let mut applied = 0;

    for contender in 0..10 {
        if matches!(
            store
                .put_if_absent("leader", vec![contender], ConsistencyLevel::EachQuorum)
                .unwrap(),
            CasResult::Applied { .. }
        ) {
            applied += 1;
        }
    }

    assert_eq!(applied, 1);
    assert_eq!(store.metrics().cas_applied_total, 1);
    assert_eq!(store.metrics().cas_mismatch_total, 9);
}

#[test]
fn conditional_writes_cas_at_consistency_one_is_refused() {
    let mut store = store();

    let error = store
        .compare_and_set("job:1", None, b"queued".to_vec(), ConsistencyLevel::One)
        .expect_err("One cannot provide a linearizable CAS");

    assert_eq!(
        error,
        ConditionalError::WeakConsistency {
            level: ConsistencyLevel::One
        }
    );
}

#[test]
fn conditional_writes_multi_key_conditional_is_rejected_loud() {
    let error = SingleKeyConditionalStore::reject_multi_key(["a", "b"])
        .expect_err("multi-key CAS must stay out of scope");

    assert_eq!(error, ConditionalError::MultiKeyRejected { key_count: 2 });
}

#[test]
fn conditional_writes_fenced_lock_rejects_stale_token() {
    let mut store = store();
    let first = store
        .try_acquire_lock("lock:refresh", ConsistencyLevel::Quorum)
        .unwrap()
        .expect("first lock acquisition succeeds");
    let second = store
        .force_acquire_lock("lock:refresh", ConsistencyLevel::Quorum)
        .unwrap();

    assert!(second > first);
    assert!(matches!(
        store.validate_fence_token("lock:refresh", first),
        Err(ConditionalError::StaleFenceToken { .. })
    ));
    assert_eq!(store.metrics().lock_stale_token_rejected_total, 1);
}

#[test]
fn conditional_writes_cas_respects_tombstone_version() {
    let mut store = store();
    store.apply_tombstone("job:1", 5);

    let result = store
        .put_if_absent("job:1", b"reborn".to_vec(), ConsistencyLevel::All)
        .unwrap();

    assert_eq!(result, CasResult::Applied { new_version: 6 });
    assert_eq!(store.record("job:1").map(|record| record.version), Some(6));
}

#[test]
#[ignore = "chaos marker: lock survives partition via partition-home authority"]
fn conditional_writes_lock_survives_partition_via_raft_authority() {
    let mut store = store();
    let token = store
        .try_acquire_lock("lock:refresh", ConsistencyLevel::Quorum)
        .unwrap()
        .expect("lock acquired before simulated partition");

    assert!(store.release_lock("lock:refresh", token).is_ok());
}