decdn-node 0.1.0

The deCDN node daemon (decdn-node): runtime, request handlers, payment settlement, and the admin RPC server
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
119
120

use super::*;
use crate::load_shed::{LoadShedPolicy, PressureSnapshot, RequestClass, ShedDecision, ShedReason};

fn params() -> Params {
    Params {
        egress_budget_bps: 1_000,
        max_serves_high: 100,
        max_serves_low: 80,
        per_client_cap: 10,
    }
}
fn snap(n: u32, c: u32, bps: u64) -> PressureSnapshot {
    PressureSnapshot {
        streams_in_flight: n,
        client_streams_in_flight: c,
        egress_bps: bps,
    }
}

#[test]
fn admits_everything_below_high_water_and_under_budget() {
    let p = ResourcePressure::new(params());
    assert_eq!(
        p.decide(RequestClass::CacheMiss, &snap(50, 9, 500)),
        ShedDecision::Admit
    );
    assert_eq!(
        p.decide(RequestClass::CacheHit, &snap(50, 9, 500)),
        ShedDecision::Admit
    );
    assert!(!p.pressure_active());
}

#[test]
fn lone_client_is_never_capped_at_low_load() {
    // Fairness invariant: no speculative reservation. A single client with
    // many streams but below high-water is not capped.
    let p = ResourcePressure::new(params());
    assert_eq!(
        p.decide(RequestClass::CacheMiss, &snap(50, 50, 500)),
        ShedDecision::Admit
    );
}

#[test]
fn sheds_miss_first_above_high_water_but_keeps_hits() {
    let p = ResourcePressure::new(params());
    // Cross the high-water mark.
    assert_eq!(
        p.decide(RequestClass::CacheMiss, &snap(120, 1, 500)),
        ShedDecision::Shed(ShedReason::NodeAtCapacity)
    );
    // Hit still admitted while egress is under budget.
    assert_eq!(
        p.decide(RequestClass::CacheHit, &snap(120, 1, 500)),
        ShedDecision::Admit
    );
    assert!(p.pressure_active());
}

#[test]
fn egress_saturation_sheds_even_hits() {
    let p = ResourcePressure::new(params());
    assert_eq!(
        p.decide(RequestClass::CacheHit, &snap(50, 1, 1_000)),
        ShedDecision::Shed(ShedReason::EgressSaturated)
    );
}

#[test]
fn per_client_cap_engages_only_under_pressure() {
    let p = ResourcePressure::new(params());
    // Trip pressure, then a client over its share is shed even for a hit.
    assert_eq!(
        p.decide(RequestClass::CacheHit, &snap(120, 10, 500)),
        ShedDecision::Shed(ShedReason::ClientAtCapacity)
    );
}

#[test]
fn hysteresis_holds_pressure_between_the_marks() {
    let p = ResourcePressure::new(params());
    // Trip at high-water.
    let _ = p.decide(RequestClass::CacheMiss, &snap(100, 1, 500));
    assert!(p.pressure_active());
    // Between low and high: still pressured (no flap), so miss still sheds.
    assert_eq!(
        p.decide(RequestClass::CacheMiss, &snap(90, 1, 500)),
        ShedDecision::Shed(ShedReason::NodeAtCapacity)
    );
    // Drop to/below low-water: pressure clears, miss admits again.
    assert_eq!(
        p.decide(RequestClass::CacheMiss, &snap(80, 1, 500)),
        ShedDecision::Admit
    );
    assert!(!p.pressure_active());
}

#[test]
fn zero_budget_disables_egress_ceiling() {
    let mut pr = params();
    pr.egress_budget_bps = 0;
    let p = ResourcePressure::new(pr);
    assert_eq!(
        p.decide(RequestClass::CacheHit, &snap(50, 1, u64::MAX)),
        ShedDecision::Admit
    );
}

#[test]
fn zero_per_client_cap_disables_client_fairness() {
    let mut pr = params();
    pr.per_client_cap = 0;
    let p = ResourcePressure::new(pr);
    // Pressured, huge client count, but per-client disabled: a hit still admits.
    assert_eq!(
        p.decide(RequestClass::CacheHit, &snap(120, 9_999, 500)),
        ShedDecision::Admit
    );
}