Skip to main content

qualia_core_db/net/peer/fabric/
experiments.rs

1//! Named falsifiable experiments from the fabric design ยง7.
2
3use super::carrier::PathClass;
4use super::connect::{connect, drive, Fabric};
5use super::contact::ContactDescriptor;
6use super::intent::{ProtectionPolicy, Purpose};
7use super::kernel::{FabricState, KernelEffect, KernelEvent};
8use super::lease::RelayLease;
9use super::receipt::ReceiptStatus;
10use crate::net::peer::runtime::ResourceBudget;
11
12fn budget() -> ResourceBudget {
13    ResourceBudget {
14        bytes: 1024,
15        work: 4,
16        io: 4,
17    }
18}
19
20/// Valid signature, old generation: do not probe the locator.
21pub fn compromised_discovery_stale() -> KernelEffect {
22    let mut f = Fabric::new();
23    connect(
24        &mut f,
25        [9u8; 32],
26        Purpose::ordinary(),
27        ProtectionPolicy::RELAY_ONLY,
28        budget(),
29        0,
30        8_000,
31    )
32    .unwrap();
33    let last = ContactDescriptor::mailbox([9u8; 32], 5, 2_000_000_000);
34    f.kernel.note_contact(&last);
35    let stale = ContactDescriptor::mailbox([9u8; 32], 3, 2_000_000_000);
36    assert!(stale.is_stale(f.kernel.last_contact_generation));
37    f.kernel.step(
38        KernelEvent::Descriptor {
39            stale: stale.is_stale(f.kernel.last_contact_generation),
40            expired: false,
41            direct_locator: stale.is_direct_locator(),
42        },
43        1,
44    )
45}
46
47/// Lease expiry mid-transfer queues the remainder and does not enlarge the cap.
48pub fn lease_expiry_mid_transfer() -> (u64, FabricState) {
49    let mut lease = RelayLease::grant(3, 1, [1u8; 32], [2u8; 32], 32, 100, 1, false);
50    assert!(lease.charge(16, 10).is_ok());
51    lease.expiry_ms = 10;
52    assert!(lease.charge(8, 11).is_err());
53    assert_eq!(lease.remaining_bytes, 16);
54    let mut f = Fabric::new();
55    connect(
56        &mut f,
57        [2u8; 32],
58        Purpose::ordinary(),
59        ProtectionPolicy::RELAY_ONLY,
60        budget(),
61        0,
62        8_000,
63    )
64    .unwrap();
65    drive(&mut f, KernelEvent::LeaseLive, 1);
66    drive(&mut f, KernelEvent::LeaseExpired, 11);
67    (lease.remaining_bytes, f.kernel.state)
68}
69
70/// Interface change while direct probing is forbidden: probe count stays zero.
71pub fn network_switch_relay_only() -> u32 {
72    let mut f = Fabric::new();
73    connect(
74        &mut f,
75        [4u8; 32],
76        Purpose::ordinary(),
77        ProtectionPolicy::RELAY_ONLY,
78        budget(),
79        0,
80        8_000,
81    )
82    .unwrap();
83    drive(
84        &mut f,
85        KernelEvent::Descriptor {
86            stale: false,
87            expired: false,
88            direct_locator: false,
89        },
90        1,
91    );
92    drive(&mut f, KernelEvent::LeaseLive, 1);
93    drive(
94        &mut f,
95        KernelEvent::PathValidated {
96            class: PathClass::Relayed,
97        },
98        2,
99    );
100    let before = f.kernel.direct_probe_count;
101    drive(&mut f, KernelEvent::NetworkGenerationChanged, 3);
102    assert_eq!(before, 0);
103    f.kernel.direct_probe_count
104}
105
106/// Queued mutation after grant revocation cannot commit.
107pub fn revoked_grant_replay() -> ReceiptStatus {
108    let mut f = Fabric::new();
109    connect(
110        &mut f,
111        [8u8; 32],
112        Purpose::ordinary(),
113        ProtectionPolicy::ISOLATED,
114        budget(),
115        0,
116        8_000,
117    )
118    .unwrap();
119    let i = f.enqueue(77, [0x11u8; 32], [8u8; 32], 500).unwrap();
120    drive(&mut f, KernelEvent::GrantRevoked, 2);
121    f.replay(i, 77, &[0x11u8; 32], 10).unwrap()
122}
123
124#[cfg(test)]
125mod tests {
126    use super::*;
127
128    #[test]
129    fn experiment_compromised_discovery() {
130        assert_eq!(compromised_discovery_stale(), KernelEffect::Deny);
131    }
132
133    #[test]
134    fn experiment_lease_expiry() {
135        let (left, state) = lease_expiry_mid_transfer();
136        assert_eq!(left, 16);
137        assert_eq!(state, FabricState::OfflineQueued);
138    }
139
140    #[test]
141    fn experiment_network_switch() {
142        assert_eq!(network_switch_relay_only(), 0);
143    }
144
145    #[test]
146    fn experiment_revoked_replay() {
147        assert_eq!(revoked_grant_replay(), ReceiptStatus::Denied);
148    }
149}