source_budget.rs (6272B)
1 use std::sync::Mutex; 2 3 pub(crate) const MAX_EVENT_BYTES: usize = radroots_event_codec::decode::MAX_EVENT_JSON_BYTES; 4 pub(crate) const MAX_FETCH_BYTES: usize = 8 * 1024 * 1024; 5 pub(crate) const MAX_FETCH_EVENTS: usize = 4096; 6 pub(crate) const MAX_FETCH_NOTIFICATIONS: usize = 8192; 7 8 #[derive(Debug, Default)] 9 struct Usage { 10 bytes: usize, 11 events: usize, 12 notifications: usize, 13 wire_bytes: usize, 14 wire_messages: usize, 15 wire_data: usize, 16 exhausted: bool, 17 } 18 19 /// One monotonic inventory shared by all relay batches. Reservations are not 20 /// refunded when a duplicate, malformed event or completed batch is discarded. 21 #[derive(Debug, Default)] 22 pub(crate) struct FetchBudget(Mutex<Usage>, tokio::sync::Notify); 23 24 impl FetchBudget { 25 pub(crate) fn exhaust(&self) { 26 if let Ok(mut usage) = self.0.lock() { 27 usage.exhausted = true; 28 } 29 self.1.notify_waiters(); 30 } 31 pub(crate) fn wire(&self, bytes: usize, frames: usize, data: usize) -> bool { 32 let Ok(mut usage) = self.0.lock() else { 33 return false; 34 }; 35 if usage.exhausted 36 || bytes > MAX_FETCH_BYTES - usage.wire_bytes 37 || frames > MAX_FETCH_NOTIFICATIONS - usage.wire_messages 38 || data > MAX_FETCH_EVENTS - usage.wire_data 39 { 40 usage.exhausted = true; 41 self.1.notify_waiters(); 42 return false; 43 } 44 usage.wire_bytes += bytes; 45 usage.wire_messages += frames; 46 usage.wire_data += data; 47 true 48 } 49 50 pub(crate) fn exhausted(&self) -> bool { 51 self.0.lock().map_or(true, |usage| usage.exhausted) 52 } 53 54 pub(crate) async fn wait_exhausted(&self) { 55 loop { 56 let notified = self.1.notified(); 57 tokio::pin!(notified); 58 notified.as_mut().enable(); 59 if self.exhausted() { 60 return; 61 } 62 notified.await; 63 } 64 } 65 66 pub(super) fn notification(&self) -> bool { 67 let Ok(mut usage) = self.0.lock() else { 68 return false; 69 }; 70 if usage.exhausted || usage.notifications == MAX_FETCH_NOTIFICATIONS { 71 usage.exhausted = true; 72 self.1.notify_waiters(); 73 return false; 74 } 75 usage.notifications += 1; 76 true 77 } 78 79 pub(super) fn event(&self, bytes: usize) -> bool { 80 let Ok(mut usage) = self.0.lock() else { 81 return false; 82 }; 83 if usage.exhausted 84 || bytes > MAX_EVENT_BYTES 85 || usage.events == MAX_FETCH_EVENTS 86 || bytes > MAX_FETCH_BYTES - usage.bytes 87 { 88 usage.exhausted = true; 89 self.1.notify_waiters(); 90 return false; 91 } 92 usage.events += 1; 93 usage.bytes += bytes; 94 true 95 } 96 } 97 98 #[cfg(test)] 99 mod tests { 100 use super::*; 101 102 #[test] 103 fn each_maximum_is_accepted_and_the_next_unit_is_rejected() { 104 let bytes = FetchBudget::default(); 105 assert!(!FetchBudget::default().event(MAX_EVENT_BYTES + 1)); 106 for _ in 0..MAX_FETCH_BYTES / MAX_EVENT_BYTES { 107 assert!(bytes.event(MAX_EVENT_BYTES)); 108 } 109 assert!(!bytes.event(1)); 110 let events = FetchBudget::default(); 111 for _ in 0..MAX_FETCH_EVENTS { 112 assert!(events.event(1)); 113 } 114 assert!(!events.event(1)); 115 let notifications = FetchBudget::default(); 116 for _ in 0..MAX_FETCH_NOTIFICATIONS { 117 assert!(notifications.notification()); 118 } 119 assert!(!notifications.notification()); 120 } 121 122 #[test] 123 fn competing_relays_cannot_overreserve_the_aggregate_budget() { 124 let budget = FetchBudget::default(); 125 let accepted = std::thread::scope(|scope| { 126 let tasks = (0..8) 127 .map(|_| scope.spawn(|| (0..32).filter(|_| budget.event(MAX_EVENT_BYTES)).count())) 128 .collect::<Vec<_>>(); 129 tasks 130 .into_iter() 131 .map(|task| task.join().unwrap()) 132 .sum::<usize>() 133 }); 134 assert_eq!(accepted * MAX_EVENT_BYTES, MAX_FETCH_BYTES); 135 assert!(!budget.event(1)); 136 } 137 138 #[tokio::test] 139 async fn raw_bytes_frames_and_data_attempts_have_sticky_independent_limits() { 140 for (bytes, frames, data) in [ 141 (MAX_FETCH_BYTES, 0, 0), 142 (0, MAX_FETCH_NOTIFICATIONS, 0), 143 (0, 0, MAX_FETCH_EVENTS), 144 ] { 145 let budget = FetchBudget::default(); 146 assert!(budget.wire(bytes, frames, data)); 147 assert!(!budget.exhausted()); 148 assert!(!budget.wire( 149 usize::from(bytes > 0), 150 usize::from(frames > 0), 151 usize::from(data > 0) 152 )); 153 assert!(budget.exhausted()); 154 assert!(!budget.wire(0, 0, 0)); 155 assert!(!budget.event(0)); 156 assert!(!budget.notification()); 157 tokio::time::timeout(std::time::Duration::from_secs(1), budget.wait_exhausted()) 158 .await 159 .unwrap(); 160 } 161 } 162 163 #[tokio::test] 164 async fn exhaustion_wakes_every_waiter_without_lost_notifications() { 165 let budget = FetchBudget::default(); 166 let first = budget.wait_exhausted(); 167 let second = budget.wait_exhausted(); 168 tokio::pin!(first, second); 169 assert!(futures::poll!(&mut first).is_pending()); 170 assert!(futures::poll!(&mut second).is_pending()); 171 assert!(!budget.wire(MAX_FETCH_BYTES + 1, 0, 0)); 172 assert!(futures::poll!(&mut first).is_ready()); 173 assert!(futures::poll!(&mut second).is_ready()); 174 } 175 176 #[test] 177 fn poisoned_budget_refuses_every_inventory_entry_without_resetting_authority() { 178 let budget = FetchBudget::default(); 179 assert!(budget.wire(1, 1, 1)); 180 let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { 181 let _guard = budget.0.lock().unwrap(); 182 panic!("injected budget lock failure"); 183 })); 184 assert!(budget.exhausted()); 185 assert!(!budget.wire(0, 0, 0)); 186 assert!(!budget.notification()); 187 assert!(!budget.event(0)); 188 futures::executor::block_on(budget.wait_exhausted()); 189 } 190 }