qualia_core_db/net/peer/fabric/
experiments.rs1use 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
20pub 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
47pub 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
70pub 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
106pub 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}