lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }