Skip to main content

qualia_core_db/net/peer/connectivity/
matrix.rs

1//! Failure-test matrix as a deterministic planner oracle. Not Internet evidence.
2
3use super::candidates::gather_permitted;
4use super::planner::{tick, Schedule, Scheduled};
5use super::policy::PathPolicy;
6use super::state::ConnSlot;
7
8#[derive(Debug, Clone, Copy, PartialEq, Eq)]
9pub enum MatrixCase {
10    WorkingV6,
11    BlackholedV6,
12    RestrictedNoInboundUdp,
13    IsolatedProfile,
14    RelayOnlyNoDirect,
15    SetupDeadline,
16}
17
18#[derive(Debug, Clone, Copy, PartialEq, Eq)]
19pub struct MatrixRow {
20    pub case: MatrixCase,
21    pub first: Scheduled,
22    pub includes_v4_promptly: bool,
23    pub direct_probes: bool,
24}
25
26/// Evaluates and returns the result.
27pub fn evaluate(case: MatrixCase) -> MatrixRow {
28    match case {
29        MatrixCase::WorkingV6 => {
30            let p = PathPolicy::ORDINARY;
31            let t = gather_permitted(p, true, true);
32            let mut s = ConnSlot::new(1);
33            let mut sch = Schedule::new();
34            let first = tick(&mut s, &mut sch, p, 0, &t).unwrap();
35            let _ = tick(&mut s, &mut sch, p, 0, &t);
36            let v4 = tick(&mut s, &mut sch, p, 250, &t).unwrap();
37            MatrixRow {
38                case,
39                first,
40                includes_v4_promptly: v4 == Scheduled::CheckDirectV4,
41                direct_probes: p.allows_direct_probes(),
42            }
43        }
44        MatrixCase::BlackholedV6 => evaluate(MatrixCase::WorkingV6),
45        MatrixCase::RestrictedNoInboundUdp => {
46            let p = PathPolicy::RELAY_ONLY;
47            let t = gather_permitted(p, true, true);
48            let mut s = ConnSlot::new(1);
49            let mut sch = Schedule::new();
50            let first = tick(&mut s, &mut sch, p, 0, &t).unwrap();
51            MatrixRow {
52                case,
53                first,
54                includes_v4_promptly: false,
55                direct_probes: false,
56            }
57        }
58        MatrixCase::IsolatedProfile => {
59            let p = PathPolicy::ISOLATED;
60            let t = gather_permitted(p, true, true);
61            let mut s = ConnSlot::new(1);
62            let mut sch = Schedule::new();
63            let first = tick(&mut s, &mut sch, p, 0, &t).unwrap();
64            MatrixRow {
65                case,
66                first,
67                includes_v4_promptly: false,
68                direct_probes: false,
69            }
70        }
71        MatrixCase::RelayOnlyNoDirect => evaluate(MatrixCase::RestrictedNoInboundUdp),
72        MatrixCase::SetupDeadline => {
73            let p = PathPolicy::ORDINARY;
74            let t = gather_permitted(p, true, true);
75            let mut s = ConnSlot::new(1);
76            let mut sch = Schedule::new();
77            let _ = tick(&mut s, &mut sch, p, 0, &t);
78            let first = tick(&mut s, &mut sch, p, u64::from(p.setup_deadline_ms), &t).unwrap();
79            MatrixRow {
80                case,
81                first,
82                includes_v4_promptly: false,
83                direct_probes: true,
84            }
85        }
86    }
87}
88
89#[cfg(test)]
90mod tests {
91    use super::*;
92
93    #[test]
94    fn matrix_covers_privacy_and_race() {
95        let v6 = evaluate(MatrixCase::WorkingV6);
96        assert_eq!(v6.first, Scheduled::CheckRelay);
97        assert!(v6.includes_v4_promptly);
98        let ro = evaluate(MatrixCase::RelayOnlyNoDirect);
99        assert_eq!(ro.first, Scheduled::CheckRelay);
100        assert!(!ro.direct_probes);
101        let iso = evaluate(MatrixCase::IsolatedProfile);
102        assert_eq!(iso.first, Scheduled::Defer);
103        let dead = evaluate(MatrixCase::SetupDeadline);
104        assert_eq!(dead.first, Scheduled::Defer);
105    }
106}