qualia_core_db/net/peer/fabric/
select.rs1use super::carrier::{prohibited, PathClass};
4use super::evidence::PathEvidence;
5use crate::net::peer::connectivity::policy::Disclosure;
6
7pub const MAX_RANKED: usize = 8;
8
9#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10pub struct RankedPath {
11 pub index: u8,
12 pub class: PathClass,
13 pub score: i32,
14}
15
16pub fn exclude_then_rank(
18 disclosure: Disclosure,
19 live_generation: u32,
20 rows: &[PathEvidence],
21 out: &mut [RankedPath],
22) -> usize {
23 let mut n = 0usize;
24 let mut i = 0usize;
25 while i < rows.len() {
26 let e = rows[i];
27 if prohibited(disclosure, e.class)
28 || !e.validated()
29 || e.stale_generation(live_generation)
30 || n >= out.len()
31 || n >= MAX_RANKED
32 {
33 i += 1;
34 continue;
35 }
36 let rtt = if e.rtt_ms > 60_000 { 60_000 } else { e.rtt_ms };
37 let score = (i32::from(e.max_payload) / 8) - (rtt as i32);
38 out[n] = RankedPath {
39 index: i as u8,
40 class: e.class,
41 score,
42 };
43 n += 1;
44 i += 1;
45 }
46 let mut a = 0usize;
47 while a + 1 < n {
48 let mut b = a + 1;
49 while b < n {
50 if out[b].score > out[a].score {
51 let t = out[a];
52 out[a] = out[b];
53 out[b] = t;
54 }
55 b += 1;
56 }
57 a += 1;
58 }
59 n
60}
61
62#[cfg(test)]
63mod tests {
64 use super::*;
65 use crate::net::peer::fabric::evidence::TransportWitness;
66
67 fn local(class: PathClass, rtt: u32) -> PathEvidence {
68 PathEvidence::from_witness(TransportWitness::from_local(class, 1, 1152, rtt, 10))
69 }
70
71 #[test]
72 fn faster_direct_cannot_beat_relay_only_policy() {
73 let rows = [local(PathClass::DirectV6, 1), local(PathClass::Relayed, 50)];
74 let mut out = [RankedPath {
75 index: 0,
76 class: PathClass::Offline,
77 score: 0,
78 }; MAX_RANKED];
79 let n = exclude_then_rank(Disclosure::ApprovedRelaysOnly, 1, &rows, &mut out);
80 assert_eq!(n, 1);
81 assert_eq!(out[0].class, PathClass::Relayed);
82 }
83
84 #[test]
85 fn ordinary_prefers_faster_validated_direct() {
86 let rows = [local(PathClass::Relayed, 50), local(PathClass::DirectV6, 1)];
87 let mut out = [RankedPath {
88 index: 0,
89 class: PathClass::Offline,
90 score: 0,
91 }; MAX_RANKED];
92 let n = exclude_then_rank(Disclosure::DirectPermitted, 1, &rows, &mut out);
93 assert_eq!(n, 2);
94 assert_eq!(out[0].class, PathClass::DirectV6);
95 }
96}